What is Python?

Python is a popular programming language. It was created by Guido van Rossum,

and released in 1991.

It is used for:

● web development (server-side),

● software development,
● mathematics,
● system scripting.

History:

Python was conceived in the late 1980s by Guido Van Rossum began doing its
application-based work in December of 1989 by at Centrum Wickenden &
Informatica (CWI) which is situated in Netherland. It was started firstly as a hobby
project because he was looking for an interesting project to keep him occupied
during Christmas. The programming language which Python is said to have
succeeded is ABC Programming Language, which had the interfacing with the
Amoeba Operating System and had the feature of exception handling. He had
already helped to create ABC earlier in his career and he had seen some issues with
ABC but liked most of the features. After that what he did as really very clever. He
had taken the syntax of ABC, and some of its good features. It came with a lot of
complaints too, so he fixed those issues completely and had created a good scripting
language which had removed all the flaws. The inspiration for the name came from
BBC’s TV Show – ‘Monty Python’s Flying Circus’, as he was a big fan of the TV
show and also, he wanted a short, unique and slightly mysterious name for his
invention and hence he named it Python! He was the “Benevolent dictator for life”
(BDFL) until he stepped down from the position as the leader on 12th July 2018. For
quite some time he used to work for Google, but currently, he is working at Dropbox.
The language was finally released in 1991. When it was released, it used a lot fewer
codes to express the concepts, when we compare it with Java, C++ & C. Its design
philosophy was quite good too. Its main objective is to provide code readability and
advanced developer productivity. When it was released, it had more than enough
capability to provide classes with inheritance, several core data type exception
handling and functions.

Python 3.9 is the latest version.

The two of the most used versions has to Python 2.x & 3.x. There is a lot of
competition between the two and both of them seem to have quite a number of
different fanbase.
For various purposes such as developing, scripting, generation and software testing,
this language is utilized. Due to its elegance and simplicity, top technology
organizations like Dropbox, Google, Quora, Mozilla, Hewlett-Packard, Qualcomm,
IBM, and Cisco have implemented Python.
Python has come a long way to become the most popular coding language in the
world. Python has just turned 30, but it still has that unknown charm & X factor which
can be clearly seen from the fact that Google users have consistently searched for
Python much more than they have searched for Kim Kardashian, Donald Trump,
Tom Cruise etc.
Python has been an inspiration for many other coding languages such as Ruby,
Cobra, Boo, CoffeeScript ECMAScript, Groovy, Swift Go, OCaml, Julia etc.

Why Python?

● Python works on different platforms (Windows, Mac, Linux, Raspberry Pi, etc).
● Python has a simple syntax similar to the English language.
● Python has syntax that allows developers to write programs with fewer lines
than some other programming languages.
● Python runs on an interpreter system, meaning that code can be executed as
soon as it is written. This means that prototyping can be very quick.
● Python can be treated in a procedural way, an object-oriented way or a
functional way.

Python Syntax

● Python was designed for readability, and has some similarities to the English
language with influence from mathematics.
● Python uses new lines to complete a command, as opposed to other
programming languages which often use semicolons or parentheses.
● Python relies on indentation, using whitespace, to define scope; such as the
scope of loops, functions and classes. Other programming languages often
use curly-brackets for this purpose. Example:

print("Hello, World!")

Using the Python Interpreter Interactively

The most straightforward way to start talking to Python is in an

interactive Read-Eval-Print Loop (REPL) environment. That simply means starting
up the interpreter and typing commands to it directly. The interpreter:

● Reads the command you enter

● Evaluates and executes the command
 ● Prints the output (if any) to the console
● Loops back and repeats the process

For example, in Windows, there will likely be a program group in the Start menu
labelled Python 3.x, and under it a menu item labelled Python 3.x (32-bit), or
something similar depending on the particular installation you chose.

Alternatively, you can open a terminal window and run the interpreter from the
command line. How you go about opening a terminal window varies depending on
which operating system you’re using:

● In Windows, it is called Command Prompt.

● In macOS or Linux, it should be called Terminal.

More Control Flow Tools

Besides the while statement just introduced, Python uses the usual flow control
statements known from other languages, with some twists.
1.if Statements

Perhaps the most well-known statement type is the if statement. For example:

>>> x = int(input("Please enter an integer: "))

Please enter an integer: 42
>>> if x < 0:
... x = 0
... print('Negative changed to zero')
... elif x == 0:
... print('Zero')
... elif x == 1:
... print('Single')
... else:
... print('More')
...
More

There can be zero or more elif parts, and the else part is optional. The keyword ‘elif’
is short for ‘else if’, and is useful to avoid excessive indentation. An if … elif … elif …
sequence is a substitute for the switch or case statements found in other languages.

2.for Statements

The for statement in Python differs a bit from what you may be used to in C or
Pascal. Rather than always iterating over an arithmetic progression of numbers (like
in Pascal), or giving the user the ability to define both the iteration step and halting
condition (as C), Python’s for statement iterates over the items of any sequence (a
list or a string), in the order that they appear in the sequence. For example (no pun
intended):

>>> # Measure some strings:

... words = ['cat', 'window', 'defenestrate']
>>> for w in words:
... print(w, len(w))
...
cat 3
window 6
defenestrate 12

Code that modifies a collection while iterating over that same collection can be tricky
to get right. Instead, it is usually more straight-forward to loop over a copy of the
collection or to create a new collection:

# Strategy: Iterate over a copy

for user, status in users.copy().items():
if status == 'inactive':
del users[user]

# Strategy: Create a new collection

active_users = {}
for user, status in users.items():
if status == 'active':
active_users[user] = status

3. The range() Function

If you do need to iterate over a sequence of numbers, the built-in
function range() comes in handy. It generates arithmetic progressions:

>>> for i in range(5):

... print(i)
...
0
1
2
3
4

The given end point is never part of the generated sequence; range(10) generates
10 values, the legal indices for items of a sequence of length 10. It is possible to let
the range start at another number, or to specify a different increment (even negative;
sometimes this is called the ‘step’):

range(5, 10)
5, 6, 7, 8, 9

range(0, 10, 3)
0, 3, 6, 9

range(-10, -100, -30)

-10, -40, -70

To iterate over the indices of a sequence, you can combine range() and len() as
follows:

>>> a = ['Mary', 'had', 'a', 'little', 'lamb']

>>> for i in range(len(a)):
... print(i, a[i])
...
0 Mary
1 had
2a
3 little
4 lamb

In most such cases, however, it is convenient to use the enumerate() function,

see Looping Techniques.

A strange thing happens if you just print a range:

>>> print(range(10))
range(0, 10)
In many ways the object returned by range() behaves as if it is a list, but in fact it
isn’t. It is an object which returns the successive items of the desired sequence when
you iterate over it, but it doesn’t really make the list, thus saving space.

We say such an object is iterable, that is, suitable as a target for functions and
constructs that expect something from which they can obtain successive items until
the supply is exhausted. We have seen that the for statement is such a construct,
while an example of a function that takes an iterable is sum():

>>> sum(range(4)) # 0 + 1 + 2 + 3
6

Later we will see more functions that return iterables and take iterables as
arguments. Lastly, maybe you are curious about how to get a list from a range. Here
is the solution:

>>> list(range(4))
[0, 1, 2, 3]

4. break and continue Statements, and else Clauses on Loops

The break statement, like in C, breaks out of the innermost

enclosing for or while loop.

Loop statements may have an else clause; it is executed when the loop terminates
through exhaustion of the iterable (with for) or when the condition becomes false
(with while), but not when the loop is terminated by a break statement. This is
exemplified by the following loop, which searches for prime numbers:

>>> for n in range(2, 10):

... for x in range(2, n):
... if n % x == 0:
... print(n, 'equals', x, '*', n//x)
... break
... else:
... # loop fell through without finding a factor
... print(n, 'is a prime number')
...
2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3

(Yes, this is the correct code. Look closely: the else clause belongs to
the for loop, not the if statement.)

When used with a loop, the else clause has more in common with the else clause of
a try statement than it does with that of if statements: a try statement’s else clause
runs when no exception occurs, and a loop’s else clause runs when no break occurs.
For more on the try statement and exceptions, see Handling Exceptions.

The continue statement, also borrowed from C, continues with the next iteration of
the loop:

>>> for num in range(2, 10):

... if num % 2 == 0:
... print("Found an even number", num)
... continue
... print("Found an odd number", num)
Found an even number 2
Found an odd number 3
Found an even number 4
Found an odd number 5
Found an even number 6
Found an odd number 7
Found an even number 8
Found an odd number 9

5.pass Statements

The pass statement does nothing. It can be used when a statement is required
syntactically but the program requires no action. For example:

>>> while True:

... pass # Busy-wait for keyboard interrupt (Ctrl+C)
...

This is commonly used for creating minimal classes:

>>> class MyEmptyClass:

... pass
...

Another place pass can be used is as a place-holder for a function or conditional

body when you are working on new code, allowing you to keep thinking at a more
abstract level. The pass is silently ignored:
>>> def initlog(*args):
... pass # Remember to implement this!
...

6.Defining Functions

We can create a function that writes the Fibonacci series to an arbitrary boundary:

>>> def fib(n): # write Fibonacci series up to n

... """Print a Fibonacci series up to n."""
... a, b = 0, 1
... while a < n:
... print(a, end=' ')
... a, b = b, a+b
... print()
...
>>> # Now call the function we just defined:
... fib(2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

The keyword def introduces a function definition. It must be followed by the function
name and the parenthesized list of formal parameters. The statements that form the
body of the function start at the next line, and must be indented.

The first statement of the function body can optionally be a string literal; this string
literal is the function’s documentation string, or docstring. (More about docstrings can
be found in the section Documentation Strings.) There are tools which use
docstrings to automatically produce online or printed documentation, or to let the
user interactively browse through code; it’s good practice to include docstrings in
code that you write, so make a habit of it.

>>> fib
<function fib at 10042ed0>
>>> f = fib
>>> f(100)
0 1 1 2 3 5 8 13 21 34 55 89

Coming from other languages, you might object that fib is not a function but a
procedure since it doesn’t return a value. In fact, even functions without
a return statement do return a value, albeit a rather boring one. This value is
called None (it’s a built-in name). Writing the value None is normally suppressed by
the interpreter if it would be the only value written. You can see it if you really want to
using print():

>>> fib(0)
>>> print(fib(0))
None

It is simple to write a function that returns a list of the numbers of the Fibonacci
series, instead of printing it:

>>> def fib2(n): # return Fibonacci series up to n

... """Return a list containing the Fibonacci series up to n."""
... result = []
... a, b = 0, 1
... while a < n:
... result.append(a) # see below
... a, b = b, a+b
... return result
...
>>> f100 = fib2(100) # call it
>>> f100 # write the result
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

This example, as usual, demonstrates some new Python features:

● The return statement returns with a value from a function. return without an
expression argument returns None. Falling off the end of a function also
returns None.
● The statement result.append(a) calls a method of the list object result. A
method is a function that ‘belongs’ to an object and is
named obj.methodname, where obj is some object (this may be an
expression), and methodname is the name of a method that is defined by the
object’s type. Different types define different methods. Methods of different
types may have the same name without causing ambiguity. (It is possible to
define your own object types and methods, using classes, see Classes) The
method append () shown in the example is defined for list objects; it adds a
new element at the end of the list. In this example it is equivalent
to result = result + [a], but more efficient.

Data Structures
Data structures are the fundamental constructs around which you build your
programs. Each data structure provides a particular way of organizing data so it can
be accessed efficiently, depending on your use case. Python ships with an extensive
set of data structures in its standard library.
1.List:

● The list data type has some more methods. Here are all of the methods of list
objects:
● list.append(x)
● Add an item to the end of the list. Equivalent to a[len(a):] = [x].
● list.extend(iterable)
● Extend the list by appending all the items from the iterable. Equivalent
to a[len(a):] = iterable.
● list.insert(i, x)
● Insert an item at a given position. The first argument is the index of the
element before which to insert, so a.insert(0, x) inserts at the front of the list,
and a.insert(len(a), x) is equivalent to a.append(x).
● list.remove(x)
● Remove the first item from the list whose value is equal to x. It raises
a ValueError if there is no such item.
● list.pop([i])
● Remove the item at the given position in the list, and return it. If no index is
specified, a.pop() removes and returns the last item in the list. (The square
brackets around the i in the method signature denote that the parameter is
optional, not that you should type square brackets at that position. You will
see this notation frequently in the Python Library Reference.)
● list.clear()
● Remove all items from the list. Equivalent to del a[:].
● list.index(x[, start[, end]])
● Return zero-based index in the list of the first item whose value is equal to x.
Raises a ValueError if there is no such item.
● The optional arguments start and end are interpreted as in the slice notation
and are used to limit the search to a particular subsequence of the list. The
returned index is computed relative to the beginning of the full sequence
rather than the start argument.
● list.count(x)
● Return the number of times x appears in the list.
● list.sort(*, key=None, reverse=False)
● Sort the items of the list in place (the arguments can be used for sort
customization, see sorted() for their explanation).
● list.reverse()
● Reverse the elements of the list in place.
● list.copy()
● Return a shallow copy of the list. Equivalent to a[:].
● An example that uses most of the list methods:

● >>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']

● >>> fruits.count('apple')
● 2
● >>> fruits.count('tangerine')
● 0
● >>> fruits.index('banana')
● 3
● >>> fruits.index('banana', 4) # Find next banana starting a position 4
 ● 6
● >>> fruits.reverse()
● >>> fruits
● ['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
● >>> fruits.append('grape')
● >>> fruits
● ['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
● >>> fruits.sort()
● >>> fruits
● ['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
● >>> fruits.pop()
● 'pear'

2. The del statement

There is a way to remove an item from a list given its index instead of its value:
the del statement. This differs from the pop() method which returns a value.
The del statement can also be used to remove slices from a list or clear the entire list
(which we did earlier by assignment of an empty list to the slice). For example:

>>>
>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]

3. Tuples and Sequences

A tuple consists of a number of values separated by commas, for instance:

>>>
>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # Tuples may be nested:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
>>> # Tuples are immutable:
... t[0] = 88888
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> # but they can contain mutable objects:
... v = ([1, 2, 3], [3, 2, 1])
>>> v
([1, 2, 3], [3, 2, 1])

As you see, on output tuples are always enclosed in parentheses, so that nested
tuples are interpreted correctly; they may be input with or without surrounding
parentheses, although often parentheses are necessary anyway (if the tuple is part
of a larger expression). It is not possible to assign to the individual items of a tuple,
however it is possible to create tuples which contain mutable objects, such as lists.

4. Sets

Python also includes a data type for sets. A set is an unordered collection with no
duplicate elements. Basic uses include membership testing and eliminating duplicate
entries. Set objects also support mathematical operations like union, intersection,
difference, and symmetric difference.

Curly braces or the set() function can be used to create sets. Note: to create an
empty set you have to use set(), not {}; the latter creates an empty dictionary, a data
structure that we discuss in the next section.

Here is a brief demonstration:

>>>
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket) # show that duplicates have been removed
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket # fast membership testing
True
>>> 'crabgrass' in basket
False

>>> # Demonstrate set operations on unique letters from two words

...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a # unique letters in a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b # letters in a but not in b
{'r', 'd', 'b'}
>>> a | b # letters in a or b or both
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b # letters in both a and b
{'a', 'c'}
>>> a ^ b # letters in a or b but not both
{'r', 'd', 'b', 'm', 'z', 'l'}

5. Dictionaries

Another useful data type built into Python is the dictionary (see Mapping Types —
dict). Dictionaries are sometimes found in other languages as “associative
memories” or “associative arrays”. Unlike sequences, which are indexed by a range
of numbers, dictionaries are indexed by keys, which can be any immutable type;
strings and numbers can always be keys. Tuples can be used as keys if they contain
only strings, numbers, or tuples; if a tuple contains any mutable object either directly
or indirectly, it cannot be used as a key. You can’t use lists as keys, since lists can be
modified in place using index assignments, slice assignments, or methods
like append() and extend().

It is best to think of a dictionary as a set of key: value pairs, with the requirement that
the keys are unique (within one dictionary). A pair of braces creates an empty
dictionary: {}. Placing a comma-separated list of key:value pairs within the braces
adds initial key:value pairs to the dictionary; this is also the way dictionaries are
written on output.

The main operations on a dictionary are storing a value with some key and extracting
the value given the key. It is also possible to delete a key:value pair with del. If you
store using a key that is already in use, the old value associated with that key is
forgotten. It is an error to extract a value using a non-existent key.

Performing list(d) on a dictionary returns a list of all the keys used in the dictionary, in
insertion order (if you want it sorted, just use sorted(d) instead). To check whether a
single key is in the dictionary, use the in keyword.

Here is a small example using a dictionary:

>>> tel = {'jack': 4098, 'sape': 4139}

>>> tel['guido'] = 4127
>>> tel
{'jack': 4098, 'sape': 4139, 'guido': 4127}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'jack': 4098, 'guido': 4127, 'irv': 4127}
>>> list(tel)
['jack', 'guido', 'irv']
>>> sorted(tel)
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
False

The dict() constructor builds dictionaries directly from sequences of key-value pairs:

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])

{'sape': 4139, 'guido': 4127, 'jack': 4098}

In addition, dict comprehensions can be used to create dictionaries from arbitrary

key and value expressions:

>>> {x: x**2 for x in (2, 4, 6)}

{2: 4, 4: 16, 6: 36}

When the keys are simple strings, it is sometimes easier to specify pairs using
keyword arguments:

>>> dict(sape=4139, guido=4127, jack=4098)

{'sape': 4139, 'guido': 4127, 'jack': 4098}

6. Looping Techniques

When looping through dictionaries, the key and corresponding value can be retrieved
at the same time using the items() method.

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}

>>> for k, v in knights.items():
... print(k, v)
...
gallahad the pure
robin the brave

When looping through a sequence, the position index and corresponding value can
be retrieved at the same time using the enumerate() function.

>>> for i, v in enumerate(['tic', 'tac', 'toe']):

... print(i, v)
...
0 tic
1 tac
2 toe

To loop over two or more sequences at the same time, the entries can be paired with
the zip() function.

>>> questions = ['name', 'quest', 'favorite color']

>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
... print('What is your {0}? It is {1}.'.format(q, a))
...
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.

To loop over a sequence in reverse, first specify the sequence in a forward direction
and then call the reversed() function.

>>> for i in reversed(range(1, 10, 2)):

... print(i)
...
9
7
5
3
1

To loop over a sequence in sorted order, use the sorted() function which returns a
new sorted list while leaving the source unaltered.

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']

>>> for i in sorted(basket):
... print(i)
...
apple
apple
banana
orange
orange
pear

Using set() on a sequence eliminates duplicate elements. The use of sorted() in

combination with set() over a sequence is an idiomatic way to loop over unique
elements of the sequence in sorted order.

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']

>>> for f in sorted(set(basket)):
... print(f)
...
apple
banana
orange
pear

It is sometimes tempting to change a list while you are looping over it; however, it is
often simpler and safer to create a new list instead.

>>> import math

>>> raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]
>>> filtered_data = []
>>> for value in raw_data:
... if not math.isnan(value):
... filtered_data.append(value)
...
>>> filtered_data
[56.2, 51.7, 55.3, 52.5, 47.8]

Modules

If you quit from the Python interpreter and enter it again, the definitions you have
made (functions and variables) are lost. Therefore, if you want to write a somewhat
longer program, you are better off using a text editor to prepare the input for the
interpreter and running it with that file as input instead. This is known as creating
a script. As your program gets longer, you may want to split it into several files for
easier maintenance. You may also want to use a handy function that you’ve written
in several programs without copying its definition into each program.
To support this, Python has a way to put definitions in a file and use them in a script
or in an interactive instance of the interpreter. Such a file is called a module;
definitions from a module can be imported into other modules or into
the main module (the collection of variables that you have access to in a script
executed at the top level and in calculator mode).

A module is a file containing Python definitions and statements. The file name is the
module name with the suffix .py appended. Within a module, the module’s name (as
a string) is available as the value of the global variable __name__. For instance, use
your favorite text editor to create a file called fibo.py in the current directory with the
following contents:

# Fibonacci numbers module

def fib(n): # write Fibonacci series up to n

a, b = 0, 1
while a < n:
print(a, end=' ')
a, b = b, a+b
print()

def fib2(n): # return Fibonacci series up to n

result = []
a, b = 0, 1
while a < n:
result.append(a)
a, b = b, a+b
return result

Now enter the Python interpreter and import this module with the following
command:

>>> import fibo

This does not enter the names of the functions defined in fibo directly in the current
symbol table; it only enters the module name fibo there. Using the module name you
can access the functions:

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'

If you intend to use a function often you can assign it to a local name:

>>> fib = fibo.fib

>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

o A module can contain executable statements as well as function definitions.

These statements are intended to initialize the module. They are executed
only the first time the module name is encountered in an import
statement. 1 (They are also run if the file is executed as a script.)
o Each module has its own private symbol table, which is used as the global
symbol table by all functions defined in the module. Thus, the author of a
module can use global variables in the module without worrying about
accidental clashes with a user’s global variables. On the other hand, if you
know what you are doing you can touch a module’s global variables with the
same notation used to refer to its functions, modname.itemname.
o Modules can import other modules. It is customary but not required to place
all import statements at the beginning of a module (or script, for that matter).
The imported module names are placed in the importing module’s global
symbol table.

There is a variant of the import statement that imports names from a module directly
into the importing module’s symbol table. For example:

>>>
>>> from fibo import fib, fib2
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

This does not introduce the module name from which the imports are taken in the
local symbol table (so in the example, fibo is not defined).

There is even a variant to import all names that a module defines:

>>> from fibo import *

>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
This imports all names except those beginning with an underscore (_). In most cases
Python programmers do not use this facility since it introduces an unknown set of
names into the interpreter, possibly hiding some things you have already defined.

Executing modules as scripts

When you run a Python module with

python fibo.py <arguments>

the code in the module will be executed, just as if you imported it, but with
the __name__ set to "__main__". That means that by adding this code at the end of
your module:

if __name__ == "__main__":
import sys
fib(int(sys.argv[1]))

you can make the file usable as a script as well as an importable module, because
the code that parses the command line only runs if the module is executed as the
“main” file:

$ python fibo.py 50
0 1 1 2 3 5 8 13 21 34

If the module is imported, the code is not run:

>>> import fibo

>>>

This is often used either to provide a convenient user interface to a module, or for
testing purposes (running the module as a script executes a test suite).

The Module Search Path

When a module named spam is imported, the interpreter first searches for a built-in
module with that name. If not found, it then searches for a file named spam.py in a
list of directories given by the variable sys.path. sys.path is initialized from these
locations:

● The directory containing the input script (or the current directory when no file
is specified).
 ● PYTHONPATH (a list of directory names, with the same syntax as the shell
variable PATH).
● The installation-dependent default.

“Compiled” Python files

To speed up loading modules, Python caches the compiled version of each module
in the __pycache__ directory under the name module.version.pyc, where the version
encodes the format of the compiled file; it generally contains the Python version
number. For example, in CPython release 3.3 the compiled version of spam.py
would be cached as __pycache__/spam.cpython-33.pyc. This naming convention
allows compiled modules from different releases and different versions of Python to
coexist.

Standard Modules

Python comes with a library of standard modules, described in a separate document,

the Python Library Reference (“Library Reference” hereafter). Some modules are
built into the interpreter; these provide access to operations that are not part of the
core of the language but are nevertheless built in, either for efficiency or to provide
access to operating system primitives such as system calls. The set of such modules
is a configuration option which also depends on the underlying platform. For
example, the winreg module is only provided on Windows systems. One particular
module deserves some attention: sys, which is built into every Python interpreter.
The variables sys.ps1 and sys.ps2 define the strings used as primary and secondary
prompts:

>>> import sys

>>> sys.ps1
'>>> '
>>> sys.ps2
'... '
>>> sys.ps1 = 'C> '
C> print('Yuck!')
Yuck!
C>

These two variables are only defined if the interpreter is in interactive mode.

The variable sys.path is a list of strings that determines the interpreter’s search path
for modules. It is initialized to a default path taken from the environment
variable PYTHONPATH, or from a built-in default if PYTHONPATH is not set. You
can modify it using standard list operations:

>>> import sys

>>> sys.path.append('/ufs/guido/lib/python')

The dir() Function

The built-in function dir() is used to find out which names a module defines. It returns
a sorted list of strings:

>>>
>>> import fibo, sys
>>> dir(fibo)
['__name__', 'fib', 'fib2']
>>> dir(sys)
['__breakpointhook__', '__displayhook__', '__doc__', '__excepthook__',
'__interactivehook__', '__loader__', '__name__', '__package__', '__spec__',
'__stderr__', '__stdin__', '__stdout__', '__unraisablehook__',
'_clear_type_cache', '_current_frames', '_debugmallocstats', '_framework',
'_getframe', '_git', '_home', '_xoptions', 'abiflags', 'addaudithook',
'api_version', 'argv', 'audit', 'base_exec_prefix', 'base_prefix',
'breakpointhook', 'builtin_module_names', 'byteorder', 'call_tracing',
'callstats', 'copyright', 'displayhook', 'dont_write_bytecode', 'exc_info',
'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info',
'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_origin_tracking_depth',
'getallocatedblocks', 'getdefaultencoding', 'getdlopenflags',
'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile',
'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval',
'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info',
'intern', 'is_finalizing', 'last_traceback', 'last_type', 'last_value',
'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks',
'path_importer_cache', 'platform', 'prefix', 'ps1', 'ps2', 'pycache_prefix',
'set_asyncgen_hooks', 'set_coroutine_origin_tracking_depth', 'setdlopenflags',
'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr',
'stdin', 'stdout', 'thread_info', 'unraisablehook', 'version', 'version_info',
'warnoptions']

Without arguments, dir() lists the names you have defined currently:

>>>
>>> a = [1, 2, 3, 4, 5]
>>> import fibo
>>> fib = fibo.fib
>>> dir()
['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys']
Note that it lists all types of names: variables, modules, functions, etc.

dir() does not list the names of built-in functions and variables.

Packages

Packages are a way of structuring Python’s module namespace by using “dotted

module names”. For example, the module name A.B designates a submodule
named B in a package named A. Just like the use of modules saves the authors of
different modules from having to worry about each other’s global variable names, the
use of dotted module names saves the authors of multi-module packages like
NumPy or Pillow from having to worry about each other’s module names.

Users of the package can import individual modules from the package, for example:

import sound.effects.echo

This loads the submodule sound.effects.echo. It must be referenced with its full
name.

sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

An alternative way of importing the submodule is:

from sound.effects import echo

This also loads the submodule echo, and makes it available without its package
prefix, so it can be used as follows:

echo.echofilter(input, output, delay=0.7, atten=4)

Yet another variation is to import the desired function or variable directly:

from sound.effects.echo import echofilter

Input and Output

Sometimes a developer might want to take input from the user at some point in the
program. To do this Python provides an input() function.
Syntax:
input('prompt')
where, prompt is a string that is displayed on the string at the time of taking input.