Module - 5

LISTS, TUPLES, DICTIONARIES

Lists: list operations, list slices, list methods, list loop, mutability, aliasing, cloning lists, list
parameters, list comprehension; Tuples: tuple assignment, tuple as return value, tuple
comprehension; Dictionaries: operations and methods, comprehension;

Lists, Tuples, Dictionaries:

List:

It is a general purpose most widely used in data structures

List is a collection which is ordered and changeable and allows duplicate members.
(Grow and shrink as needed, sequence type, sortable).
To use a list, you must declare it first. Do this using square brackets and separate
values with commas.
We can construct / create list in many ways.
Ex:
>>> list1=[1,2,3,'A','B',7,8,[10,11]]
>>> print(list1)
[1, 2, 3, 'A', 'B', 7, 8, [10, 11]]

>>> x=list()
>>> x
[]

>>> tuple1=(1,2,3,4)
>>> x=list(tuple1)
>>> x
[1, 2, 3, 4]

71
List operations:
These operations include indexing, slicing, adding, multiplying, and checking for
membership

Basic List Operations:

Lists respond to the + and * operators much like strings; they mean concatenation and
repetition here too, except that the result is a new list, not a string.

Python Expression Results Description

len([1, 2, 3]) 3 Length

[1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] Concatenation

['Hi!'] * 4 ['Hi!', 'Hi!', 'Hi!', 'Hi!'] Repetition

3 in [1, 2, 3] True Membership

for x in [1, 2, 3]: print x, 123 Iteration

Indexing, Slicing, and Matrixes

Because lists are sequences, indexing and slicing work the same way for lists as they do for
strings.

L = ['vtu', 'department', 'VTU!']

Python Expression Results Description

L[2] VTU Offsets start at zero

72
 L[-2] department Negative: count from the right

L[1:] ['department', Slicing fetches sections

'VTU!']

List slices:

>>> list1=range(1,6)
>>> list1
range(1, 6)
>>> print(list1)
range(1, 6)
List methods:
The list data type has some more methods. Here are all of the methods of list objects:
Del()
Append()
Extend()
Insert()
Pop()
Remove()
Reverse()
Sort()
Delete: Delete a list or an item from a list
>>> x=[5,3,8,6]
>>> del(x[1]) #deletes the index position 1 in a list
>>> x
[5, 8, 6]

>>> del(x)
>>> x # complete list gets deleted
91
Append: Append an item to a list
>>> x=[1,5,8,4]
>>> x.append(10)
>>> x
[1, 5, 8, 4, 10]
Extend: Append a sequence to a list.
>>> x=[1,2,3,4]
>>> y=[3,6,9,1]
>>> x.extend(y)
>>> x
[1, 2, 3, 4, 3, 6, 9, 1]
Insert: To add an item at the specified index, use the insert () method:

>>> x=[1,2,4,6,7]
>>> x.insert(2,10) #insert(index no, item to be inserted)

>>> x

[1, 2, 10, 4, 6, 7]

>>> x.insert(4,['a',11])

>>> x

[1, 2, 10, 4, ['a', 11], 6, 7]

Pop: The pop() method removes the specified index, (or the last item if index is not
specified) or simply pops the last item of list and returns the item.

>>> x=[1, 2, 10, 4, 6, 7]

>>> x.pop()

>>> x
92
[1, 2, 10, 4, 6]

>>> x=[1, 2, 10, 4, 6]

>>> x.pop(2)

10

>>> x

[1, 2, 4, 6]

Remove: The remove() method removes the specified item from a given list.

>>> x=[1,33,2,10,4,6]

>>> x.remove(33)

>>> x
[1, 2, 10, 4, 6]

>>> x.remove(4)

>>> x

[1, 2, 10, 6]

Reverse: Reverse the order of a given list.

>>> x=[1,2,3,4,5,6,7]
>>> x.reverse()
>>> x
[7, 6, 5, 4, 3, 2, 1]
Sort: Sorts the elements in ascending order
>>> x=[7, 6, 5, 4, 3, 2, 1]

>>> x.sort()

>>> x

[1, 2, 3, 4, 5, 6, 7]

93
>>> x=[10,1,5,3,8,7]

>>> x.sort()

>>> x

[1, 3, 5, 7, 8, 10]

List loop:

Loops are control structures used to repeat a given section of code a certain number of times
or until a particular condition is met.

Method #1: For loop

#list of items

list = ['V','T','U']
i=1

#Iterating over the list

for item in list:
print ('department ',i,' is
',item) i = i+1
Output:

C:/Users/VTU/Programs/Python/Python38-32/pyyy/lis.py department 1 is
M
department 2 is
R
department 3 is
C
department 4 is
E
department5 is
T
Method #2: For loop and range()
In case we want to use the traditional for loop which iterates from number x to number
y. # Python3 code to iterate over a list
list = [1, 3, 5, 7, 9]

94
# getting length of list
length = len(list)
# Iterating the index
# same as 'for i in range(len(list))'
for i in range(length):
print(list[i])

Output:
C:/Users/VTU/ Programs/Python/Python38-32/pyyy/listlooop.py 1
3
5
7
9
Method #3: using while loop

# Python3 code to iterate over a list

list = [1, 3, 5, 7, 9]

# Getting length of list

length = len(list)
i=0

# Iterating using while loop

while i < length:
print(list[i])
i += 1

Mutability:

A mutable object can be changed after it is created, and an immutable object can't.

Append: Append an item to a list

>>> x=[1,5,8,4]
>>> x.append(10)
>>> x
[1, 5, 8, 4, 10]
Extend: Append a sequence to a list.
>>> x=[1,2,3,4]
95
>>> y=[3,6,9,1]
>>> x.extend(y)
>>> x
Delete: Delete a list or an item from a list
>>> x=[5,3,8,6]
>>> del(x[1]) #deletes the index position 1 in a list
>>> x
[5, 8, 6]
Insert: To add an item at the specified index, use the insert () method:

>>> x=[1,2,4,6,7]

>>> x.insert(2,10) #insert(index no, item to be inserted)

>>> x

[1, 2, 10, 4, 6, 7]

>>> x.insert(4,['a',11])

>>> x

[1, 2, 10, 4, ['a', 11], 6, 7]

Pop: The pop() method removes the specified index, (or the last item if index is not
specified) or simply pops the last item of list and returns the item.

>>> x=[1, 2, 10, 4, 6, 7]

>>> x.pop()

>>> x

[1, 2, 10, 4, 6]

>>> x=[1, 2, 10, 4, 6]

96
>>> x.pop(2)

10

>>> x

[1, 2, 4, 6]

Remove: The remove() method removes the specified item from a given list.

>>> x=[1,33,2,10,4,6]

>>> x.remove(33)

>>> x

[1, 2, 10, 4, 6]
>>> x.remove(4)

>>> x

[1, 2, 10, 6]

Reverse: Reverse the order of a given list.

>>> x=[1,2,3,4,5,6,7]
>>> x.reverse()
>>> x
[7, 6, 5, 4, 3, 2, 1]
Sort: Sorts the elements in ascending order
>>> x=[7, 6, 5, 4, 3, 2, 1]

>>> x.sort()

>>> x

[1, 2, 3, 4, 5, 6, 7]

>>> x=[10,1,5,3,8,7]

>>> x.sort()

97
>>> x

[1, 3, 5, 7, 8, 10]

Aliasing:
1. An alias is a second name for a piece of data, often easier (and more useful) than
making a copy.
2.
3. But if data can change, aliases can result in lot of hard to find bugs.
4.

For ex:
a = [81, 82, 83]
b = [81, 82, 83]
print(a == b)
print(a is b)
b=a
print(a == b)
print(a is b)
b[0] = 5
print(a)
Output:
C:/Users/VTU /Programs/Python/Python38-32/pyyy/alia.py True
False
True
True
[5, 82, 83]

Because the same list has two different names, a and b, we say that it is aliased. Changes
made with one alias affect the other. In the example above, you can see that a and b refer to
the same list after executing the assignment statement b = a.
Cloning Lists:

If we want to modify a list and also keep a copy of the original, we need to be able to make a
copy of the list itself, not just the reference. This process is sometimes called cloning, to
avoid the ambiguity of the word copy.

The easiest way to clone a list is to use the slice operator. Taking any slice of a creates a new
list. In this case the slice happens to consist of the whole list.

Example:
98
a = [81, 82, 83]

b = a[:] # make a clone using slice

print(a == b)

print(a is b)

b[0] = 5

print(a)

print(b)

Output:

C:/Users/VTU/Programs/Python/Python38-32/pyyy/clo.py

True
False
[81, 82, 83]
[5, 82, 83]
Now we are free to make changes to b without worrying about a

List parameters:

Passing a list as an argument actually passes a reference to the list, not a copy of the list.
Since lists are mutable, changes made to the elements referenced by the parameter change
the same list that the argument is referencing.

# for example, the function below takes a list as an argument and multiplies each element
in the list by 2:

def doubleStuff(List):

""" Overwrite each element in aList with double its value. """

for position in range(len(List)):

List[position] = 2 * List[position]

things = [2, 5, 9]

print(things)

99
doubleStuff(things)

print(things)

Output:
C:/Users/VTU/AppData/Local/Programs/Python/Python38-32/lipar.py ==

[2, 5, 9]

[4, 10, 18]

List comprehension:

List:

List comprehensions provide a concise way to create lists. Common applications are to make
new lists where each element is the result of some operations applied to each member of
another sequence or iterable, or to create a subsequence of those elements that satisfy a
certain condition.

For example, assume we want to create a list of squares, like:

>>> list1=[]

>>> for x in range(10):

list1.append(x**2)

>>> list1

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

(or)

This is also equivalent to

>>> list1=list(map(lambda x:x**2, range(10)))

>>> list1

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

91
0
(or)

Which is more concise and redable.

>>> list1=[x**2 for x in range(10)]

>>> list1

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Similarily some examples:

>>> x=[m for m in range(8)]

>>> print(x)
[0, 1, 2, 3, 4, 5, 6, 7]

>>> x=[z**2 for z in range(10) if z>4]

>>> print(x)
[25, 36, 49, 64, 81]

>>> x=[x ** 2 for x in range (1, 11) if x % 2 == 1]

>>> print(x)
[1, 9, 25, 49, 81]

>>> a=5
>>> table = [[a, b, a * b] for b in range(1, 11)]
>>> for i in table:
print(i)

[5, 1, 5]
[5, 2, 10]
[5, 3, 15]
[5, 4, 20]
[5, 5, 25]
[5, 6, 30]
[5, 7, 35]
[5, 8, 40]
[5, 9, 45]
[5, 10, 50]

91
1
Tuples:

A tuple is a collection which is ordered and unchangeable. In Python tuples are written
with round brackets.
Supports all operations for sequences.
Immutable, but member objects may be mutable

91
2
accidently being added, changed, or deleted.

We can construct tuple in many ways:

X=() #no item tuple
X=(1,2,3)
X=tuple(list1)
X=1,2,3,4

Example:
>>> x=(1,2,3)
>>> print(x)
(1, 2, 3)
>>> x
(1, 2, 3)

>>> x=()
>>> x
()

>>> x=[4,5,66,9]
>>> y=tuple(x)
>>> y
(4, 5, 66, 9)

>>> x=1,2,3,4
>>> x
(1, 2, 3, 4)

Some of the operations of tuple are:

Access tuple items
Change tuple items
Loop through a tuple
Count()
Index()
Length()

91
3
Access tuple items: Access tuple items by referring to the index number, inside square
brackets
>>> x=('a','b','c','g')
>>> print(x[2])
c
Change tuple items: Once a tuple is created, you cannot change its values. Tuples
are unchangeable.

>>> x=(2,5,7,'4',8)
>>> x[1]=10
Traceback (most recent call last):
File "<pyshell#41>", line 1, in <module>
x[1]=10
TypeError: 'tuple' object does not support item assignment
>>> x
(2, 5, 7, '4', 8) # the value is still the same

Loop through a tuple: We can loop the values of tuple using for loop
>>> x=4,5,6,7,2,'aa'
>>> for i in x:
print(i)

4
5
6
7
2
aa

Count (): Returns the number of times a specified value occurs in a tuple
>>> x=(1,2,3,4,5,6,2,10,2,11,12,2)
>>> x.count(2)
4

Index (): Searches the tuple for a specified value and returns the position of where it
was found

91
4
>>> x=(1,2,3,4,5,6,2,10,2,11,12,2)
>>> x.index(2)
1

(Or)

>>> x=(1,2,3,4,5,6,2,10,2,11,12,2)
>>> y=x.index(2)
>>> print(y)
1

Length (): To know the number of items or values present in a tuple, we use len().
>>> x=(1,2,3,4,5,6,2,10,2,11,12,2)
>>> y=len(x)
>>> print(y)
12

Tuple Assignment

Python has tuple assignment feature which enables you to assign more than one variable at a
time. In here, we have assigned tuple 1 with the department information like department
name, year, etc. and another tuple 2 with the values in it like number (1, 2, 7).

For Example,

Here is the code,

>>> tup1 = ('vtu', 'eng department','2004','mba', 'it','csit');

>>> tup2 = (1,2,3,4,5,6,7);

>>> print(tup1[0])

vtu

>>> print(tup2[1:4])

(2, 3, 4)

Tuple 1 includes list of information of vtu

Tuple 2 includes list of numbers in it

91
5
We call the value for [0] in tuple and for tuple 2 we call the value between 1 and 4

Run the above code- It gives name vtu for first tuple while for second tuple it gives
number (2, 3, 4)

Tuple as return values:

A Tuple is a comma separated sequence of items. It is created with or without (). Tuples are
immutable.

# A Python program to return multiple values from a method using tuple

# This function returns a tuple

def fun():
str = "vtu
department" x =
20
return str, x; # Return tuple, we could also
# write (str, x)
# Driver code to test above method
str, x = fun() # Assign returned tuple
print(str)
print(x)

Output:
C:/Users/VTU /Programs/Python/Python38-32/tupretval.py vtu department
20

Functions can return tuples as return values.

def circleInfo(r):
""" Return (circumference, area) of a circle of radius r """
c = 2 * 3.14159 * r
a = 3.14159 * r * r
return (c, a)
print(circleInfo(10))
Output:
C:/Users/VTU/Programs/Python/Python38-32/functupretval.py (62.8318, 314.159)

91
6
def f(x):
y0 = x + 1
y1 = x * 3
y2 = y0 ** y3
return (y0, y1, y2)

Tuple comprehension:
Tuple Comprehensions are special: The result of a tuple comprehension is special. You
might expect it to produce a tuple, but what it does is produce a special "generator"
object that we can iterate over.

For example:
>>> x = (i for i in 'abc') #tuple comprehension
>>> x
<generator object <genexpr> at 0x033EEC30>

>>> print(x)
<generator object <genexpr> at 0x033EEC30>

You might expect this to print as ('a', 'b', 'c') but it prints as <generator object <genexpr>
at 0x02AAD710> The result of a tuple comprehension is not a tuple: it is actually a
generator. The only thing that you need to know now about a generator now is that you
can iterate over it, but ONLY ONCE.
So, given the code

>>> x = (i for i in 'abc')

>>> for i in x:
print(i)

a
b
c
Create a list of 2-tuples like (number, square):
>>> z=[(x, x**2) for x in range(6)]
>>> z
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]
91
7
Set:
Similarly to list comprehensions, set comprehensions are also supported:

>>> a = {x for x in 'abracadabra' if x not in 'abc'}

>>> a
{'r', 'd'}

>>> x={3*x for x in range(10) if x>5}

>>> x
{24, 18, 27, 21}

Dictionaries:

A dictionary is a collection which is unordered, changeable and indexed. In Python

dictionaries are written with curly brackets, and they have keys and values.
Key-value pairs
Unordered
We can construct or create dictionary like:

Example:
>>> dict1 = {"brand":"vtu","model":"department","year":2004}
>>> dict1
{'brand': 'vtu', 'model': 'department', 'year': 2004}

Operations and methods:

Methods that are available with dictionary are tabulated below. Some of them have already
been used in the above examples.

Method Description

clear() Remove all items form the dictionary.

91
8
 copy() Return a shallow copy of the dictionary.

Return a new dictionary with keys from seq and

fromkeys(seq[, v]) value equal to v (defaults to None).

Return the value of key. If key doesnot exit,

get(key[,d]) return d (defaults to None).

Return a new view of the dictionary's items

items() (key, value).

keys() Return a new view of the dictionary's keys.

Remove the item with key and return its value

or d if key is not found. If d is not provided
pop(key[,d]) and key is not found, raises KeyError.

Remove and return an arbitary item (key,

value). Raises KeyError if the dictionary is
popitem() empty.

If key is in the dictionary, return its value. If

not, insert key with a value of d and
setdefault(key[,d]) return d (defaults to None).

Update the dictionary with the key/value pairs

update([other]) from other, overwriting existing keys.

values() Return a new view of the dictionary's values

Below are some dictionary operations:

91
9
To access specific value of a dictionary, we must pass its key,
>>> dict1 = {"brand":"vtu","model":"department","year":2004}
>>> x=dict1["brand"]
>>> x
'vtu'

To access keys and values and items of dictionary:

>>> dict1 = {"brand":"vtu","model":"department","year":2004}
>>> dict1.keys()
dict_keys(['brand', 'model', 'year'])
>>> dict1.values() dict_values(['vtu',
'department', 2004])
>>> dict1.items()
dict_items([('brand', 'vtu'), ('model', 'department'), ('year', 2004)])

>>> for items in dict1.values():

print(items)

vtu
depart
ment
2004

>>> for items in dict1.keys():

print(items)
brand
model
year

>>> for i in dict1.items():

print(i)
('brand', 'vtu')
('model', 'department')
('year', 2004)

Some more operations like:

Add/change

92
0
 Remove
Length
Delete

Add/change values: You can change the value of a specific item by referring to its key
name

>>> dict1 = {"brand":"vtu","model":"department","year":2004}

>>> dict1["year"]=2005
>>> dict1
{'brand': 'vtu', 'model': 'department', 'year': 2005}

Remove(): It removes or pop the specific item of dictionary.

>>> dict1 = {"brand":"vtu","model":"department","year":2004}

>>> print(dict1.pop("model"))
department
>>> dict1
{'brand': 'vtu', 'year': 2005}

Delete: Deletes a particular item.

>>> x = {1:1, 2:4, 3:9, 4:16, 5:25}

>>> del x[5]
>>> x

Length: we use len() method to get the length of dictionary.

>>>{1: 1, 2: 4, 3: 9, 4: 16}
{1: 1, 2: 4, 3: 9, 4: 16}
>>> y=len(x)
>>> y
4
Iterating over (key, value) pairs:
>>> x = {1:1, 2:4, 3:9, 4:16, 5:25}
>>> for key in x:
print(key, x[key])

11
24
39
100
4 16
5 25
>>> for k,v in x.items():
print(k,v)
11
24
39
4 16
5 25

List of Dictionaries:

>>> customers = [{"uid":1,"name":"John"},

{"uid":2,"name":"Smith"},
{"uid":3,"name":"Andersson"},
]
>>> >>> print(customers)
[{'uid': 1, 'name': 'John'}, {'uid': 2, 'name': 'Smith'}, {'uid': 3, 'name': 'Andersson'}]

## Print the uid and name of each customer

>>> for x in customers:
print(x["uid"], x["name"])

1 John
2 Smith
3 Andersson

## Modify an entry, This will change the name of customer 2 from Smith to Charlie
>>> customers[2]["name"]="charlie"
>>> print(customers)
[{'uid': 1, 'name': 'John'}, {'uid': 2, 'name': 'Smith'}, {'uid': 3, 'name': 'charlie'}]

## Add a new field to each entry

>>> for x in customers:

x["password"]="123456" # any initial value

>>> print(customers)
[{'uid': 1, 'name': 'John', 'password': '123456'}, {'uid': 2, 'name': 'Smith', 'password':
'123456'}, {'uid': 3, 'name': 'charlie', 'password': '123456'}]

## Delete a field
103
>>> del customers[1]
>>> print(customers)
[{'uid': 1, 'name': 'John', 'password': '123456'}, {'uid': 3, 'name': 'charlie', 'password':
'123456'}]

>>> del customers[1]

>>> print(customers)
[{'uid': 1, 'name': 'John', 'password': '123456'}]

## Delete all fields

>>> for x in customers:

del x["uid"]

>>> x
{'name': 'John', 'password': '123456'}

Comprehension:

Dictionary comprehensions can be used to create dictionaries from arbitrary key and
value expressions:

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

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

>>> dict11 = {x: x*x for x in range(6)}

>>> dict11
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

103
 Module 6
FILES, EXCEPTIONS, MODULES, PACKAGES

Files and exception: text files, reading and writing files, command line arguments, errors
and exceptions, handling exceptions, modules (datetime, time, OS , calendar, math module),
Explore packages.

Files, Exceptions, Modules, Packages:

Files and exception:

A file is some information or data which stays in the computer storage devices. Python gives
you easy ways to manipulate these files. Generally files divide in two categories,
text file and binary file. Text files are simple text where as the binary files contain binary
data which is only readable by computer.

Text files: In this type of file, Each line of text is terminated with a special character
\

Binary files: In this type of file, there is no terminator for a line and the data is stored
after converting it into machine understandable binary language.

An exception is an event, which occurs during the execution of a program that disrupts the
normal flow of the program's instructions. In general, when a Python script encounters a
situation that it cannot cope with, it raises an exception. An exception is a Python object
that represents an error.

Text files:

We can create the text files by using the syntax:

Variable name=open

For ex: f= open ("hello.txt","w+")

We declared the variable f to open a file named hello.txt. Open takes 2 arguments, the
file that we want to open and a string that represents the kinds of permission or
operation we want to do on the file
Here we used "w" letter in our argument, which indicates write and the plus sign that
103
means it will create a file if it does not exist in library

103
 The available option beside "w" are "r" for read and "a" for append and plus sign
means if it is not there then create it

File Modes in Python:

Mode Description

'r' This is the default mode. It Opens file for reading.

'w' This Mode Opens file for writing.

If file does not exist, it creates a new file.
If file exists it truncates the file.

'x' Creates a new file. If file already exists, the operation fails.

'a' Open file in append mode.

If file does not exist, it creates a new file.

't' This is the default mode. It opens in text mode.

'b' This opens in binary mode.

'+' This will open a file for reading and writing (updating)

Reading and Writing files:

The following image shows how to create and open a text file in notepad from command
prompt

104
(or)

Hit on enter then it shows the following whether to open or not?

# Write a python program to open and read a file

print(a.read())

105
a.close()

Output:
C:/Users/VTU /Programs/Python/Python38-32/filess/f1.py welcome to python
programming

(or)

Note: All the program files and text files need to saved together in a particular file then
only the program performs the operations in the given file mode

f.close() ---- This will close the instance of the file somefile.txt stored

# Write a python program

f=open("1.txt","a")

f.write("hello world")

f.close()

Output:

106
(or)

Note: In the above program the 1.txt file is created automatically and adds hello world
into txt file

If we keep on executing the same program for more than one time then it append the data
that many times

#
existing file.

f=open("1.txt",'w')

f.write("hi python programming")

f.close()

Output:

In the above program the hello txt file consist of data like

107
But when we try to write some data on to the same file it overwrites and saves with the
current data (check output)

# Write a python program to open and write the content to file and read it.

fo=open("abc.txt","w+")

fo.write("Python Programming")

print(fo.read())

fo.close()

Output:

(or)

Note: It creates the abc.txt file automatically and writes the data into it

108
Command line arguments:

The command line arguments must be given whenever we want to give the input before the
start of the script, while on the other hand, raw_input() is used to get the input while the
python program / script is running.

The command line arguments in python can be process

Python sys module stores the command line arguments into a list, we can access it
using sys.argv. This is very useful and simple way to read command line arguments as
String.
sys.argv is the list of commandline arguments passed to the Python program. argv represents
all the items that come along via the command line input, it's basically an array holding the
command line arguments of our program

>>> sys.modules.keys() -- this prints so many dict elements in the form of list.

# Python code to demonstrate the use of 'sys' module for command line arguments

import sys

# command line arguments are stored in the form

# of list in sys.argv
argumentList = sys.argv
print(argumentList)

# Print the name of file

print(sys.argv[0])

# Print the first argument after the name of file

#print(sys.argv[1])

Output:
C:/Users/VTU /Programs/Python/Python38-32/cmndlinarg.py

['C:/Users/VTU /Programs/Python/Python38-32/cmndlinarg.py'] C:/Users/VTU/

/Programs/Python/Python38-32/cmndlinarg.py

109
 Note:

IndexError: list index out of range

import sys

print(type(sys.argv))
print('The command line arguments are:')
for i in sys.argv:
print(i)

Output:
C:/Users/VTU /Programs/Python/Python38-32/symod.py ==
<class 'list'>
The command line arguments are: C:/Users/VTU/
/Programs/Python/Python38-32/symod.py

# write a python program to get python version.

import sys
print("System version is:")
print(sys.version)
print("Version Information is:")
print(sys.version_info)

Output:
C:/Users/VTU/AppData/Local/Programs/Python/Python38-32/pyyy/s1.py =
System version is:
3.8.0 (tags/v3.8.0:fa919fd, Oct 14 2019, 19:21:23) [MSC v.1916 32 bit (Intel)]
Version Information is:
sys.version_info(major=3, minor=8, micro=0, releaselevel='final', serial=0)

Python getopt module is very similar in working as the C getopt() function for parsing
command-line parameters. Python getopt module is useful in parsing command line
arguments where we want user to enter some options too.

>>> parser = argparse.ArgumentParser(description='Process some integers.')

110
#

111
import argparse

parser = argparse.ArgumentParser()
print(parser.parse_args())

Python argparse module is the preferred way to parse command line arguments. It provides a
lot of option such as positional arguments, default value for arguments, help message,
specifying data type of argument etc

It parses the command line options and parameter list. The signature of this function is
mentioned below:

getopt.getopt(args, shortopts, longopts=[ ])

args are the arguments to be passed.

shortopts is the options this script accepts.
Optional parameter, longopts is the list of String parameters this function accepts
which should be supported. Note that the -- should not be prepended with option
names.

-h------------print help and usage message

-m------------accept custom option value
-d------------run the script in debug mode

import getopt
import sys

argv = sys.argv[0:]
try:
opts, args = getopt.getopt(argv, 'hm:d', ['help', 'my_file='])
#print(opts)
print(args)
except getopt.GetoptError:
# Print a message or do something useful
print('Something went wrong!')
sys.exit(2)

112
Output:
C:/Users/VTU/AppData/Local/Programs/Python/Python38-32/gtopt.py ==

['C:/Users/VTU/AppData/Local/Programs/Python/Python38-32/gtopt.py']

Errors and Exceptions:

Python Errors and Built-in Exceptions: Python (interpreter) raises exceptions when it
encounters errors. When writing a program, we, more often than not, will
encounter errors. Error caused by not following the proper structure (syntax) of the language
is called syntax error or parsing error

ZeroDivisionError:

ZeroDivisionError in Python indicates that the second argument used in a division (or
modulo) operation was zero.

OverflowError:

OverflowError in Python indicates that an arithmetic operation has exceeded the limits of
the current Python runtime. This is typically due to excessively large float values, as integer
values that are too big will opt to raise memory errors instead.

ImportError:

It is raised when you try to import a module which does not exist. This may happen if you
made a typing mistake in the module name or the module doesn't exist in its standard path.
In the example below, a module named "non_existing_module" is being imported but it
doesn't exist, hence an import error exception is raised.

IndexError:

An IndexError exception is raised when you refer a sequence which is out of range. In the
example below, the list abc contains only 3 entries, but the 4th index is being accessed,
which will result an IndexError exception.

TypeError:

When two unrelated type of objects are combined, TypeErrorexception is raised.In example
below, an int and a string is added, which will result in TypeError exception.

113
IndentationError:

Unexpected indent. As mentioned in the "expected an indentedblock" section, Python not

only insists on indentation, it insists on consistentindentation. You are free to choose the
number of spaces of indentation to use, but you then need to stick with it.

Syntax errors:

These are the most basic type of error. They arise when the Python parser is unable to
understand a line of code. Syntax errors are almost always fatal, i.e. there is almost never a
way to successfully execute a piece of code containing syntax errors.

Run-time error:

A run-time error happens when Python understands what you are saying, but runs into
trouble when following your instructions.

Key Error :

Python raises a KeyError whenever a dict() object is requested (using the

format a = adict[key]) and the key is not in the dictionary.

Value Error:

In Python, a value is the information that is stored within a certain object. To encounter a
ValueError in Python means that is a problem with the content of the object you tried to
assign the value to.

Python has many built-in exceptions which forces your program to output an error when
something in it goes wrong. In Python, users can define such exceptions by creating a new
class. This exception class has to be derived, either directly or indirectly,
from Exception class.

Different types of exceptions:

ArrayIndexOutOfBoundException.
ClassNotFoundException.
FileNotFoundException.
IOException.
InterruptedException.
NoSuchFieldException.
NoSuchMethodException

114
Handling Exceptions:

The cause of an exception is often external to the program itself. For example, an incorrect
input, a malfunctioning IO device etc. Because the program abruptly terminates on
encountering an exception, it may cause damage to system resources, such as files. Hence,
the exceptions should be properly handled so that an abrupt termination of the program is
prevented.

Python uses try and except keywords to handle exceptions. Both keywords are followed by
indented blocks.

Syntax:

try :

#statements in try block

except :

#executed when error in try block

Typically we see, most of the times

Syntactical errors
At developer level and compile level it gives errors.

Logical errors
As a developer we test the application, during that time logical error may obtained.

Run time error

the user say 6 and 0 i.e.,6/0 (shows error a number cannot be divided by zero))
This is not easy compared to the above two errors because it is not done by the
system, it is (mistake) done by the user.

The things we need to observe are:

1. You should be able to understand the mistakes; the error might be done by user, DB
connection or server.
2. Whenever there is an error execution should not
stop. Ex: Banking Transaction
3. The aim is execution should not stop even though an error occurs.

115
For ex:

a=5

b=2

print(a/b)

print("Bye")

Output:

C:/Users/VTU/AppData/Local/Programs/Python/Python38-32/pyyy/ex1.py 2.5

Bye

The above is normal execution with no error, but if we say when b=0, it is a
critical and gives error, see below

a=5

b=0
print(a/b)

print("bye") #this has to be printed, but abnormal termination

Output:

Traceback (most recent call last):

File "C:/Users/VTU/AppData/Local/Programs/Python/Python38-32/pyyy/ex2.py", line 3,

in <module>

print(a/b)

ZeroDivisionError: division by zero

To overcome this we handle exceptions using except keyword

a=5
b=0

116
try:
print(a/b)
except Exception:
print("number can not be divided by zero")
print("bye")
Output:

C:/Users/VTU/AppData/Local/Programs/Python/Python38-32/pyyy/ex3.py

number can not be divided by zero

bye

The except block executes only when try block has an error, check it below

a=5

b=2

try:

print(a/b)

except Exception:

print("number can not be divided by zero")

print("bye")

Output:

C:/Users/VTU/AppData/Local/Programs/Python/Python38-32/pyyy/ex4.py 2.5

For example if you want to print the message like what is an error in a program

a=5

b=0

try:

117
 print(a/b)

except Exception as e:

print("number can not be divided by zero",e)

print("bye")

Output:

C:/Users/VTU/AppData/Local/Programs/Python/Python38-32/pyyy/ex5.py

number can not be divided by zero division by zero

bye

(Type of error)

Let us see some more examples:

a=5

b=2

try:

print("resource opened")

print(a/b)

print("resource closed")

except Exception as e:

print("number can not be divided by zero",e)

Output:

C:/Users/VTU /Programs/Python/Python38-32/pyyy/ex6.py resource opened

2.5

resource closed

118
 Note: the file is opened and closed well, but see by changing the value of b to 0,

a=5

b=0

try:

print("resource opened")

print(a/b)

print("resource closed")

except Exception as e:

print("number can not be divided by zero",e)

Output:

C:/Users/VTU /Programs/Python/Python38-32/pyyy/ex7.py resource opened

number can not be divided by zero division by zero

Note: resource not closed

a=5

b=0

try:

print("resource opened")

print(a/b)

except Exception as e:

print("number can not be divided by zero",e)

print("resource closed")

Output:

119
C:/Users/VTU /Programs/Python/Python38-32/pyyy/ex8.py resource opened

number can not be divided by zero division by zero

resource closed

The result is fine that the file is opened and closed, but again change the value of
b to back (i.e., value 2 or other than zero)

a=5
b=2
try:
print("resource opened")
print(a/b)
except Exception as e:
print("number can not be divided by zero",e)
print("resource closed")
Output:
C:/Users/VTU/AppData/Local/Programs/Python/Python38-32/pyyy/ex9.py

resource opened

2.5

But again the same problem file/resource is not closed

To overcome this python has a feature called finally:

This block gets executed though we get an error or not

Note: Except block executes, only when try block has an error, but finally block
executes, even though you get an exception.
a=5
b=0

try:

120
 print("resource open")
print(a/b)
k=int(input("enter a number"))
print(k)
except ZeroDivisionError as e:
print("the value can not be divided by zero",e)
finally:
print("resource closed")
Output:
C:/Users/VTU /Programs/Python/Python38-32/pyyy/ex10.py resource open
the value can not be divided by zero division by zero
resource closed

change the value of b to 2 for above program, you see the output like

C:/Users/VTU/AppData/Local/Programs/Python/Python38-32/pyyy/ex10.py
resource open
2.5
enter a number 6
6
resource closed

Instead give input as some character or string for above program, check the
output
C:/Users/VTU /Programs/Python/Python38-32/pyyy/ex10.py resource open
2.5
enter a number p
resource closed
Traceback (most recent call last):
File "C:/Users/VTU/Programs/Python/Python38-32/pyyy/ex10.py", line 7, in <module>
k=int(input("enter a number"))
ValueError: invalid literal for int() with base 10: ' p'

121
#
a=5
b=0

try:
print("resource open")
print(a/b)
k=int(input("enter a number"))
print(k)
except ZeroDivisionError as e:
print("the value can not be divided by zero",e)
except ValueError as e:
print("invalid input")
except Exception as e:
print("something went wrong...",e)

finally:
print("resource closed")

Output:
C:/Users/VTU /Programs/Python/Python38-32/pyyy/ex11.py resource open
the value can not be divided by zero division by zero
resource closed

Change the value of b to 2 and give the input as some character or string (other
than int)
C:/Users/VTU /Programs/Python/Python38-32/pyyy/ex12.py resource open
2.5
enter a number p
invalid input
resource closed

Modules (Date, Time, os, calendar, math):

Modules refer to a file containing Python statements and definitions.

122
 We use modules to break down large programs into small manageable and organized
files. Furthermore, modules provide reusability of code.

We can define our most used functions in a module and import it, instead of copying
their definitions into different programs.

Modular programming refers to the process of breaking a large, unwieldy

programming task into separate, smaller, more manageable subtasks or modules.

Advantages :

Simplicity: Rather than focusing on the entire problem at hand, a module typically

development easier and less error-prone.

Maintainability: Modules are typically designed so that they enforce logical

boundaries between different problem domains. If modules are written in a way that
minimizes interdependency, there is decreased likelihood that modifications to a
single module will have an impact on other parts of the program. This makes it more
viable for a team of many programmers to work collaboratively on a large application.

Reusability: Functionality defined in a single module can be easily reused (through

an appropriately defined interface) by other parts of the application. This eliminates
the need to recreate duplicate code.

Scoping: Modules typically define a separate namespace, which helps avoid

collisions between identifiers in different areas of a program.

Functions, modules and packages are all constructs in Python that promote code
modularization.

A file containing Python code, for e.g.: example.py, is called a module and its module name
would be example.

>>> def add(a,b):

result=a+b

return result

123
Here, we have defined a function add() inside a module named example. The function takes
in two numbers and returns their sum.

How to import the module is:

We can import the definitions inside a module to another module or the Interactive
interpreter in Python.

We use the import keyword to do this. To import our previously defined

module example we type the following in the Python prompt.

Using the module name we can access the function using dot (.) operation. For Eg:

>>> import example

>>> example.add(5,5)

10

Python has a ton of standard modules available. Standard modules can be imported
the same way as we import our user-defined modules.

Reloading a module:

def hi(a,b):

print(a+b)

hi(4,4)

Output:

C:/Users/VTU /Programs/Python/Python38-32/pyyy/add.py 8

>>> import add

124
>>> import add

>>> import add

>>>

Python provides a neat way of doing this. We can use the reload() function inside
the imp module to reload a module. This is how its done.

>>> import imp

>>> import my_module

This code got executed >>> import my_module >>> imp.reload(my_module) This
code got executed <module 'my_module' from '.\\my_module.py'>how its done.

>>> import imp

>>> import add

>>> imp.reload(add)

<module 'add' from 'C:/Users/VTU /Programs/Python/Python38- 32/pyyy\\add.py'>

The dir() built-in function

>>> import example

>>> dir(example)

['__builtins ', ' cached ', ' doc__', ' file__', ' loader ', ' name ', '__package ',
' spec ', 'add']

>>> dir()

['__annotations ', ' builtins ', ' doc ', ' file ', ' loader ', ' name ',
' package ', ' spec ', '__warningregistry__', 'add', 'example', 'hi', 'imp']

It shows all built-in and user-defined modules.

For ex:

125
>>> example. name

'example'

Datetime module:

# Write a python program to display date, time

>>> import datetime

>>> a=datetime.datetime(2019,5,27,6,35,40)

>>> a

datetime.datetime(2019, 5, 27, 6, 35, 40)

# write a python program to display date

import datetime

a=datetime.date(2000,9,18)

print(a)

Output:

C:/Users/VTU /Programs/Python/Python38-32/pyyy/d1.py = 2000-09-18

# write a python program to display time

import datetime

a=datetime.time(5,3)

print(a)

Output:

C:/Users/VTU/AppData/Local/Programs/Python/Python38-32/pyyy/d1.py =

05:03:00

#write a python program to print date, time for today and now.

import datetime

126
a=datetime.datetime.today()

b=datetime.datetime.now()

print(a)

print(b)

Output:

C:/Users/VTU/AppData/Local/Programs/Python/Python38-32/pyyy/d1.py =

2019-11-29 12:49:52.235581

2019-11-29 12:49:52.235581

#write a python program to add some days to your present date and print the date
added.

import datetime

a=datetime.date.today()

b=datetime.timedelta(days=7)

print(a+b)

Output:

C:/Users/VTU/AppData/Local/Programs/Python/Python38-32/pyyy/d1.py =

2019-12-06

#write a python program to print the no. of days to write to reach your birthday

import datetime

a=datetime.date.today()

b=datetime.date(2020,5,27)

c=b-a

print(c)

Output:

127
C:/Users/VTU/AppData/Local/Programs/Python/Python38-32/pyyy/d1.py =

180 days, 0:00:00

#write an python program to print date, time using date and time functions

import datetime

t=datetime.datetime.today()

print(t.date())

print(t.time())

Output:

C:/Users/VTU/AppData/Local/Programs/Python/Python38-32/pyyy/d1.py =

2019-11-29

12:53:39.226763

Time module:

#write a python program to display time.

import time

print(time.time())

Output:

C:/Users/VTU/AppData/Local/Programs/Python/Python38-32/pyyy/t1.py =

1575012547.1584706

#write a python program to get structure of time stamp.

import time

print(time.localtime(time.time()))

Output:

C:/Users/VTU/AppData/Local/Programs/Python/Python38-32/pyyy/t1.py =

128
time.struct_time(tm_year=2019, tm_mon=11, tm_mday=29, tm_hour=13, tm_min=1,
tm_sec=15, tm_wday=4, tm_yday=333, tm_isdst=0)

#write a python program to make a time stamp.

import time

a=(1999,5,27,7,20,15,1,27,0)

print(time.mktime(a))

Output:

C:/Users/VTU/ /Programs/Python/Python38-32/pyyy/t1.py = 927769815.0

#write a python program using sleep().

import time

time.sleep(6) #prints after 6 seconds

print("Python Lab")

Output:

C:/Users/VTU /Programs/Python/Python38-32/pyyy/t1.py = Python Lab

(#prints after 6 seconds)

os module:

>>> import os

>>> os.name

'nt'

>>> os.getcwd() 'C:\\Users\VTU\Programs\\Python\\Python38-32\\pyyy'

>>> os.mkdir("temp1")

129
Note: temp1 dir is created

>>> os.getcwd() 'C:\\Users\VTU\Programs\\Python\\Python38-32\\pyyy'

>>> open("t1.py","a")

<_io.TextIOWrapper name='t1.py' mode='a' encoding='cp1252'>

>>> os.access("t1.py",os.F_OK)

True

>>> os.access("t1.py",os.W_OK)

True

>>> os.rename("t1.py","t3.py")

>>> os.access("t1.py",os.F_OK)

False

>>> os.access("t3.py",os.F_OK)

True

>>> os.rmdir('temp1')

(or)

os.rmdir('C:/Users/VTU/Programs/Python/Python38-32/pyyy/temp1')

130
Note: Temp1dir is removed

>>> os.remove("t3.py")

Note: We can check with the following cmd whether removed or not

>>> os.access("t3.py",os.F_OK)

False

>>> os.listdir()

['add.py', 'ali.py', 'alia.py', 'arr.py', 'arr2.py', 'arr3.py', 'arr4.py', 'arr5.py', 'arr6.py', 'br.py',
'br2.py', 'bubb.py', 'bubb2.py', 'bubb3.py', 'bubb4.py', 'bubbdesc.py', 'clo.py', 'cmndlinarg.py',
'comm.py', 'con1.py', 'cont.py', 'cont2.py', 'd1.py', 'dic.py', 'e1.py', 'example.py', 'f1.y.py',
'flowof.py', 'fr.py', 'fr2.py', 'fr3.py', 'fu.py', 'fu1.py', 'if1.py', 'if2.py', 'ifelif.py', 'ifelse.py',
'iff.py', 'insertdesc.py', 'inserti.py', 'k1.py', 'l1.py', 'l2.py', 'link1.py', 'linklisttt.py', 'lis.py',
'listlooop.py', 'm1.py', 'merg.py', 'nesforr.py', 'nestedif.py', 'opprec.py', 'paraarg.py',
'qucksort.py', 'qukdesc.py', 'quu.py', 'r.py', 'rec.py', 'ret.py', 'rn.py', 's1.py', 'scoglo.py',
'selecasce.py', 'selectdecs.py', 'stk.py', 'strmodl.py', 'strr.py', 'strr1.py', 'strr2.py', 'strr3.py',
'strr4.py', 'strrmodl.py', 'wh.py', 'wh1.py', 'wh2.py', 'wh3.py', 'wh4.py', 'wh5.py',
' pycache__']

>>> os.listdir('C:/Users/VTU/AppData/Local/Programs/Python/Python38-32') ['argpar.py',

'br.py', 'bu.py', 'cmndlinarg.py', 'DLLs', 'Doc', 'f1.py', 'f1.txt', 'filess',

'functupretval.py', 'funturet.py', 'gtopt.py', 'include', 'Lib', 'libs', 'LICENSE.txt', 'lisparam.py',
'mysite', 'NEWS.txt', 'niru', 'python.exe', 'python3.dll', 'python38.dll', 'pythonw.exe', 'pyyy',
'Scripts', 'srp.py', 'sy.py', 'symod.py', 'tcl', 'the_weather', 'Tools', 'tupretval.py',
'vcruntime140.dll']

Calendar module:

131
#write a python program to display a particular month of a year using calendar
module.

import calendar

print(calendar.month(2020,1))

Output:

# write a python program to check whether the given year is leap or not.

import calendar

print(calendar.isleap(2021))

Output:

C:/Users/VTU /Programs/Python/Python38-32/pyyy/cl1.py False

#write a python program to print all the months of given year.

import calendar

print(calendar.calendar(2020,1,1,1))

Output:

132
math module:

# write a python program which accepts the radius of a circle from user and computes
the area.

import math

r=int(input("Enter radius:"))

area=math.pi*r*r

print("Area of circle is:",area)

Output:
133
C:/Users/VTU /Programs/Python/Python38-32/pyyy/m.py = Enter radius:4

Area of circle is: 50.26548245743669

>>> import math

>>> print("The value of pi is", math.pi)

O/P: The value of pi is 3.141592653589793

Import with renaming:

We can import a module by renaming it as follows.

For Eg:

>>> import math as m

>>> print("The value of pi is", m.pi)

O/P: The value of pi is 3.141592653589793

We have renamed the math module as m. This can save us typing time in some cases.

Note that the name math is not recognized in our scope. Hence, math.pi is
invalid, m.pi is the correct implementation.

Python from...import statement:

We can import specific names from a module without importing the module as a
whole. Here is an example.

>>> from math import pi

>>> print("The value of pi is", pi)

O/P: The value of pi is 3.141592653589793

We imported only the attribute pi from the module.

In such case we don't use the dot operator. We could have imported multiple attributes
as follows.

134
 >>> from math import pi, e

>>> pi

3.141592653589793

>>> e

2.718281828459045

Import all names:

We can import all names(definitions) from a module using the following construct.

>>>from math import *

>>>print("The value of pi is", pi)

We imported all the definitions from the math module. This makes all names except
those beginnig with an underscore, visible in our scope.

Explore packages:

We don't usually store all of our files in our computer in the same location. We use a
well-organized hierarchy of directories for easier access.

Similar files are kept in the same directory, for example, we may keep all the songs in
the "music" directory. Analogous to this, Python has packages for directories
and modules for files.

As our application program grows larger in size with a lot of modules, we place
similar modules in one package and different modules in different packages. This
makes a project (program) easy to manage and conceptually clear.

Similar, as a directory can contain sub-directories and files, a Python package can
have sub-packages and modules.

A directory must contain a file named init .py in order for Python to consider it as
a package. This file can be left empty but we generally place the initialization code for
that package in this file.

Here is an example. Suppose we are developing a game, one possible organization of

packages and modules could be as shown in the figure below.

135
If a file named __init .py is present in a package directory, it is invoked when the
package or a module in the package is imported. This can be used for execution of
package initialization code, such as initialization of package-level data.

For example init__.py

A module in the package can access the global by importing it in turn

We can import modules from packages using the dot (.) operator.

For example, if want to import the start module in the above example, it is done as
follows.

import Game.Level.start

Now if this module contains a function named select_difficulty(), we must use the
full name to reference it.

Game.Level.start.select_difficulty(2)

136
 If this construct seems lengthy, we can import the module without the package prefix
as follows.

from Game.Level import start

We can now call the function simply as follows.

start.select_difficulty(2)

Yet another way of importing just the required function (or class or variable) form a
module within a package would be as follows.

from Game.Level.start import select_difficulty

Now we can directly call this function.

select_difficulty(2)

Examples:

#Write a python program to create a package (II YEAR),sub-

package(MBA),modules(student) and create read and write function to module

def read():

print("Department")

def write():

print("Student")

Output:

>>> from IIYEAR.MBA import student

>>> student.read()

Department

>>> student.write()

Student

>>> from IIYEAR.MBA.student import read

>>> read

137
<function read at 0x03BD1070>

>>> read()

Department

>>> from IIYEAR.MBA.student import write

>>> write()

Student

# Write a program to create and import module?

def add(a=4,b=6):

c=a+b

return c

Output:

C:\Users\VTU\AppData\Local\Programs\Python\Python38-32\IIYEAR\modu1.py

>>> from IIYEAR import modu1

>>> modu1.add()

10

# Write a program to create and rename the existing module.

def a():

print("hello world")

a()

Output:

C:/Users/VTU /Programs/Python/Python38-32/IIYEAR/exam.py hello world

>>> import exam as ex

hello world

138