Data Structures. Dictionaries - stores a series of unsorted key/value pairs that are indexed using the keys and return the value.

Transcription

1 Data Structures Lists - stores a series of ordered mutable items Tuples - stores a series of ordered immutable items [not commonly used] Sets - stores a series of mutable or immutable(frozen) unsorted unique items Dictionaries - stores a series of unsorted key/value pairs that are indexed using the keys and return the value.

2 Mutable/Immutable Mutable - Able to be modified Immutable - Not able to be modified Easy way to remember: If a device is mutable (turn off the volume), then you are able to modify the volume of that device. So mutable == modifiable.

3 Lists Lists - generally store a series of similar typed items (but don't HAVE to be) ordered (indexed using square brackets and #'s) mutable created using square brackets. Example: >>> animals = [ 'cat', 'dog', 'snake', 'dog' ] >>> animals ['cat', 'dog', 'snake', 'dog']

4 List Functions L.append(object) - append object to end L.count(value) - return number of occurrences of value L.extend(iterable) - extend list by appending elements from the iterable (another list for example) L.index(value, [start, [stop]]) - return first index of value.

5 List Functions (Cont'd) L.insert(index, object) - insert object before index L.pop([index]) - remove and return item at index (default last) L.remove(value) - remove first occurrence of value L.reverse() - reverse L.sort(key=None, reverse=false) - sort a list, in reverse order if you set reverse to True.

6 Tuples Tuples - often store a series of mismatched items (but don't HAVE to be) ordered (indexed using square brackets and #'s) immutable created using parentheses Example: >>> timestamp = ( 'April', 1, 2011, 12, 36, 5) >>> timestamp ('April', 1, 2011, 12, 36, 5)

7 Tuples Another python sequence, similar to strings and lists Think of tuples as: Immutable Lists Immutable A value once set can not be modified... unmodifiable. Benefits of tuples: Faster/smaller/more efficient (less overhead). Drawback of tuples: Not modifiable! When to use tuples: What you store in the tuple isn't going to change. When the items stored are of different types (showing some sort of structure to the data stored)

8 Tuples Where T is the tuple in question: T = ('a','b','c') T.count(value) -- return number of occurrences of value T.index(value) -- return first index of value No append(), insert(), pop(), extend(), remove(), etc.

9 Sets Sets - often store a series of similar items (but don't HAVE to be) unordered (no indexing) mutable unique items created using curly braces Example: >>> colors = { 'red', 'white', 'blue', 'red' } >>> colors {'blue', 'white', 'red'}

10 Sets Think of sets as: Unordered Unique Lists Unordered Items can be in re-order at python's whim Unique no item is it it more than once When to use sets: When you don't want items repeated AND when order is irrelevant

11 Sets Where S is the set in question: S = {'a','b','c'} set(iterable) - return a set of the iterable objects S.add(item) - add item to the set S.clear() - removes all elements from the set S.copy() - return a copy of the list S.difference(S2) - returns the difference between S and S2 S.intersection(S2) - return the intersection of S and S2 S.issubset(S2) - returns True if S is a subset of S2 False otherwise S.issuperset(S2) - returns True if S is a superset of S2 False otherwise (S2 is a subset of S) S.pop() - returns and removes one element from S S.remove(item) - removes 'item' from S S.union(S2) - returns the union of S and S2

12 Dictionaries (Hashes) Dicts - Use a string key to lookup corresponding values. Unordered (indexable using keys) Mutable Created using curly braces & key:value pairs Example: >>> pets = { 'dog':'anna', 'cat':'paddington' } >>> pets {'dog': 'anna', 'cat': 'paddington'}

13 Dicts (Hashes) Think of dicts as: Named Lists (indexed based on names) When to use dicts: When it's more convenient to use names instead of numbers as indexes When we can uniquely identify items based on unique keys When NOT to use dicts: When a list would be just as good (dicts are less efficient) When order matters

14 Dicts Where D is the dict in question: D = { 'key1':'value1', 'key2':value2 '} D[key] - returns the value whose key is being indexed D.get(key) - returns D[key] D.items() - returns set of D's items (key value pairs) D.keys() - returns set of D's keys D.values() - returns set of D's values D.pop(key) return D[key] and remove it from D No sort() or reverse() - unordered No insert(), append() - add using 'D[key] = value'

15 References All variables for data structures only point to the data. Copy a pointer to a data structure vs. Copy/duplicate the actual data

16 References Copying lists: mylist = [1,2,3] yourlist = mylist[:] Copying tuples: #immutable so assignment is fine mytuple = (1,2,3) yourtuple = mytuple Copying sets: myset = { 'a','b','c' } yourset = myset.copy() Copying dicts: mydict = { 'key1':'value1', 'key2':'value2'} yourdict = mydict.copy()

17 Del Statement del is a built-in statement that you can use with lists and dicts to delete certain elements or slices. Mylist = ['list', 'of', 'strings', 'has', 'several', 'items'] del mylist[0] del mylist[1:] del mylist[:]

18 Built-in function functions len() is a built-in function will give you the size of any sequence (string, list, set, dict) max() is a built-in function will give you the maximum value in any sequence (string, list, set, dict) min() is a built-in function will give you the minimum value in any sequence (string, list, set, dict)

19 Iterating over Sequences data is any sequence data type (str, list, set, tuple, dict) for i in data: print(i)

20 Iterating over Dictionaries mydict = { 'dog':'anna', 'cat':'paddington' } # extra iterating options for item in mydict.items(): print(item) # item is a tupled key/value pair for key,value in mydict.items(): print(key, :,value) # key/value pairs

21 Nested Data Structures You can have data structures nested inside of other data structures Lists of Lists Dicts of Tuples Dicts of Lists etc.