4.3 - Functions, Tuples, Dictionaries, Exceptions and Data Processing (PCEP-30)
Write a program that will convert the my_list list to a tuple. (flip) my_list = ["car", "Ford", "flower", "Tulip"] t = tuple(my_list) print(t)
('car', 'Ford', 'flower', 'Tulip')
tuple - example tuple_1 = (1, 2, 4, 8) tuple_2 = 1., .5, .25, .125 print(tuple_1) print(tuple_2) (flip for output)
(1, 2, 4, 8) (1.0, 0.5, 0.25, 0.125)
example my_tuple = (1, 10, 100, 1000) print(my_tuple[0]) print(my_tuple[-1]) print(my_tuple[1:]) print(my_tuple[:-2]) for elem in my_tuple: *print(elem) (flip card for output)
1 1000 (10, 100, 1000) (1, 10) 1 10 100 1000
2 of 3 pol_eng_dictionary = { *"zamek": "castle", *"woda": "water", *"gleba": "soil" *} print(len(pol_eng_dictionary)) del pol_eng_dictionary["zamek"] # remove an item print(len(pol_eng_dictionary)) (flip for outputs)
3 2
You can create an empty tuple like this: empty_tuple = () print(type(empty_tuple))
<class 'tuple'>
The order in which a dictionary stores its data is completely out of your control, and your expectations. That's normal. (flip)
In Python 3.6x dictionaries have become ordered collections by default. Your results may vary depending on what Python version you're using.
adding a new key; dictionary Adding a new key-value pair to a dictionary is as simple as changing a value - you only have to assign a value to a new, previously non-existent key. (flip)
Note: this is very different behavior compared to lists, which don't allow you to assign values to non-existing indices.
If you want to loop through a dictionary's keys and values, you can use the items() method pol_eng_dictionary = { *"zamek": "castle", *"woda": "water", *"gleba": "soil" *} for key, value in pol_eng_dictionary.items(): *print("Pol/Eng ->", key, ":", value) (flip for output)
Pol/Eng -> zamek : castle Pol/Eng -> woda : water Pol/Eng -> gleba : soil
What is the output of the following snippet? (flip) tup = 1, 2, 3 a, b, c = tup print(a * b * c)
The program will print 6 to the screen. The tup tuple elements have been "unpacked" in the a, b, and c variables.
tuple - example tuple_1 = (1, 2, 4, 8) tuple_2 = 1., .5, .25, .125 (flip)
There are two tuples, both containing four elements.
immutable data; Imagine that a list can only be assigned and read over. You would be able neither to append an element to it, nor remove any element from it. (flip for further explanation)
This means that appending an element to the end of the list would require the recreation of the list from scratch.
You can access tuple elements by indexing them my_tuple = (1, 2.0, "string", [3, 4], (5, ), True) print(my_tuple[3]) (flip)
[3, 4]
For example, you have an English word (e.g., cat) and need its French equivalent. You browse the dictionary in order to find the word (you may use different techniques to do that - it doesn't matter) (flip)
and eventually you get it. Next, you check the French counterpart and it is (most probably) the word "chat".
4 of 4 - example (flip for output) dictionary = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"} for key in sorted(dictionary.keys()): *print(key, "->", dictionary[key])
cat -> chat dog -> chien horse -> cheval
3 of 3 (flip for output) dictionary = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"} for english, french in dictionary.items(): *print(english, "->", french)
cat -> chat dog -> chien horse -> cheval Note the way in which the tuple has been used as a for loop variable.
example (flip for output) dictionary = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"} words = ['cat', 'lion', 'horse'] for word in words: *if word in dictionary: **print(word, "->", dictionary[word]) *else: **print(word, "is not in dictionary")
cat -> chat lion is not in dictionary horse -> cheval
If you want to get any of the values out of a dictionary, you have to deliver a valid key value: print(dictionary['cat']) print(phone_numbers['Suzy']) (flip for output)
chat 22657854310
2 of 3 (flip for output) dictionary = {"cat": "chat", "dog": "chien", "horse": "cheval"} for french in dictionary.values(): *print(french)
cheval chien chat As the dictionary is not able to automatically find a key for a given value, the role of this method is rather limited.
3 of 4 - example (flip for output) dictionary = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"} for key in dictionary.keys(): *print(key, "->", dictionary[key])
horse -> cheval dog -> chien cat -> chat
tuples prefer to use parenthesis; although it's also possible to create a tuple just from a set of values separated by commas. (flip for further info)
lists like to see brackets
If you want to change the value associated with a specific key, you can do so by referring to the item's key name in the following way: pol_eng_dictionary = { *"zamek": "castle", *"woda": "water", *"gleba": "soil" *} pol_eng_dictionary["zamek"] = "lock" item = pol_eng_dictionary["zamek"] print(item)
lock
If you want to create a "one-element tuple", you have to take into consideration the fact that, due to syntax reasons; a tuple has to be distinguishable from an ordinary, single value; you must "end the value with a comma" (flip for example)
one_element_tuple_1 = (1, ) one_element_tuple_2 = 1.,
A one-element tuple may be created as follows: one_elem_tuple_1 = ("one", ) one_elem_tuple_2 = "one", (flip for additional info)
parenthesis or no parenthesis; but you need a comma for python to know its a tuple. Otherwise it's a variable
2 of 2 pol_eng_dictionary = { *"kwiat": "flower", *"woda": "water", *"gleba": "soil" *} item_1 = pol_eng_dictionary["gleba"] print(item_1) item_2 = pol_eng_dictionary.get("woda") print(item_2)
soil water
"Dictionaries" are unordered*, 'changeable' (mutable), and indexed collections of data
true
"Immutable" datatypes are objects that "cannot be modified or altered" after they have been created
true
"In situ" is a Latin phrase that translates as literally "in position". For example, the following instruction modifies the data in situ: list.append(1)
true
"Mutable" data can be freely updated at any time - we call such an operation "in situ".
true
# Example 1 (didn't put output on next side) tuple_1 = (1, 2, 3) for elem in tuple_1: *print(elem) # Example 2 tuple_2 = (1, 2, 3, 4) print(5 in tuple_2) print(5 not in tuple_2) # Example 3 tuple_3 = (1, 2, 3, 5) print(len(tuple_3)) # Example 4 tuple_4 = tuple_1 + tuple_2 tuple_5 = tuple_3 * 2 print(tuple_4) print(tuple_5)
true
'Tuples' are ordered and unchangeable (immutable) collections of data. They can be thought of as 'immutable lists'. They are written in round brackets
true
'pairs' themselves are "separated by commas" phone_numbers = {'boss': 5551234567, 'Suzy': 22657854310}
true
1 of 2 If you want to access a dictionary item, you can do so by making a reference to its key inside a pair of square brackets (ex. 1) or by using the get() method (ex. 2)
true
1 of 2 You can also insert an item to a dictionary by using the update() method, and remove the last element by using the popitem() method
true
1 of 3 Another way is based on using a dictionary's method named " items() "
true
1 of 3 You can use the del keyword to remove a specific item, or delete a dictionary. To remove all the dictionary's items, you need to use the clear() method
true
1 of 3 There is also a method named " values() ", which works similarly to keys(), but 'returns values'
true
1 of 3; Can dictionaries be browsed using the for loop, like lists or tuples? No and yes.
true
1 of 4 The first of them is a method named keys(), possessed by each dictionary.
true
2 of 3 Items(); returns tuples; this is the first example where tuples are something more than just an example of themselves; where each tuple is a key-value pair
true
2 of 3; No, because a dictionary is not a sequence type - the for loop is useless with it.
true
2 of 4 The method returns an iterable object consisting of all the keys gathered within the dictionary. Having a group of keys enables you to access the whole dictionary in an easy and handy way.
true
3 of 3 Yes, because there are simple and very effective tools that can adapt any dictionary to the for loop requirements in other words, building an intermediate link between the dictionary and a temporary sequence entity
true
3 of 3 pol_eng_dictionary = { *"zamek": "castle", *"woda": "water", *"gleba": "soil" *} pol_eng_dictionary.clear() # removes all the items print(len(pol_eng_dictionary)) # outputs: 0 del pol_eng_dictionary # removes the dictionary
true
A "sequence type" is a type of data in Python which is able to store more than one value; or less than one, as a sequence may be empty; and these values can be sequentially (hence the name) browsed, element by element.
true
A "tuple" is an "immutable" sequence type. It can behave like a list, but it mustn't be modified in situ
true
A hanging indent is a type of indentation where the first line of a paragraph is not indented, but subsequent lines in the same paragraph are indented.
true
As the "for loop" is a tool especially designed to iterate through sequences, we can express the definition as: a sequence is data which can be scanned by the for loop.
true
Assigning a 'new value to an existing key' is simple - as 'dictionaries are fully mutable', there are no obstacles to modifying them.
true
Complete the code to correctly use the count() method to find the number of duplicates of 2 in the following tuple tup = 1, 2, 3, 2, 4, 5, 6, 2, 7, 2, 8, 9 duplicates = tup.count(2) print(duplicates) # outputs: 4
true
Each dictionary is a set of ' key: value pairs '. You can create it by using the following syntax: my_dictionary = { *key1: value1, *key2: value2, *key3: value3, *}
true
Each tuple element may be of a different type (i.e., integers, strings, booleans, etc.). What is more, tuples can contain other tuples or lists (and the other way round).
true
First of all, it's a confirmation that "dictionaries are not lists" - they don't preserve the order of their data, as the 'order is completely meaningless'
true
Fortunately, there's a simple way to avoid such a situation. The "in" operator, together with its companion, "not in", can salvage this situation.
true
Getting a dictionary's value resembles "indexing", especially thanks to the "brackets" surrounding the key's value. Note: if the key is a string, you have to specify it as a string; "keys are case-sensitive": 'Suzy' is something different from 'suzy'.
true
Have you noticed anything surprising? The "order of the printed pairs is different than in the initial assignment". What does that mean?
true
However, you can delete a tuple as a whole: my_tuple = 1, 2, 3, del my_tuple print(my_tuple) # NameError: name 'my_tuple' is not defined
true
IMPORTANT: getting a value from a dictionary you "mustn't use a non-existent key" will cause a runtime error.
true
If you want to get the elements of a tuple in order to read them, you can use the same conventions to which you're accustomed while using lists.
true
It is possible to create an empty tuple - parentheses are required then: empty_tuple = ()
true
Note: each tuple element may be of a different type (floating-point, integer, or any other not-as-yet-introduced kind of data).
true
One of the most useful tuple properties is their ability to appear on the "left side of the assignment operator"
true
Removing the commas won't spoil the program in any syntactical sense, but you will instead get two single variables, not tuples
true
The "dictionary" is another Python data structure. It's "not" a sequence type; but can be easily adapted to sequence processing; and it is mutable.
true
The Python dictionary works in the same way as a bilingual dictionary
true
The dictionary as a whole can be printed with a single print() invocation. phone_numbers = {'boss': 5551234567, 'Suzy': 22657854310} print(phone_numbers)
true
The first and the clearest distinction between lists and tuples is the "syntax used to create them"
true
The list is a classic example of a Python sequence
true
The list of pairs is surrounded by "curly braces" dictionary = {"cat": "chat", "dog": "chien", "horse": "cheval"}
true
The similarities may be misleading - don't try to modify a tuple's contents! It's not a list!
true
This means that a dictionary is a set of key-value pairs
true
To copy a dictionary, use the copy() method: pol_eng_dictionary = { *"zamek": "castle", *"woda": "water", *"gleba": "soil" *} copy_dictionary = pol_eng_dictionary.copy()
true
Tuples are immutable, which means you cannot change their elements; you cannot append tuples, or modify, or remove tuple elements
true
You can loop through a tuple elements (Example 1), check if a specific element is (not)present in a tuple (Example 2), use the len() function to check how many elements there are in a tuple (Example 3), or even join/multiply tuples (Example 4):
true
a dictionary is a one-way tool - if you have an English-French dictionary, you can look for French equivalents of English terms, but not vice versa.
true
a dictionary is not a list - a list contains a set of numbered values, while a dictionary holds pairs of values
true
a key may be any immutable type of object: it can be a number (integer or float), or even a string, but not a list
true
a tuple's elements can be variables, not only literals. Moreover, they can be expressions if they're on the right side of the assignment operator
true
continued In the first example, the dictionary uses keys and values which are both strings. In the second one, the keys are strings, but the values are integers. The reverse layout (keys → numbers, values → strings) is also possible, as well as number-number combination.
true
dictionaries; In Python's world, the word you look for is named a "key". The word you get from the dictionary is called a "value".
true
each key must be unique - it's not possible to have more than one key of the same value
true
example of a tuple my_tuple = (1, 2, True, "a string", (3, 4), [5, 6], None)
true
key-value pairs sandwiched by colons dictionary = {"cat": "chat", "dog": "chien", "horse": "cheval"}
true
mutability - is a property of any of Python's data that describes its readiness to be freely changed during program execution. There are two kinds of Python data: mutable and immutable
true
removing a key; will always cause the removal of the associated value. Values cannot exist without their keys. This is done with the del instruction.
true
the * operator can multiply tuples, just like lists
true
the + operator can join tuples together
true
the len() function accepts tuples, and returns the number of elements contained inside
true
the len() function works for dictionaries, too - it returns the numbers of key-value pairs in the dictionary
true
tuples and dictionaries can work together
true
tuples; the in and not in operators work in the same way as in lists.
true
start of key takessss
ttt
What is the output of the following program? colors = { * "white": (255, 255, 255), * "grey": (128, 128, 128), * "red": (255, 0, 0), * "green": (0, 128, 0) * } for col, rgb in colors.items(): * print(col, ":", rgb)
white : (255, 255, 255) grey : (128, 128, 128) red : (255, 0, 0) green : (0, 128, 0)
To check if a given key exists in a dictionary, you can use the in keyword: pol_eng_dictionary = { *"zamek": "castle", *"woda": "water", *"gleba": "soil" *} if "zamek" in pol_eng_dictionary: *print("Yes") else: *print("No")
yes
You can use the for loop to loop through a dictionary pol_eng_dictionary = { *"zamek": "castle", *"woda": "water", *"gleba": "soil" *} for item in pol_eng_dictionary: print(item) (flip for outputs)
zamek woda gleba
Write a program that will "glue" the two dictionaries (d1 and d2) together and create a new one (d3). (flip) d1 = {'Adam Smith': 'A', 'Judy Paxton': 'B+'} d2 = {'Mary Louis': 'A', 'Patrick White': 'C'} d3 = {} for item in (d1, d2): *d3.update(item) print(d3)
{'Adam Smith': 'A', 'Judy Paxton': 'B+', 'Mary Louis': 'A', 'Patrick White': 'C'}
To add or remove a key (and the associated value), use the following syntax: phonebook = {} phonebook["Adam"] = 3456783958 print(phonebook) del phonebook["Adam"] print(phonebook) (flip for outputs)
{'Adam': 3456783958} {}
example - adding a new key-value pair to a dictionary dictionary = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"} dictionary['liger'] = 'ligre' print(dictionary)
{'cat': 'chat', 'dog': 'chien', 'horse': 'cheval', 'liger': 'ligre'}
example - removing key dictionary = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"} del dictionary['dog'] print(dictionary) (flip)
{'cat': 'chat', 'horse': 'cheval'}
example - (flip for output) dictionary = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"} dictionary['cat'] = 'minou' print(dictionary)
{'cat': 'minou', 'dog': 'chien', 'horse': 'cheval'}
Write a program that will convert the colors tuple to a dictionary. colors = (("green", "#008000"), ("blue", "#0000FF")) colors_dictionary = dict(colors) print(colors_dictionary)
{'green': '#008000', 'blue': '#0000FF'}
2 of 2 pol_eng_dictionary = {"kwiat": "flower"} pol_eng_dictionary.update({"gleba": "soil"}) print(pol_eng_dictionary) pol_eng_dictionary.popitem() print(pol_eng_dictionary)
{'kwiat': 'flower', 'gleba': 'soil'} {'kwiat': 'flower'}
