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:')

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