CHAPTER THREE
Sequences
Sequences
• contains objects that are kept in a specific order
• you can identify an object in a sequence by its index location
• the first object in a sequence is zero
• when a sequence is referenced outside its range, an exception is raised
• a variable contains zero or one value
• a sequence can contain zero or many values
• you can extract from a sequence with the slicing operation
• examples of sequences include lists, tuples and strings
Sequences
Operations on sequences
Three common operations applied to sequences
• + will concatenate sequences to make them longer
• * is used with numerical digits to repeat the sequence several times
• [ ] fetches a particular element from the sequence(index) or a subset of
elements (slicing)
Strings (immutable or static )
Definition
• a sequence that contains single-byte ASCII characters
• used to store and represent text information
• can be enclosed in single ('), double (") or triple quotes (''' or """) as follows:
• o = ‘Lets party’ OR o = “Lets party” OR o = '''Lets party'''
• are immutable, cannot modify an existing string object
• an operation on a string object creates a new string object
Strings (immutable or static )
Displaying strings
• newline e.g k="Hello World!\nIt's hot
• continuation e.g k="Hello World!\
It's hot“
• Single quote use escape character e.g k='Isn\'t it?‘
• If double quotes no need for \ e.g k="Isn't it? "
• In a triple quoted string, line breaks in the literal are preserved as newline
characters. You cannot use a backslash in a triple-quoted string
Strings (immutable or static )
How characters are stored in a string
• Example s = “Mi”
• each character is stored at a specific index location
• a character is accessed through the index e.g. s[0] is M
• there is no separate data type for characters
• a character is a string of length 1
Strings (immutable or static )
String methods
• to view a list of all methods
that can be used with str
type help(‘str’)
Strings (immutable or static )
String methods (cont)
Strings (immutable or static )
Finding substrings in a string
• String Methods Used to Find Substrings in a String
Arrays
Numerical arrays
• a string is an array of characters
• a numerical array stores numerical data
• they do not have NULL characters
• numerical arrays are NOT terminated by NULL characters
• indexes are used for accessing elements
• There are one and two dimensional arrays
Arrays
One dimensional array
• given an array p as follows:
• array declaration : p= [ 0 for i in range(5) ]
• input into array : for i in range(5):
p[i]= int(input())
• print array values : for n in p:
print (n)
Arrays
Two dimensional array
• are divided into rows and columns
• The indices of row and column begin at value 0
• To access each element of the array, you have to specify two indices; one for row, and
the other for column
• Both are enclosed in square brackets.
• array declaration : p = [ [ 0 for i in range(3) ] for j in range(3) ]
• input into array : for d1 in range(3):
for d2 in range(3):
p[d1][d2]= int(input()
• print array value : p[1][2]
Lists (mutable)
Definition
• is a container object that is mutable
• is a collection of elements, which might include other lists
• begin and end with a square bracket
• elements inside are separated with commas
• first element of the list is at index 0 last element is at index -1
• Example: [p = ["John", "Kelly", 1, 2, [Sugar, Butter, 10]] #list containing a list
print (p[0]) #prints John
Lists (mutable)
Length of a list
• to find the length of a list, you use the len() function
• it returns the length as an index location of the last element plus one
• Given : names=['John', 'Kelly', 'Caroline', 'Paula']
len(names) will return 4
for i in range(0,len(names)): #range(0,4) returns 0 - 3
print (names[i])
Lists (mutable)
List Slicing
•You can slice a list into parts to get desired elements
Given : names=['John', 'Kelly', 'Caroline', 'Paula']
names[0:3] #returns index 0 to 2 ['John', 'Kelly', 'Caroline']
names[-4] #returns fourth from last ['John']
names[-3:-1]#returns third from last to second from last 'Kelly', 'Caroline']
names[:2] #returns first 2 ['John', 'Kelly']
names[2:] #returns index at 2 to last ['Caroline', 'Paula']
names[:-2] #returns index 0 to second from last ['John', 'Kelly', 'Caroline']
names[-2:] #returns second from last to end of the list ['Caroline', 'Paula']
Lists (mutable)
Other list methods
• some of the methods
that can be applied to lists
Tuples (immutable)
Tuple objects
• are a type of sequence, like strings
• unlike strings, which can contain only characters tuples can contain elements of any type
• a tuple is an immutable object that cannot be changed once created
• as with every sequence, tuple indices are zero based
• the first element is at index 0, and the last element is at index -1
• Is similar to a list, but elements are enclosed in parentheses ()
• the elements are in a defined order
Tuples (immutable)
Tuples vs Lists
• are faster than lists, when an item has to be added on the list a new one is
created
• when defining a constant set of data, a tuple is preferred (write-protected)
• tuples can be used as dictionary keys. Dictionary keys must be immutable
• if tuples contain lists, then they can not be used as dictionary keys
• tuples can be converted into lists and vice versa
Tuples (immutable)
Tuple example
• demonstration of a tuple
names=('John', 'Kelly', 'Caroline', 'Steve', 'Katheline')# declaration
print ("The names in the tuple are:", names) # displayed as declared
print ("The first name in the tuple is", names[0]) # John
print ("The last name in the tuple is", names[len(names)-1])# Katherine
print ("The names in the tuple are")
for n in names:
print (n) # John
Kelly
Caroline
Steve
Katheline
Dictionary (mutable)
Dictionary
• a combination of key/value pairs in which every key has to be unique
• Key/value pairs are separated by a colon, and the pairs are separated by
commas
• The key/value pairs are enclosed in a curly brackets
• Syntax
d = {key1 : value1, key2 : value2 }
• dictionaries are mutable, which means a dictionary can be modified, and
you don’t have to create a copy of it to modify it
• Dictionary keys are case sensitive and immutable because Python
associates them with a unique number called a hash. Also,
• dictionary keys can be of mixed data types: strings, integers, and others.
Dictionary (mutable)
Methods
• a some of the methods that
can be applied to dictionary
Dictionary (mutable)
Example
• illustration of a dictionary
cap={'U.S.':'Washington D.C.','U.K.':'London','India':'New Delhi',}
n=input('Enter country: ')
if n in cap:
print ('The capital of', n , 'is', cap[n])
else:
print ('Sorry the country', n, 'does not exist in our dictionary')
cap['Australia']='Sweden'
print ('The dictionary after adding a country:')
for country, capital in cap.items():
print ('Capital of', country, 'is' , capital)
m=input('Enter the country to delete:')
del cap[m]
print ('The dictionary after deleting a country:')
for country, capital in cap.items():
print ('Capital of', country, 'is' , capital)
Sets (mutable)
The set container
• is an unordered collection of objects that can be contained in a hashtable
• hashtable is a set of key-value pairs
• since the sets are unordered, they do not support slicing or other
sequence-like behaviour
• sets cannot have any duplicate elements
• an element only appears 0 or 1 times
• a set is mutable except a frozenset which is immutable
Sets (mutable)
Uses of sets
• to tests membership
• to remove duplicates from a sequence
• to compute boolean operations like union , intersection, symmetric
difference and set difference
Sets (mutable)
Union (|)
• in a union operation an element appears in the union if it exists in one set
or the other
s1=set([3,5,6,10,11,100])
s2=set([1,3,5,6,11,15])
s1 | s2 s1.union (s2) returns {1,3,5,6,10,11,15,100}
Sets (mutable)
Intersection (&)
• in an intersection operation, the elements that appear in both sets appear
in the intersection
s1=set([3,5,6,10,11,100])
s2=set([1,3,5,6,11,15])
s1& s2 s1.intersection (s2) returns {3,5,6,11}
Sets (mutable)
Difference (-)
• In a difference operation, all the elements that are in the left set but not
in the right set will appear in the difference operation
s1=set([3,5,6,10,11,100])
s2=set([1,3,5,6,11,15])
s1-s2 s1.difference (s2) returns {10,100}
s2-S1 s2.difference (s1) returns {1,15}
Sets (mutable)
Symmetric difference (^)
• is the object that appears in one of the two sets provided but not in both
s1=set([3,5,6,10,11,100])
s2=set([1,3,5,6,11,15])
s1.symmetric_difference (s2) returns {1,10,15,100}
Sets (mutable)
Symmetric difference update
• symmetric_difference_update () method changes the first set to match
the set that is returned by the function
s1=set([3,5,6,10,11,100])
s2=set([1,3,5,6,11,15])
s1.symmetric_difference_update (s2) returns s1 as {1,10,15,100}
Sets (mutable)
Membership
• to check if an object is in the set in is used
s1=set([3,5,6,10,11,100])
s2=set([1,3,5,6,11,15])
10 in s1 returns True
15 in s1 returns False
15 in s2 returns True
Sets (mutable)
Iteration through a set
• makes it easy to iterate through distinct objects e.g
s1=set([3,5,6,10,11,100])
for n in s:
if ((n % 2 ) == 0)
print (“%d is even” %n)
else:
print (“%d is odd” %n)
• Output: 3 is odd
5 is odd
6 is even
10 is even
11 is odd
100 is even
Sets (mutable)
Removing objects from a set
•there are four functions to remove objects from a set
•pop () removes an object from a set. Object to be removed not specified
•remove () removes a specified object from a set
•discard () removes a specified object from a set. No error if object does not exist
•clear () clears the whole set completely
Sets (mutable)
Set methods/functions
• The list of methods and functions that can be applied on a set
Notes
