CHAPTER THREE Sequences Sequences contains objects that are

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!n. It'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 d 1 in range(3): for d 2 in range(3): p[d 1][d 2]= 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 = {key 1 : value 1, key 2 : value 2 } • 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 s 1=set([3, 5, 6, 10, 11, 100]) s 2=set([1, 3, 5, 6, 11, 15]) s 1 | s 2 s 1. union (s 2) 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 s 1=set([3, 5, 6, 10, 11, 100]) s 2=set([1, 3, 5, 6, 11, 15]) s 1& s 2 s 1. intersection (s 2) 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 s 1=set([3, 5, 6, 10, 11, 100]) s 2=set([1, 3, 5, 6, 11, 15]) s 1 -s 2 s 1. difference (s 2) returns {10, 100} s 2 -S 1 s 2. difference (s 1) returns {1, 15}

Sets (mutable) Symmetric difference (^) • is the object that appears in one of the two sets provided but not in both s 1=set([3, 5, 6, 10, 11, 100]) s 2=set([1, 3, 5, 6, 11, 15]) s 1. symmetric_difference (s 2) 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 s 1=set([3, 5, 6, 10, 11, 100]) s 2=set([1, 3, 5, 6, 11, 15]) s 1. symmetric_difference_update (s 2) returns s 1 as {1, 10, 15, 100}

Sets (mutable) Membership • to check if an object is in the set in is used s 1=set([3, 5, 6, 10, 11, 100]) s 2=set([1, 3, 5, 6, 11, 15]) 10 in s 1 returns True 15 in s 1 returns False 15 in s 2 returns True

Sets (mutable) Iteration through a set • makes it easy to iterate through distinct objects e. g s 1=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