Python lec2

Swarup Kr Ghosh
MIS Group
IIM Calcutta
swarupg1@gmail.com

 Tuples
 Lists
 Strings
 Dictionaries
7/21/2017 2Swarup Kr Ghosh

 All three sequence types share much of the same
syntax and functionality
 Tuple
◦ A simple immutable ordered sequence of items
◦ Items can be of mixed types, including collection types
 List
◦ Mutable ordered sequence of items of mixed types
 Strings
◦ Immutable
◦ Conceptually very much like a tuple

 Tuples are defined using parentheses (and commas)
>>> tu = (23, ‘abc’, 4.56, (2,3), ‘def’)
 Lists are defined using square brackets (and
commas)
>>> li = [“abc”, 34, 4.34, 23]
 Strings are defined using quotes (“, ‘, or “““)
>>> st = “Hello World”
>>> st = ‘Hello World’
>>> st = “““This is a multi-line
string that uses triple quotes.”””

 We can access individual members of a tuple, list, or
string using square bracket “array” notation
>>> tu = (23, ‘abc’, 4.56, (2,3), ‘def’)
>>> tu[1] #Second item in the tuple
‘abc’
>>> li = [“abc”, 34, 4.34, 23]
>>> li[1] #Second item in the list
34
>>> st = “Hello World”
>>> st[1] #Second character in string
‘e’

>>> t = (23, ‘abc’, 4.56, (2,3), ‘def’)
 Positive index: count from the left, starting with 0.
>>> t[1]
‘abc’
 Negative lookup: count from right, starting with -1
>>> t[-3]
4.56

>>> t = (23, ‘abc’, 4.56, (2,3), ‘def’)
 Return a copy of the container with a subset of the
original members
 Start copying at the first index, and stop copying
before the second index
>>> t[1:4]
(‘abc’, 4.56, (2,3))
 You can also use negative indices when slicing
>>> t[1:-1]
(‘abc’, 4.56, (2,3))

>>> t = (23, ‘abc’, 4.56, (2,3), ‘def’)
 Omit the first index to make a copy starting from the
beginning of the container
>>> t[:2]
(23, ‘abc’)
 Omit the second index to make a copy starting at
the first index and going to the end of the container
>>> t[2:]
(4.56, (2,3), ‘def’)

 To make a copy of an entire sequence, use ‘[:]’
>>> t[:]
(23, ‘abc’, 4.56, (2,3), ‘def’)
 Note the difference between these two lines for
mutable sequences:
>>> list2 = list1 # 2 names refer to 1 ref
# Changing one affects both
>>> list2 = list1[:] # Two independent copies, two refs

 Boolean test whether a value is inside a container:
>>> t = [1, 2, 4, 5]
>>> 3 in t
False
>>> 4 in t
True
>>> 4 not in t
False
 For strings, tests for substrings:
>>> a = 'abcde'
>>> 'c' in a
True
>>> 'cd' in a
True
>>> 'ac' in a
False
 Be careful: the in keyword is also used in the syntax of for loops and list
comprehensions

 The + operator produces a new tuple, list, or string
whose value is the concatenation of its arguments
>>> (1, 2, 3) + (4, 5, 6)
(1, 2, 3, 4, 5, 6)
>>> [1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]
>>> “Hello” + “ ” + “World”
‘Hello World’
 The * operator produces a new tuple, list, or string that
repeats the original content
>>> (1, 2, 3) * 3
(1, 2, 3, 1, 2, 3, 1, 2, 3)
>>> [1, 2, 3] * 3
[1, 2, 3, 1, 2, 3, 1, 2, 3]
>>> “Hello” * 3
‘HelloHelloHello’

>>> t = (23, ‘abc’, 4.56, (2,3), ‘def’)
>>> t[2] = 3.14
Traceback (most recent call last):
File "<pyshell#75>", line 1, in -topleveltu[
2] = 3.14
TypeError: object doesn't support item assignment
 You can’t change a tuple
 You can make a fresh tuple and assign its reference to a
previously used name
>>> t = (23, ‘abc’, 3.14, (2,3), ‘def’)

 The comma is the tuple creation operator, not
parens
>>> 1,
(1,)
 Python shows parens for clarity (best practice)
>>> (1,)
(1,)
 Don't forget the comma!
>>> (1)
1
 Trailing comma only required for singletons others
 Empty tuples have a special syntactic form
>>> ()1313
()
>>> tuple()
()

>>> li = [‘abc’, 23, 4.34, 23]
>>> li[1] = 45
>>> li
[‘abc’, 45, 4.34, 23]
 We can change lists in place
 Name ‘li’ still points to the same memory
reference when we’re done
 The mutability of lists means that they aren’t as
fast as tuples

 append:
>>> li = [1, 11, 3, 4, 5]
>>> li.append(‘a’) # Our first exposure to method syntax
>>> li
[1, 11, 3, 4, 5, ‘a’]
 insert:
>>> li.insert(2, ‘i’)
>>>li
[1, 11, ‘i’, 3, 4, 5, ‘a’]
 extend:
>>> li.extend([9, 8, 7])
>>>li
[1, 2, ‘i’, 3, 4, 5, ‘a’, 9, 8, 7]

 + creates a fresh list (with a new memory reference)
 extend operates on list ‘li’ in place
>>> li.extend([9, 8, 7])
>>>li
[1, 2, ‘i’, 3, 4, 5, ‘a’, 9, 8, 7]
 Confusing: extend vs append
◦ Extend takes a list as an argument
◦ Append takes a singleton as an argument
>>> li.append([10, 11, 12])
>>> li
[1, 2, ‘i’, 3, 4, 5, ‘a’, 9, 8, 7, [10, 11, 12]]

a
1 2 3
b
a
1 2 3
b
4
a = [1, 2, 3]
a.append(4)
b = a
a
1 2 3

>>> li = [‘a’, ‘b’, ‘c’, ‘b’]
 Index:
>>> li.index(‘b’) # index of first occurrence
1
 Count:
>>> li.count(‘b’) # number of occurrences
2
 Remove:
>>> li.remove(‘b’) # remove first occurrence
>>> li
[‘a’, ‘c’, ‘b’]

>>> li = [5, 2, 6, 8]
 Reverse:
>>> li.reverse() # reverse the list
>>> li
[8, 6, 2, 5]
 Sort:
>>> li.sort() # sort the list
>>> li
[2, 5, 6, 8]
>>> li.sort(some_function)
# sort in place using user-defined comparison

 Lists slower but more powerful than tuples
◦ Lists can be modified, and they have lots of handy
operations we can perform on them
◦ Tuples are immutable and have fewer features
 To convert between tuples and lists use the list()
and tuple() functions:
◦ li = list(tu)
◦ tu = tuple(li)

Matrix:
>>> m=[[1,2,3],
[4,5,6],
[7,8,9]]
>>> m
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> n=[[1,1,1],
[1,1,1],
[1,1,1]]
>>> n
[[1, 1, 1], [1, 1, 1], [1, 1, 1]]
>>> m+n
[[1, 2, 3], [4, 5, 6], [7, 8, 9], [1, 1, 1], [1, 1, 1], [1, 1, 1]]
#Concatination not addition

 cross products:
>>> vec1 = [2,4,6]
>>> vec2 = [4,3,-9]
>>> [x*y for x in vec1 for y in vec2]
[8,6,-18, 16,12,-36, 24,18,-54]
>>> [x+y for x in vec1 and y in vec2]
[6,5,-7,8,7,-5,10,9,-3]
>>> [vec1[i]*vec2[i] for i in range(len(vec1))]
[8,12,-54]

 can also use if:
>>> vec1 = [2,4,6]
>>> [3*x for x in vec1 if x > 3]
[12, 18]
>>> [3*x for x in vec1 if x < 2]
[]

 Dictionaries store a mapping between a set of keys
and a set of values
◦ Keys can be any immutable type
◦ Accessed by key, not offset position
◦ Unordered collections of arbitrary objects
◦ Variable-length, heterogeneous, and arbitrarily nestable
◦ Tables of object references (hash tables)
◦ Values can be any type
◦ A single dictionary can store values of different types
 You can define, modify, view, lookup, and delete the
key-value pairs in the dictionary.

 Name={key : value,…… }
 Name[key]----- Shows value of Dictionary
d={'user':'scott','pswd':12345}
>>> d['user']
'scott'
>>> d['pswd']
12345
>>> d['scott']
Traceback (most recent call last):
File "<pyshell#4>", line 1, in <module>
d['scott']
KeyError: 'scott'

 To change values:
>>> d['user']='tiger'
>>> d
{'user': 'tiger', 'pswd': 12345}
 To insert another key with value:
>>> d['id']=45
>>> d
{'user': 'tiger', 'pswd': 12345, 'id': 45}
 Keys() method:
>>> d.keys()
dict_keys(['user', 'pswd', 'id'])
 Item() method:
>>> d.items()
dict_items([('user', 'tiger'), ('pswd', 12345), ('id', 45)])

 Del() method:
>>> del(d['user'])
>>> d
{'pswd': 12345, 'id': 45}
 Clear() method:
>>> d.clear()
>>> d
{}
 To show all keys and values with specific format:
>>> for k in sorted(d.keys()):
print('key:',k,'->',d[k])
key: id -> 45
key: pswd -> 12345
key: user -> tiger

>>> table = {'1975': 'Holy Grail',
'1979': 'Life of Brian', '1983': 'The Meaning of Life'}
>>> year = '1983'
>>> movie = table[year]
>>> movie
'The Meaning of Life‘
>>> for year in table:
print(year + 't' + table[year])
1979 Life of Brian
1975 Holy Grail
1983 The Meaning of Life
7/21/2017Swarup Kr Ghosh 28

Python lec2

More Related Content

What's hot (19)

Similar to Python lec2 (20)

Recently uploaded (20)

Python lec2