15CS664- Python Application Programming - Module 3

HKBK COLLEGE OF ENGINEERING, BENGALURU

Module - 3 : Lists
 List methods
1) append( )
Adds a new element to the end of a list:
>>> t = ['a', 'b', 'c']
>>> t.append('d')
>>> print(t)
['a', 'b', 'c', 'd']
2) extend ( )
Takes a list as an argument and appends all of the elements:
>>> t1 = ['a', 'b', 'c']
>>> t2 = ['d', 'e']
>>> t1.extend(t2)
>>> print(t1)
['a', 'b', 'c', 'd', 'e']
This example leaves t2 unmodified.
Most list methods are void; they modify the list and return
None.
t = t.sort(), the result will be nothing
3) Sort ( )
Arranges the elements of the list from low to high:
>>> t = ['d', 'c', 'e', 'b', 'a']
>>> t.sort()
>>> print(t)
['a', 'b', 'c', 'd', 'e']

Module - 3 : Lists
 List methods -Deleting Elements
4) pop( )
To delete elements from a list. If the index of the
Element is known
>>> t = ['a', 'b', 'c']
>>> x = t.pop(1)
>>> print(t)
['a', 'c']
>>> print(x)
b
pop modifies the list and returns the element that was
removed.
If we don’t provide an index, it deletes and returns the
last element.
5) del( )
If we don’t need the removed value, use the del operator:
>>> t = ['a', 'b', 'c']
>>> del t[1]
>>> print(t)
['a', 'c']
>>> t = ['a', 'b', 'c']
>>> x = t.pop( )
>>> print(t)
['a', ‘b']
>>> print(x)
c

Module - 3 : Lists
 List methods -Deleting Elements
6) remove( )
If any element from the list to be removed , use remove:
>>> t = ['a', 'b', 'c']
>>> t.remove('b')
>>> print(t)
['a', 'c']
# The return value from remove is None.
To remove more than one element, you can use del with a slice index:
>>> t = ['a', 'b', 'c', 'd', 'e', 'f']
>>> del t[1:5]
>>> print(t)
['a', 'f']
As usual, the slice selects all the elements up to, but not including, the
second index.

Module - 3 : Lists
 Lists and functions
There are a number of built-in functions that can be used on lists that allow to quickly look through a list without writing own loops:
>>> nums = [3, 41, 12, 9, 74, 15]
>>> print(len(nums))
6
>>> print(max(nums))
74
>>> print(min(nums))
3
>>> print(sum(nums))
154
>>> print(sum(nums)/len(nums)) # finding average
25
The sum() function only works when the list elements are numbers.
The other functions (max(), len(), etc.) work with lists of strings and
other types that can be comparable.

Module - 3 : Lists
We could rewrite the program that computed the average of a list of numbers entered by the user using a list.
The program to compute an average without a list:
total = 0
count = 0
while (True):
inp = input('Enter a number: ')
if inp == 'done': break
value = float(inp)
total = total + value
count = count + 1
average = total / count
print('Average:', average)

Module - 3 : Lists
We could rewrite the program that computed the average of a list of numbers entered by the user using a list.
The program to compute an average with a list:
numlist = list() # empty list
while (True):
inp = input('Enter a number: ')
if inp == 'done': break
value = float(inp)
numlist.append(value)
average = sum(numlist) / len(numlist)
print('Average:', average)

Module - 3 : Lists
 Lists and Strings
A string is a sequence of characters and a list is a sequence of values, but a list of characters is not the same
as a string.
To convert from a string to a list of characters, use list:
>>> s = ‘HKBK'
>>> t = list(s)
>>> print(t)
[‘H', ‘K', ‘B', ‘K']
The list function breaks a string into individual letters. If we want to break a string into words, use split method:
>>> s = ‘Welcome to HKBKCE'
>>> t = s.split()
>>> print(t)
[' Welcome ', ‘ to ‘, ‘ HKBKCE ’]
>>> print(t[2])
HKBKCE

Module - 3 : Lists
 Lists and Strings
We can call split with an optional argument called a delimiter that specifies which characters to use as word
boundaries.
The following example uses a hyphen as a delimiter:
>>> s = 'spam-spam-spam'
>>> delimiter = '-'
>>> s.split(delimiter)
['spam', 'spam', 'spam']
Join( ) is the inverse of split. It takes a list of strings and concatenates the elements.
join is a string method, so we have to invoke it on the delimiter and pass the list as a parameter:
>>> t = [' Welcome ', ‘ to ‘, ‘ HKBKCE ’]
>>> delimiter = ‘ '
>>> delimiter.join(t)
‘Welcome to HKBKCE’

Module - 3 : Lists
 Objects and values
a = 'banana'
b = 'banana‘
we know that a and b both refer to a string, but we don’t know whether they refer to the same string.
There are two possible states:
In one case, a and b refer to two different objects that have the same value.
In the second case, they refer to the same object.

Module - 3 : Lists
To check whether two variables refer to the same object, use the is operator.
>>> a = 'banana'
>>> b = 'banana'
>>> a is b
True
In this example, Python only created one string object, and both a and b refer to it.

Module - 3 : Lists
create two lists, we get two objects:
>>> a = [1, 2, 3]
>>> b = [1, 2, 3]
>>> a is b
False
In this case , the two lists are equivalent, because they have the same elements, but not identical, because
they are not the same object.
If two objects are identical, they are also equivalent, but if they are equivalent, they are not necessarily
identical.

Module - 3 : Lists
 Aliasing
If a refers to an object and assign b = a, then both variables refer to the same object:
>>> a = [1, 2, 3]
>>> b = a
>>> b is a
True
The association of a variable with an object is called a reference.
In this example, there are two references to the same object.
An object with more than one reference has more than one name, then the object is aliased.

Module - 3 : Lists
 Aliasing
For immutable objects like strings, aliasing is not as much of a problem.
a = 'banana'
b = 'banana'
it almost never makes a difference whether a and b refer to the same string or not.
If the aliased object is mutable, changes made with one alias affect the other:
>>> a = [1, 2, 3]
>>> b = a
>>> b[0] = 17
>>> print(a)
[17, 2, 3]

Module - 3 : Lists
 List arguments
When we pass a list to a function, the function gets a reference to the list.
If the function modifies a list parameter, the caller sees the change.
For example,
delete_head removes the first element from a list:
def delete_head(t):
del t[0]
>>> letters = ['a', 'b', 'c']
>>> delete_head(letters)
>>> print(letters)
['b', 'c']

Module - 3 : Lists
 List arguments
The parameter t and the variable letters are aliases for the same object.
It is important to distinguish between operations that modify lists and operations that create new lists.
For example, the append method modifies a list, but the + operator creates a new list:
>>> t1 = [1, 2]
>>> t2 = t1.append(3)
>>> print(t1)
[1, 2, 3]
>>> print(t2)
None
>>> t3 = t1 + [3]
>>> print(t3)
[1, 2, 3]
>>> t2 is t3
False

Module - 3 : Lists
 List arguments
This difference is important when we write functions that are supposed to modify lists.
For example, this function does not delete the head of a list:
def bad_delete_head(t):
t = t[1:] # WRONG!
The slice operator creates a new list and the assignment makes t refer to it, but none of that has any
effect on the list that was passed as an argument.
An alternative is to write a function that creates and returns a new list.
For example, tail returns all but the first element of a list:
def tail(t):
return t[1:] #This function leaves the original list unmodified. Here’s how it is used:
>>> letters = ['a', 'b', 'c']
>>> rest = tail(letters)
>>> print(rest)
['b', 'c']

Module - 3 : Dictionaries
 Dictionary
• A dictionary is like a list, but more general.
• In a list, the index positions have to be integers; in a dictionary, the indices can be
(almost) any type.
• dictionary is as mapping between a set of indices (which are called keys) and a set
of values.
• Each key maps to a value.
• The association of a key and a value is called a key-value pair or sometimes an
item.
• the keys and the values are all strings.

 Dictionary
The function dict() creates a new dictionary with no items.
Because dict is the name of a built-in function, we should avoid using it as a variable name.
>>> city_capital = dict()
>>> print(city_capital)
{ } # The curly brackets, { }, represent an empty dictionary.
To add items to the dictionary, use square brackets:
>>> city_capital[‘KAR'] = ‘Bangalore‘
This line creates an item that maps from the key ’KAR’ to the value “Bangalore”.
If we print the dictionary again, we see a key-value pair with a colon between the key and
value:
{‘KAR': ‘Bangalore'}

 Dictionary
>>> city_capital={'KAR':'Bangalore','TN':'Chennai','AP':'Hyderabad'}
{'KAR': 'Bangalore', 'TN': 'Chennai', 'AP': 'Hyderabad'}
The order of the key-value pairs is not the same.
In general, the order of items in a dictionary is unpredictable.
Use the keys to look up the corresponding values:
>>> print(city_capital['TN'])
Chennai
If the key isn’t in the dictionary, we get an exception:
>>> print(city_capital[‘KN'])
KeyError: ‘KN'

 Dictionary
The len function works on dictionaries;
it returns the number of key-value pairs:
>>> len(city_capital)
3

 Dictionary
The in operator works on dictionaries; it tells whether something appears as a key in the
dictionary.
>>> ‘KAR' in city_capital
True
>>> ‘KAN' in city_capital
False
To see whether something appears as a value in a dictionary, use the method values, which
returns the values as a list, and then use the in operator:
>>> city = list(city_capital.values())
>>> ‘Bangalore' in city
True

 Dictionary
• The in operator uses different algorithms for lists and dictionaries.
• For lists, it uses a linear search algorithm. As the list gets longer, the search time gets
longer in direct proportion to the length of the list.
• For dictionaries, Python uses an algorithm called a hash table that has a remarkable
property: the in operator takes about the same amount of time no matter how many items
there are in a dictionary.

 Dictionary as a set of counters
str = 'Good Morning God Mother'
d = dict()
for ch in str:
if ch not in d:
d[ch] = 1
else:
d[ch] = d[ch] + 1
print(d)
{'G': 2, 'o': 5, 'd': 2, ' ': 3, 'M': 2, 'r': 2, 'n': 2, 'i': 1, 'g': 1, 't': 1, 'h': 1, 'e': 1}
We are effectively computing a histogram, which is a statistical term for a set of counters (or
frequencies).

• Dictionaries have a method called get that takes a key and a default value.
• If the key appears in the dictionary, get returns the corresponding value;
otherwise it returns the default value.
For example:
>>> counts = { ‘Python' : 1 , ‘PCD' : 42, ‘Rupee': 100}
>>> print(counts.get(‘Rupee', 0))
100
>>> print(counts.get(‘doller', 0))
0

str = 'Good Morning God Mother'
d = dict( )
for ch in str:
d[ch] = d.get(ch,0) + 1
print(d)
{'G': 2, 'o': 5, 'd': 2, ' ': 3, 'M': 2, 'r': 2, 'n': 2, 'i': 1, 'g': 1, 't': 1, 'h': 1, 'e': 1}
We can use get to write our histogram loop more concisely.
Because the get method automatically handles the case where a key is not in a dictionary,
we can reduce four lines down to one and eliminate the if statement.

 Dictionaries and files
 common uses of a dictionary is to count the occurrence of words in a file with some written
text.
Write a Python program to read through the lines of the file, break each line into a list of words,
and then loop through each of the words in the line and count each word using a dictionary.
We will see that we have two for loops.
The outer loop is reading the lines of the file and the inner loop is iterating through each of the
words on that particular line. This is an example of a pattern called nested loops because one of
the loops is the outer loop and the other loop is the inner loop

 Dictionaries and files
fname = input('Enter the file name: ')
try:
fhand = open(fname)
except:
print('File cannot be opened:', fname)
exit()
counts = dict()
for line in fhand:
words = line.split()
for word in words:
if word not in counts:
counts[word] = 1
else:
counts[word] += 1
print(counts)
Enter the file name: hkbk.txt
{'HKBK': 2, 'College': 1, 'of': 2, 'Engineering': 1, 'was': 1, 'established':
1, 'in': 2, '1997.': 1, 'Teaching': 1, 'is': 2, 'more': 1, 'than': 1, 'a': 2,
'profession,': 1, 'for': 1, 'the': 1, 'faculty': 1, 'members': 1, 'HKBKCE': 2,
'situated': 1, 'Bangalore': 1, 'We': 1, 'are': 1, 'proud': 1, 'to': 1, 'be': 1,
'Students.': 1}
HKBK.txt
HKBK College of Engineering was established in 1997.
Teaching is more than a profession, for the faculty
members of HKBKCE
HKBKCE is situated in Bangalore
We are proud to be a HKBK Students.

 Looping and dictionaries
If we use a dictionary as the sequence in a for statement, it traverses the keys of the dictionary.
This loop prints each key and the corresponding value:
counts = { 'BNG' : 1 , 'MYS' : 42, 'SMG': 100}
for key in counts:
print(key, counts[key])
Output:
BNG 1
MYS 42
SMG 100

 Looping and dictionaries
If we want to print the keys in alphabetical order,
1. make a list of the keys in the dictionary using the keys method available in dictionary objects
2. sort that list and loop through the sorted list, looking up each key
Program for Printing out key-value pairs in sorted order as follows:
Output:
['SMG', 'MYS', 'BNG']
BNG 100
MYS 42
SMG 1
counts = {'SMG' : 1 , 'MYS' : 42, 'BNG' : 100}
lst = list(counts.keys())
print(lst)
lst.sort()
for key in lst:
print(key, counts[key])

 Advanced text parsing
Python split function looks for spaces and treats words as tokens separated by spaces.
We can solve both Punctuation and case sensitive problems by using the string methods lower,
punctuation, and translate.
The translate is the most subtle of the methods.
line.translate(str.maketrans(fromstr, tostr, deletestr))
Replace the characters in fromstr with the character in the same position in tostr and delete all
characters that are in deletestr.
The fromstr and tostr can be empty strings and the deletestr parameter can be omitted.

 Advanced text parsing
>>> import string
>>> string.punctuation
'!"#$%&'()*+,-./:;<=>?@[]^_`{|}~‘
HKBKpunch.txt
Greetings from HKBKCE!
Hello, How are You?
HKBK College of Engineering was established in 1997.
Teaching is more than a profession, for the faculty members of HKBKCE
HKBKCE is situated in Bangalore
We are proud to be a HKBK Students.

 Advanced text parsingimport string
fname = input('Enter the file name: ') #counting words program
try:
fhand = open(fname)
except:
print('File cannot be opened:', fname)
exit()
counts = dict()
for line in fhand:
line = line.rstrip()
line = line.translate(line.maketrans('', '', string.punctuation))
line = line.lower()
for word in words:
counts[word] = 1
else:
counts[word] += 1
print(counts)
Output:
Enter the file name: HKBKpunch.txt
{'greetings': 1, 'from': 1, 'hkbkce': 3, 'hello': 1, 'how': 1, 'are': 2, 'you':
1, 'hkbk': 2, 'college': 1, 'of': 2, 'engineering': 1, 'was': 1, 'established':
1, 'in': 2, '1997': 1, 'teaching': 1, 'is': 2, 'more': 1, 'than': 1, 'a': 2,
'profession': 1, 'for': 1, 'the': 1, 'faculty': 1, 'members': 1, 'situated': 1,
'bangalore': 1, 'we': 1, 'proud': 1, 'to': 1, 'be': 1, 'students': 1}

Module - 3 : Tuples
 Tuples are immutable
 A tuple is a sequence of values much like a list.
 The values stored in a tuple can be any type, and they are indexed by integers.
 The important difference is that tuples are immutable.
 Tuples are also comparable and hashable so we can sort lists of them and use tuples as key
values in Python dictionaries.
 Syntactically, a tuple is a comma-separated list of values:
t = 'a', 'b', 'c', 'd', 'e' or t = ('a', 'b', 'c', 'd', 'e')
>>> t1 = ('a',)
>>> type(t1)
<type 'tuple'>
>>> t2 = ('a')
>>> type(t2)
<type 'str'>

Module - 3 : Tuples
Another way to construct a tuple is the built-in function tuple.
With no argument, it creates an empty tuple:
>>> t = tuple()
>>> print(t)
()
If the argument is a sequence (string, list, or tuple), the result of the call to tuple is a tuple with
the elements of the sequence:
>>> t = tuple('lupins')
>>> print(t)
('l', 'u', 'p', 'i', 'n', 's')
Because tuple is the name of a constructor, avoid using it as a variable name.

Module - 3 : Tuples
Most list operators also work on tuples.
The bracket operator indexes an element:
>>> t = ('a', 'b', 'c', 'd', 'e')
>>> print(t[0])
'a'
slice operator selects a range of elements:
>>> print(t[1:3])
('b', 'c')

Module - 3 : Tuples
But if try to modify one of the elements of the tuple, will get an error:
>>> t[0] = 'A'
TypeError: object doesn't support item assignment
We can’t modify the elements of a tuple, but We can replace one tuple with another:
>>> t = ('A',) + t[1:]
>>> print(t)
('A', 'b', 'c', 'd', 'e')

Module - 3 : Tuples
 Comparing tuples
 The comparison operators work with tuples and other sequences.
 Python starts by comparing the first element from each sequence.
 If they are equal, it goes on to the next element, and so on, until it finds elements that differ.
 Subsequent elements are not considered (even if they are really big).
>>> (0, 1, 2) < (0, 3, 4)
True
>>> (0, 1, 2000000) < (0, 3, 4)
True

Module - 3 : Tuples
 The sort function works the same way.
 It sorts primarily by first element, but in the case of a tie, it sorts by second element, and so
on.
 This feature lends itself to a pattern called DSU for
Decorate a sequence by building a list of tuples with one or more sort keys preceding the
elements from the sequence,
Sort the list of tuples using the Python built-in sort, and
Undecorate by extracting the sorted elements of the sequence.
[DSU]

Module - 3 : Tuples
#Program to sort list of words from shortest to longest
txt = 'HKBK College of Engineering was established in 1997'
words = txt.split()
t = list()
for word in words:
t.append((len(word), word))
print(t)
t.sort()
print(t)
res = list()
for length, word in t:
res.append(word)
print(res)
Output:
[(4, 'HKBK'), (7, 'College'), (2, 'of'), (11, 'Engineering'), (3, 'was'), (11, 'established'),
(2, 'in'), (4, '1997')]
[(2, 'in'), (2, 'of'), (3, 'was'), (4, '1997'), (4, 'HKBK'), (7, 'College'), (11, 'Engineering'),
(11, 'established')]
['in', 'of', 'was', '1997', 'HKBK', 'College', 'Engineering', 'established']

Module - 3 : Tuples
 Tuple assignment
 One of the unique syntactic features of the Python language is the ability to have a tuple on
the left side of an assignment statement.
 This allows to assign more than one variable at a time when the left side is a sequence.
 Two-element list (which is a sequence) and assign the first and second elements of the
sequence to the variables x and y in a single statement.
>>> m = [ 'have', 'fun' ]
>>> x, y = m
>>> x
'have'
>>> y
'fun'
>>>
>>> m = [ 'have', 'fun' ]
>>> x = m[0]
>>> y = m[1]
>>> x
'have'
>>> y
'fun'
>>>
>>> m = [ 'have', 'fun' ]
>>> (x, y) = m
>>> x
'have'
>>> y
'fun'
>>>

Module - 3 : Tuples
 Tuple assignment
Tuple assignment allows us to swap the values of two variables in a single statement:
>>> a, b = b, a
The number of variables on the left and the number of values on the right must be
the same:
>>> a, b = 1, 2, 3
ValueError: too many values to unpack
>>> addr = 'monty@python.org'
>>> uname, domain = addr.split('@')
The return value from split is a list with two elements;
the first element is assigned to uname, the second to domain.
>>> print(uname)
monty
>>> print(domain)
python.org

Module - 3 : Tuples
 Dictionaries and tuples
Dictionaries have a method called items.
Item() returns a list of tuples, where each tuple is a key-value pair:
>>> d = {'a':10, 'b':1, 'c':22}
>>> t = list(d.items())
>>> print(t)
[('b', 1), ('a', 10), ('c', 22)]
As we should expect from a dictionary, the items are in no particular order.

Module - 3 : Tuples
 Dictionaries and tuples
sort the list of tuples.
Converting a dictionary to a list of tuples is a way for us to output the contents of a dictionary
sorted by key:
>>> d = {'a':10, 'b':1, 'c':22}
>>> t = list(d.items())
>>> t
[('b', 1), ('a', 10), ('c', 22)]
>>> t.sort()
>>> t
[('a', 10), ('b', 1), ('c', 22)]
The new list is sorted in ascending alphabetical order by the key value.

Module - 3 : Tuples
 Multiple assignment with dictionaries
Combining items, tuple assignment, and for will give code pattern for traversing the keys and values of a
dictionary in a single loop:
d = {'a':10, 'b':1, 'c':22}
for key, val in list(d.items()):
print(val, key)
This loop has two iteration variables because items returns a list of tuples and key, val is a tuple assignment
that successively iterates through each of the key-value pairs in the dictionary.
For each iteration through the loop, both key and value are advanced to the next key-value pair in the
dictionary (still in hash order).
The output of this loop is:
10 a
22 c
1 b

Module - 3 : Tuples
 The most common words
#program to count words
import string
fhand = open('HKBKpunch.txt')
counts = dict()
for line in fhand:
line = line.translate(str.maketrans('', '', string.punctuation))
line = line.lower()
for word in words:
counts[word] = 1
else:
counts[word] += 1
# Sort the dictionary by value
lst = list()
for key, val in list(counts.items()):
lst.append((val, key))
lst.sort(reverse=True)
for key, val in lst[:10]:
print(key, val)
Output:
3 hkbkce
2 of
2 is
2 in
2 hkbk
2 are
2 a
1 you
1 we
1 was
The fact that this complex data parsing and analysis can be done with an easy-to
understand Python program is one reason why Python is a good choice as
a language for exploring information

Module - 3 : Tuples
 Using tuples as keys in dictionaries
Define the variables last, first, and number, we could write a dictionary assignment statement as
follows:
directory[last,first] = number
The expression in brackets is a tuple. We could use tuple assignment in a for loop to traverse this
dictionary.
for last, first in directory:
print(first, last, directory[last,first])
#Using tuples as keys in dictionaries
phone=dict()
phone['mustafa‘,'syed']=22223333
for lname, fname in phone:
print(fname, lname, phone[lname,fname])
Output: syed mustafa 22223333

15CS664- Python Application Programming - Module 3

Recommended

More Related Content

What's hot (20)

Similar to 15CS664- Python Application Programming - Module 3 (20)

More from Syed Mustafa (20)

Recently uploaded (20)

15CS664- Python Application Programming - Module 3