These Python Programming notes (B.Tech CSE, III Year II Semester) cover Unit IV: lists, list operations, slices, methods, aliasing and cloning, list comprehension, tuples, tuple assignment, and dictionaries with their operations and methods. Code examples and outputs are given throughout.
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]
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) | 1 2 3 | Iteration |
Indexing, Slicing, and Matrixes
Because lists are sequences, indexing and slicing work the same way for lists as they do for strings.
Assuming following input −
L = ['study', 'college', 'STUDY!']
| Python Expression | Results | Description |
|---|---|---|
L[2] | STUDY! | Offsets start at zero |
L[-2]
college
Negative: count from the right
L[1:]
['college', 'STUDY!']
Slicing fetches sections
List slices:
>>> list1=range(1,6) >>> list1 range(1, 6) >>> print(list1) range(1, 6) >>> list1=[1,2,3,4,5,6,7,8,9,10] >>> list1[1:] [2, 3, 4, 5, 6, 7, 8, 9, 10] >>> list1[:1] [1] >>> list1[2:5] [3, 4, 5] >>> list1[:6] [1, 2, 3, 4, 5, 6] >>> list1[1:2:4] [2] >>> list1[1:8:2] [2, 4, 6, 8]
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
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() 7 >>> x [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] ----------------------- >>> 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 = ['M','R','C','E','T']
i = 1
#Iterating over the list
for item in list:
print ('college ',i,' is ',item)
i = i+1Output:
college 1 is M college 2 is R college 3 is C college 4 is E college 5 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]
# 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:
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 += 1Mutability:
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] >>> 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() 7 >>> x [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] ----------------------- >>> x=[10,1,5,3,8,7] >>> x.sort() >>> 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. If the data is immutable, aliases don’t matter because the data can’t change.
3. But if data can change, aliases can result in lot of hard – to – find bugs.
4. Aliasing happens whenever one variable’s value is assigned to another variable.
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:
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:
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:
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)
doubleStuff(things)
print(things)Output:
[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]
(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]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.
- If the contents of a list shouldn’t change, use a tuple to prevent items from
accidently being added, changed, or deleted.
- Tuples are more efficient than list due to python’s implementation.
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()
Access tuple items: Access tuple items by referring to the index number, inside square brackets
>>> x=('a','b','c','g')
>>> print(x[2])
cChange 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)
4Index (): Searches the tuple for a specified value and returns the position of where it was found
>>> 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 college information like college name, year, etc. and another tuple 2 with the values in it like number (1, 2, 3… 7).
For Example,
Here is the code,
- >>> tup1 = ('study', 'eng college','2004','cse', 'it','csit');
- >>> tup2 = (1,2,3,4,5,6,7);
- >>> print(tup1[0])
- study
- >>> print(tup2[1:4])
- (2, 3, 4)
Tuple 1 includes list of information of the college
Tuple 2 includes list of numbers in it
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 study 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 = "study college"
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:
study college 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:
(62.8318, 314.159) ------------------------------
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
cCreate 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)]
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:
X={1:'A',2:'B',3:'c'}
X=dict([('a',3),('b',4)])
X=dict(A=1,B=2)Example:
>>> dict1 = {"brand":"study","model":"college","year":2004}
>>> dict1
{'brand': 'study', 'model': 'college', '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 from the dictionary. |
copy() | Return a shallow copy of the dictionary. |
fromkeys(seq[, v]) | Return a new dictionary with keys from seq and value equal to v (defaults to None). |
get(key[,d]) | Return the value of key. If key does not exist, return d (defaults to None). |
items() | Return a new view of the dictionary's items (key, value). |
keys() | Return a new view of the dictionary's keys. |
pop(key[,d]) | Remove the item with key and return its value or d if key is not found. If d is not provided and key is not found, raises KeyError. |
popitem() | Remove and return an arbitrary item (key, value). Raises KeyError if the dictionary is empty. |
setdefault(key[,d]) | If key is in the dictionary, return its value. If not, insert key with a value of d and return d (defaults to None). |
update([other]) | Update the dictionary with the key/value pairs from other, overwriting existing keys. |
values() | Return a new view of the dictionary's values |
Below are some dictionary operations:
To access specific value of a dictionary, we must pass its key,
>>> dict1 = {"brand":"study","model":"college","year":2004}
>>> x=dict1["brand"]
>>> x
'study'
---------------------To access keys and values and items of dictionary:
>>> dict1 = {"brand":"study","model":"college","year":2004}
>>> dict1.keys()
dict_keys(['brand', 'model', 'year'])
>>> dict1.values()
dict_values(['study', 'college', 2004])
>>> dict1.items()
dict_items([('brand', 'study'), ('model', 'college'), ('year', 2004)])
-----------------------------------------------
>>> for items in dict1.values():
print(items)
study
college
2004
>>> for items in dict1.keys():
print(items)
brand
model
year
>>> for i in dict1.items():
print(i)
('brand', 'study')
('model', 'college')
('year', 2004)
Some more operations like:- Add/change
- Remove
- Length
- Delete
Add/change values: You can change the value of a specific item by referring to its key name
>>> dict1 = {"brand":"study","model":"college","year":2004}
>>> dict1["year"]=2005
>>> dict1
{'brand': 'study', 'model': 'college', 'year': 2005}Remove(): It removes or pop the specific item of dictionary.
>>> dict1 = {"brand":"study","model":"college","year":2004}
>>> print(dict1.pop("model"))
college
>>> dict1
{'brand': 'study', 'year': 2005}Delete: Deletes a particular item.
>>> x = {1:1, 2:4, 3:9, 4:16, 5:25}
>>> del x[5]
>>> xLength: 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
4Iterating over (key, value) pairs:
>>> x = {1:1, 2:4, 3:9, 4:16, 5:25}
>>> for key in x:
print(key, x[key])
1 1
2 4
3 9
4 16
5 25
>>> for k,v in x.items():
print(k,v)
1 1
2 4
3 9
4 16
5 25List 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 >>> 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}