Python introduction data structures lists etc

Introduction to Programming
Intro to Python
part 3

Lists
● A list is an object that holds a collection of objects; it represents a
sequence of data. In that sense, a list is similar to a string, except a
string can hold only characters.
● A list can hold any Python object. A list need not be homogeneous;
that is, the elements of a list do not all have to be of the same type.
3

List Slicing
• Retrieving a subset of items
• What are the outputs of

Functions and Methods for Lists
● There are several built-in functions that operate on lists. Here are
some useful ones:
● For example, the following computes the average of the values in a
list L:
●average = sum(L)/len(L)
7

● Here are some list methods:
8

Adding Items
• Need to use method
• List.Append( new_item )
• List.Insert(Index_Position, new_item)
• Does not needs to be next in sequence
• Updating values
• List[ index ] = new_value

Searching Items
• for item_to_search IN list_values
• List.index(item_to_search)
• ValueError if not found
• List.count(item_to_search)
• Occurences of item in list

Concatenation / Multiplier
• List.extend(other_list)
• Adds other_list to end of of List
• +=
• Same as above
• List_Values * num_of_times_to_repear

Removal
• List.remove(item_to_remove)
• Raises ValueError
• List.pop( [index] )
• del keyword
• Clear() method

Sorting
• List.sort()
• Key, reverse
• Sorted( any_iterable)
• Key, reverse
• Difference
• changes current vs returns new

● Important note There is a big difference between list methods and
string methods: String methods do not change the original string, but
list methods do change the original list.
● To sort a list L, just use L.sort() and not L=L.sort(). In fact, the latter
will not work at all.
14

Tuples
● A tuple is essentially an immutable list. Below is a list with three elements and a
tuple with three elements:
● Tuples are enclosed in parentheses, though the parentheses are actually
optional.
● Indexing and slicing work the same as with lists.
● As with lists, you can get the length of the tuple by using the len function, and,
like lists, tuples have count and index methods.
● However, since a tuple is immutable, it does not have any of the other methods
that lists have, like sort or reverse, as those change the list.
16
L = [1,2,3]
t = (1,2,3)

Tuples
● One reason why there are both lists and tuples is that in situations where speed
really matters, tuples are generally faster than lists.
● The flexibility of lists comes with a corresponding cost in speed.
● To convert an object into a tuple, use tuple.
● The following example converts a list and a string into tuples:
17
t1 = tuple([1,2,3])
t2 = tuple('abcde')

Packing / Unpacking Tuples
• To extract values of tuples
• Variable, after variable = tuple( first_item, item2 )
• * unpacks tuple to function arguments
• Create functions that return tuples

Sets, as in Mathematical Sets
• in mathematics, a set is a collection of objects, potentially of many
different types
• in a set, no two elements are identical. That is, a set consists of
elements each of which is unique compared to the other elements
• there is no order to the elements of a set
• a set with no elements is the empty set

Creating a set
Set can be created in one of two ways:
•constructor: set(iterable) where
the argument is iterable
my_set = set('abc')
my_set  {'a', 'b', 'c'}
•shortcut: {}, braces where the elements
have no colons (to distinguish them from
dicts)
my_set = {'a', 'b','c'}

Diverse elements
• A set can consist of a mixture of different types of
elements
my_set = {'a',1,3.14159,True}
• as long as the single argument can be iterated through,
you can make a set of it

no duplicates
• duplicates are automatically removed
my_set = set("aabbccdd")
print(my_set)
 {'a', 'c', 'b', 'd'}

common operators
Most data structures respond to these:
• len(my_set)
• the number of elements in a set
• element in my_set
• boolean indicating whether element is in the set
• for element in my_set:
• iterate through the elements in my_set

Set operators
• The set data structure provides some special operators that
correspond to the operators you learned in middle school.
• These are various combinations of set contents
• These operations have both a method name and a shortcut binary
operator

method: intersection, op: &
a_set=set("abcd") b_set=set("cdef")
a_set & b_set  {'c', 'd'}
b_set.intersection(a_set)  {'c', 'd'}
e f
a b c d

method:difference op:-
a_set – b_set  {'a', 'b'}
b_set.difference(a_set)  {'e', 'f'}
e f
a b c d

method: union, op: |
a_set | b_set  {'a', 'b', 'c', 'd', 'e', 'f'}
b_set.union(a_set)  {'a', 'b', 'c', 'd', 'e',
'f'}
a b c d e f

method: symmetric_difference, op: ^
a_set=set("abcd"); b_set=set("cdef")
a_set ^ b_set  {'a', 'b', 'e', 'f'}
b_set.symmetric_difference(a_set)  {'a', 'b',
'e', 'f'}
e f
a b c d

method: issubset, op: <=
method: issuperset, op: >=
small_set=set("abc"); big_set=set("abcdef")
small_set <= big_set  True
bit_set >= small_set  True
a b c d e f

Other Set Ops
• my_set.add("g")
• adds to the set, no effect if item is in set already
• my_set.clear()
• emptys the set
• my_set.remove("g") versus
my_set.discard("g")
• remove throws an error if "g" isn't there. discard doesn't
care. Both remove "g" from the set
• my_set.copy()
• returns a shallow copy of my_set

What is a dictionary?
• In data structure terms, a dictionary is better termed an associative
array, associative list or a map.
• You can think if it as a list of pairs, where the first element of the pair,
the key, is used to retrieve the second element, the value.
• We map a key to a value

Key Value pairs
• The key acts as an index to find the associated value.
• Just like a dictionary, you look up a word by its spelling to find the
associated definition
• A dictionary can be searched to locate the value associated with a key
• Key must be immutable
• strings, integers, tuples are fine
• lists are NOT
• Value can be anything

Dictionaries
● To declare a dictionary we enclose it in curly braces, {}.
● Each entry consists of a pair separated by a colon.
● The first part of the pair is called the key and the second is the value.
● The key acts like an index.
● Here is a simple dictionary:
● So in the first pair, 'A':100, the key is 'A', the value is 100, and d['A'] gives 100.
● Keys are often strings, but they can be integers, floats, and many other things as
well. You can mix different types of keys in the same dictionary and different
types of values, too.
35
d = {'A':100, 'B':200}

Functions and Methods for Dictionaries
● To change d['A'] to 400: d['A']=400
● To add a new entry to the dictionary, we can just assign it, like below: d['C']=500
● To delete an entry from a dictionary, use the del operator: del d['A']
● To copy a dictionary, use its copy method. Here is an example: d2 = d.copy()
● The empty dictionary is {}, which is the dictionary equivalent of [] for lists or '' for
strings.
36
d = {'A':100, 'B':200}

Functions and Methods for Dictionaries
● The dict function is another way to create a dictionary.
d = dict([('A',100),('B',300)])
● This creates the dictionary {'A':100,'B':300}. This way of building a
dictionary is useful if your program needs to construct a dictionary
while it is running.
37

Dictionary content methods
• my_dict.items() – all the key/value pairs
• my_dict.keys() – all the keys
• my_dict.values() – all the values
There return what is called a dictionary view.
• the order of the views corresponds
• are dynamically updated with changes

Views are iterable
for key in my_dict:
print key
• prints all the keys
for key,value in my_dict.items():
print key,value
• prints all the key/value pairs
for value in my_dict.values():
print value
• prints all the values

Python introduction data structures lists etc

More Related Content

Similar to Python introduction data structures lists etc (20)

Recently uploaded (20)

Python introduction data structures lists etc