Dictionaries

Dictionaries can be changed by adding new key-value pairs and by deleting or changing the existing ones. Hence they are called as mutable types.
For example:

d = {"a" : 1 , "b" : 2}
d["c"] = 3 
d["b"] = 4
del d["a"]
print(d)

Output

{'b': 4, 'c': 3} 

dict["c"] = 3 adds a new key-value pair to dict.
dict["b"] = 4 changes existing key-value pair in dict.
del dict["a"] removes the key-value pair "a" : 1

The different ways of creating dictionaries in Python are:

1. By using curly brackets and separating key-value pairs with commas as per the syntax below:

<dictionary-name> = {<key>:<value>, <key>:<value>...} 

For example:

 
d = {'a': 1, 'b': 2, 'c': 3} 

2. By using dictionary constructor dict(). There are multiple ways to provide keys and values to dict() constructor:

i. Specifying key:value pairs as keyword arguments to dict() function:
For example:

Employee = dict(name = 'john' , salary = 1000, age = 24)
print(Employee)

Output

{'name': 'john', 'salary': 1000, 'age': 24}  

ii. Specifying comma separated key:value pairs:
Key:value pairs are enclosed in curly braces in this format.
For example:

Employee = dict({'name': 'john', 'salary': 1000, 'age': 24})

Output

{'name': 'john', 'salary': 1000, 'age': 24} 

iii. Specifying keys and its corresponding values separately:
Keys and Values are enclosed separately in parentheses and are given as arguments to zip() function.
For example:

Employee = dict(zip(('name','salary','age'),('John',10000,24))) 

Output

{'name': 'John', 'salary': 10000, 'age': 24} 

iv. Specifying key:value pairs separately in form of sequences:
One list or tuple that contains lists/tuples of individual key:value pairs is passed as an argument to dict().
For example:

Employee = dict([['name','John'],['salary',10000],['age',24]]) 
print(Employee)

Output

{'name': 'John', 'salary': 10000, 'age': 24} 

3. By using fromkeys() function:
fromkeys() function is used to create a new dictionary from a sequence containing all the keys and a common value, which will be assigned to all the keys.
For example:

x = ('list', 'set', 'dictionary')
y = 'mutable'
my_dict = dict.fromkeys(x, y)
print(my_dict)

Output

{'list': 'mutable', 'set': 'mutable', 'dictionary': 'mutable'} 

A dictionary can have values of all data types i.e., integers, floats, strings, booleans, sequences and collections, etc. For example:

d = {1:'a' , 2: 2 , 3: True , 4: 3.5 , 5: "python",(1,2,3) : 4}

Individual elements of a dictionary can be accessed by using their corresponding keys as per the syntax shown below:

<dictionary-name> [<key>]

For example:

d = {'a': 1, 'b': 2, 'c': 3}
print(d['a'])

Output

1

In addition to this, we can also use the get( ) method to get value of the given key as per the syntax shown below:

<dictionary-name>.get(<key>, [default])

For example:

d = {'a': 1, 'b': 2, 'c': 3}
print(d.get('a'))

Output

1

In lists or strings, the elements are accessed through their index where as in dictionaries, the elements are accessed through the keys defined in the key:value pairs. Moreover, lists and strings are ordered set of elements but dictionaries are unordered set of elements so its elements cannot be accessed as per specific order.

The following types can be used as keys of a dictionary because they are immutable:

1. String
2. tuple
3. Integer
4. float

As lists and dictionaries are mutable so they cannot be used as keys of a dictionary.

Elements of a collection or sequence can be changed only if the collection or sequence is mutable. Hence, for dictionaries, the elements can be changed as dictionaries are mutable but for strings is cannot be changed as strings are immutable.

Example:

>>> d = {1 : 'a', 2: 'b'}
>>> d[1] = 'c'
>>> str = "hello"
>>> str[1] = "python"

Output

{1: 'c', 2: 'b'}
TypeError: 'str' object does not support item assignment   

Ordered Collection is the one in which the position of each element is fixed.
Example: List, strings, Tuples

Unordered Collection is the one in which position of each element is not fixed i.e., the order of all the elements are not maintained.
Example: Sets, Dictionaries

There are three ways by which new key:value pairs can be added to an existing dictionary:

1. By using assignment as per the following syntax:

<dictionary>[<key>] = <value>

For example:

d = {1 : 'a' , 2 : 'b'}
d[3] = 'c'
print(d)

Output

{1: 'a', 2: 'b', 3: 'c'}

2. By using update() method:
update() method merges key:value pairs from new dictionary into the original dictionary adding or replacing as needed. The syntax to use this method is:

<dictionary>.update(<other-dictionary>)

For example:

d = {1 : 'a' , 2 : 'b'}
d.update({3 : 'c'})
print(d)

Output

{1: 'a', 2: 'b', 3: 'c'}

3. Using setdefault() method:
It inserts a new key:value pair only if the key doesn't already exist. If the key already exists, it returns the current value of the key. The syntax to use this method is:

<dictionary>.setdefault(<key>,<value>)

For example:

d = {1 : 'a' , 2 : 'b'}
d.setdefault(3,'c')
print(d)

Output

{1: 'a', 2: 'b', 3: 'c'}

Yes, key:value pairs can be removed from a dictionary. The different methods to remove key:value pairs are given below:

1. By using del command:
It is used to delete an item with the specified key name. The syntax for doing so is as given below:

del <dictionary>[<key>]

For example:

dict =	{'list': 'mutable', 'tuple': 'immutable', 'dictionary': 'mutable'} 
del dict["tuple"]
print(dict)

Output

{'list': 'mutable', 'dictionary': 'mutable'} 

2. By using pop() method:
This method removes and returns the dicitionary element associated to the passed key. It is used as per the syntax:

<dict>.pop(key, <value>)

For example:

dict =	{'list': 'mutable', 'tuple': 'immutable', 'dictionary': 'mutable'} 
dict.pop("tuple")
print(dict)

Output

{'list': 'mutable', 'dictionary': 'mutable'} 

3. popitem() method:
This method removes and returns the last inserted item in the dictionary. It is used as per the syntax:

<dict>.popitem()

For example:

dict =	{'list': 'mutable', 'tuple': 'immutable', 'dictionary': 'mutable'} 
dict.popitem()
print(dict)

Output

{'list': 'mutable', 'tuple': 'immutable'} 

Here, the last element of dict was 'dictionary': 'mutable' which gets removed by function popitem().

unordered

Reason — Dictionary are unordered set of elements because it stores data as key-value pair and the pair of object they hold aren't indexed implicitly, that means we cannot refer to an item by using an index.

all of these

Reason — Dictionaries are called as:

1. mappings because a dictionary represents a mapping from keys to values that means each key "maps to" a value.
2. hashes because the keys of a dictionary in python are generated internally by a hashing function.
3. Associative arrays because it is an abstract data type that can also holds data in (key, value) pairs just like physical dictionary.

mutable

Reason — Dictionaries are mutable data types of Python since its entries can be added, removed, and changed in place.

items( )

Reason — items() method is used to return the list with all dictionary keys with values.
For example:

d = {'a':2, 'b':5} 
print(d.items())

Output

dict_items([('a', 2), ('b', 5)])

setdefault()

Reason — setdefault() function is used to return the value of a key (if the key is in dictionary). Else, it inserts a key with the default value to the dictionary.
For example:

d = {"list": "mutable","tuple": "immutable"}

d.setdefault("dictionaries", "mutable")

Output

mutable

Since "dictionaries" named key does not exist in dict, therefore setdefault() function inserts it to the dictionary d and returns the value of it.

fromkeys( )

Reason — fromkeys() function is used to create a new dictionary from a sequence containing all the keys and a common value, which will be assigned to all the keys.
For example:

x = ('list', 'set', 'dictionary')
y = 'mutable'
my_dict = dict.fromkeys(x, y)
print(my_dict)

Output

{'list': 'mutable', 'set': 'mutable', 'dictionary': 'mutable'} 

None

Reason — If no value is specified, the keys are assigned None as their default values.

all of these

Reason —

1. del keyword is used to delete an item with the specified key name.
   For example:

d =	{'list': 'mutable', 'tuple': 'immutable', 'dictionary': 'mutable'} 
del dict["tuple"]
print(d)

Output

{'list': 'mutable', 'dictionary': 'mutable'} 

del keyword deletes the key "tuple" and it's corresponding value.

2. pop() method removes the item with the specified key name: For example:

d =	{'list': 'mutable', 'tuple': 'immutable', 'dictionary': 'mutable'} 
d.pop("tuple")
print(d)

Output

{'list': 'mutable', 'dictionary': 'mutable'} 

The key named "tuple" is popped out. Hence dictionary d has only two key-value pairs.

3. popitem() method removes the last inserted item of dictionary.
   For example:

d =	{'list': 'mutable', 'tuple': 'immutable', 'dictionary': 'mutable'} 
d.popitem()
print(d)

Output

{'list': 'mutable', 'tuple': 'immutable'} 

Here, the last element of d was 'dictionary': 'mutable' which gets removed by function popitem().

del statement

Reason — For example:

d = {'list': 'mutable', 'tuple': 'immutable'} 
del d['dictionary']

Output

<module> KeyError: 'dictionary'

Since key named "dictionary" does not exist in d, del keyword will raise an error.

popitem()

Reason — Calling popitem() method on an empty dictionary will throw a KeyError.
For example:

d = {}
d.popitem()

Output

KeyError: 'popitem(): dictionary is empty'

shallow copy

Reason — Shallow copy means the content of the dictionary is not copied by value, but just creating a new reference. It is done by using copy() function on original dictionary.
For example:

original_dict = {1:'computer with python', 2:'computer with java'} 
new_dict = original_dict.copy()
print(new_dict)

Output

{1: 'computer with python', 2: 'computer with java'}

deep copy

Reason — A deep copy constructs a new compound object and then, recursively, inserts copies into it of the objects found in the original.

All of these.

Reason — The dictionary d has two key-value pairs where a and b are the keys and 3 and 7 are the values respectively. Therefore, all the statements are correct.

fall

Reason — The values of dictionaries can be accessed by giving the key inside the square brackets of dictionary. The expression d['autumn'] will return "fall" as autumn is the key of dictionary d so d['autumn'] will return its value i.e., "fall".

True

Reason — in operator is used to check whether a certain key is in the dictionary or not. It is also called containment check. It returns a boolean value.
Here, the expression "dog" in D1 will print true, since D1 contains "dog" key.

False

Reason — in operator is used to check whether a certain key is in the dictionary or not. It is also called containment check. It returns a boolean value.
Here, the expression 25 in D1 will print false, since D1 does not contain 25 key.

Error

Reason — In Dictionaries, the elements are accessed through the keys defined in key:value pairs not by indexes, therefore the expression d1[0] will raise an error as "0" is no such key defined in d1.

It will simply update the dictionary as:
d = {"Phy":94, "Che":72, "Bio":80, "Eng":95}.

Reason — The update() method updates the dictionary with the elements from another dictionary object or from an iterable of key/value pairs.
Here {"Che":72, "Bio":80} represents another dictionary with the help of which original d is updated i.e. the value of keys: "Che" and "Bio" are updated to 72 and 80 respectively.

{'Jo': 1, 'Ra': 2, 'Phoebe': 2}

Reason — The update() method updates the dictionary with the elements from another dictionary object or from an iterable of key/value pairs.
Here, {"Phoebe":2} is a dictionary of key named "Phoebe" which is not present in dict. Therefore, update function will add this key and its corresponding value to original dictionary dict.
Note: There is a misprint in the options provided in the book.

del di["tiger"]

Reason — del keyword is used to delete an item with the specified key name. Here, tiger is the key name which is specified with del statement in expression: del di["tiger"]. Hence, it will delete tiger entry from the di.

None of these

Reason — print(len(d1)) will print the length of d1 i.e. 3
print(d1.get("b")) will return the value of key "b" i.e. 2
d1["a"] = 5 will update the value of key "a" to 5.
Hence, all the expressions above will execute with no error.

(i), (ii)

Reason — Expression dict.pop("book") and del dict["book"] will give same output as both of them are removing the key "book" from dict i.e., {'diary': 1, 'novel': 5}

3, 2, 01

Reason — d1 is a dictionary containing three elements. str1 is initialized to an empty string.
Inside the for loop, the values of dictionary d1 are getting concatenated to str1 as a string. The statement str2 = str1[:-1] takes a slice of str1 from start to end and assigns to str2. So effectively, this statement is assigning str1 to str2.
The detailed execution of the for loop is shown in the table below:

Now the expression str2[::-1] will reverse the string "10 2 3" to '3 2 01'

Descending order (Z-A), by key

Reason — The sorted() function returns a sorted list of dictionary keys. By default, the sort order is ascending. To sort the keys in descending order, the reverse parameter must be set to true as an optional argument (sorted(my_dictionary, reverse = True)).

Dictionary is termed as an unordered collection of object because the printed order of elements is not same as the order in which the elements are stored.

Keys of a dictionary must be of immutable types such as

1. a Python string
2. a number
3. a tuple (containing only immutable entries)

The tuple should contain only immutable entries. Only then it can be used as a key in a dictionary.

1. Dictionary values can be all the data types of Python including collections and sequences.
2. Dictionary keys must be of immutable types like a string, a number, a tuple (containing only immutable entries).

No, the contents of a dictionary cannot be sorted in place like that of a list. However, we can indirectly sort the keys and values of a dictionary by using sorted() function:

• sorted(dictionary.keys())
• sorted(dictionary.values())
• sorted(dictionary)
• sorted(dictionary.items())

For example:

>>> d = {"def" : 2 ,"abc" : 1, "mno" : 3}
>>> sorted(d.keys())
>>> sorted(d.values())
>>> sorted(d)
>>> sorted(d.items())

Output

['abc', 'def', 'mno']  
[1, 2, 3]  
['abc', 'def', 'mno']  
[('abc', 1), ('def', 2), ('mno', 3)]  

This type of error occurs when a mutable type like list is used as a key in dictionary — d1 = {[4, 5] : "a"}

We cannot directly check for a value inside a dictionary using in operator since in operator searches for a key in a dictionary. We can use values() function along with in operator to check for a value in dictionary as shown below:

>>> d = {1: 'a' , 2:'b'}
>>> 'b' in d.values()

Output

True

Yes, we can modify the contents of a dictionary.
Values of key-value pairs are modifiable in dictionary. New key-value pairs can also be added to an existing dictionary and existing key-value pairs can be removed.
However, the keys of the dictionary cannot be changed. Instead we can add a new key : value pair with the desired key and delete the previous one.
For example:

d = { 1 : 1 }
d[2] = 2   
print(d)
d[1] = 3   
print(d)
d[3] = 2
print(d)
del d[2]
print(d)

Output

{1: 1, 2: 2}  
{1: 3, 2: 2} 
{1: 3, 2: 2, 3: 2}  
{1: 3, 3: 2} 

Explanation

d is a dictionary which contains one key-value pair.
d[2] = 2 adds new key-value pair to d.
d[1] = 3 modifies value of key 1 from 1 to 3.
d[3] = 2 adds new key-value pair to d.
del d[2] deletes the key 2 and its corresponding value.

del D is used to delete the whole dictionary where as del D[<key>] is used to delete only the key:value pair with the given key.
For example:

d = {1: 'a' , 2 : 'b'} 
del d[2] 
print(d)
del d
print(d)

Output

{1:'a'}
NameError: name 'd' is not defined.

The clear( ) function removes all the key:value pairs from the dictionary and makes it empty dictionary while del <dict> statement removes the complete dictionary as an object. After del statement with a dictionary name, that dictionary object no more exists, not even empty dictionary.
For example:

d = {1: 'a' , 2 : 'b'} 
d.clear()
print(d)
del d
print(d)

Output

{}
NameError: name 'd' is not defined.

The fromkeys() method is used to create a new dictionary from a sequence containing all the keys and a common value, which will be assigned to all the keys as per syntax shown below:

dict.fromkeys(<keys sequence>, [<value>])

For example:

x = ('list', 'set', 'dictionary')
y = 'mutable'
my_dict = dict.fromkeys(x, y)
print(my_dict)

Output

{'list': 'mutable', 'set': 'mutable', 'dictionary': 'mutable'} 

The differences between pop( ) and popitem( ) are mentioned below:

If only sorted() is applied on dictionary then it considers only the keys of the dictionary for sorting and returns a sorted list of the dictionary keys.
For example:

d = {2 : "def" , 3 : "abc" , 1 : "mno"}
print(sorted(d))

Output

[1, 2, 3] 

No, max( ) and min( ) will not always work for a dictionary. They will only work with dictionaries having homogeneous keys that can be compared.

It is not possible to use the sum( ) function to calculate the sum of values in a dictionary, as sum( ) function only works with the keys, and only when the keys are homogenous and addition compatible.

We can calculate the sum of the values of a dictionary with the help of values( ) and sum( ) functions as shown in the example below:

d = {"abc" : 1 ,"def" : 2 , "mno" : 3}
sum(d.values())

A shallow copy of a dictionary refers to a copy of the dictionary whereby only a copy of references (the keys) is created and the content (values of the dictionary) is not copied.

The copy() function is used to create a shallow copy of a dictionary where only a copy of keys is created and the values referenced are shared by the two copies.
For example:

original_d = {1:'a', 2:'b'} 
new_d = original_d.copy()
print(new_d)

Output

{1: 'a', 2: 'b'}

Here, original_d and new_d are two isolated objects, but their contents still share the same reference i.e ('a','b')

(i) the values are of immutable types
If the values are of immutable types then any changes made in the copy created with copy( ) will not be reflected in the original dictionary.
For example:

d1 = {1:'Neha' , 2: 'Saima' , 3: 'Avnit' , 4: 'Ana'}
d2 = d1.copy()
d2[5] = 'Taru'
print(d2)
print(d1)

Output

{1: 'Neha', 2: 'Saima', 3: 'Avnit', 4: 'Ana', 5: 'Taru'} 
{1: 'Neha', 2: 'Saima', 3: 'Avnit', 4: 'Ana'} 

(ii) the values are of mutable types
If the values are of mutable types then any changes made in the copy created with copy() will be reflected in the original dictionary.
For example:

d1 = {1:[1,2,3] , 2: [3,4,5]}
d2 = d1.copy()
d2[1].append(4)
print(d2)
print(d1)

Output

{1: [1, 2, 3, 4], 2: [3, 4, 5]}
{1: [1, 2, 3, 4], 2: [3, 4, 5]}

1. D + 3 — This will result in an error as dictionary does not support + operation.
2. D * 3 — This will result in an error as dictionary does not support * operation.
3. D + {3 : "3"} — This will result in an error as dictionary does not support + operation..
4. D.update( {3 : "3"}) — This will execute with no error since valid dictionary is passed to update( ) method.
5. D.update { {"3" : 3}} — This will result in an error since update( ) method syntax used here is invalid.
6. D.update("3" : 3) — This will result in an error since update( ) method always takes dictionary as it arguments which is not passed here. Hence it will lead to an error.

This type of error occurs when a mutable type is used as a key in dictionary. In d1, [1, "a"] is used as a key which is a mutable type of list. It will generate the below error:

TypeError: unhashable type: 'list'

This error can be fixed by using a tuple as a key instead of list as shown below:

d1  = {"a" : 1, 1 : "a", (1, "a") : "two"}

dict1 will be created successfully because tuples are used as keys. As tuples are immutable, therefore it won't give any error.

dict2 will give an error because the tuples used as keys of dict2 contain lists as their elements. As lists are mutable, so they can't appear in keys of the dictionary.

It can be corrected by removing list elements from the tuples as shown below:
dict2 = { (1,2) : [1,2], (3,4) : [3, 4]}

Dictionaries can be stored inside another dictionary as values and not as keys. Here, d4 is storing the other dictionaries as keys which is not allowed because dictionaries are mutable objects. That's why this code is raising error.
It can be corrected by using d1, d2, d3 as values of d4.
The corrected code is shown below:

d4 = { "a": d1, "b": d2, "c": d3}

The code is not giving the desired output because 25 is present in dic1 as a value and not as a key. "val in dic1" only checks val in the keys of dictionaries.
We can get the desired output by changing val in dic1 to val in dic1.values().

Output

dict_keys([5, 'a'])  
dict_values([[6, 7, 8], (1, 2, 3)])  

Explanation

keys() function returns all the keys defined in the dictionary in the form of a list. values() function returns all the values defined in the dictionary in the form of a list.

1. The output of line 1 is : 'd'
2. The output of line 2 is: 30
3. The output of line 3 is: False
   Since 30 is present in myDict as a value and not as a key.
4. The output of line 5 is: ('d',30)
myLst is a list which is created by dictionary items i.e myDict.items()
   Hence, myLst will store ⇒ [('a', 27), ('b', 43), ('c', 25), ('d', 30)]
myLst.sort() will sort the list in ascending order according to the first element of each tuple. Since the first elements of the tuples are all strings, Python performs lexicographical sorting, which means that 'a' comes before 'b' and so on.
   myLst[-1] will return last element of list i.e.,('d', 30).
5. The sort function in Line 4 will not return any value.
   It will sort myLst in place in ascending order according to the first element of each tuple. Since the first elements of the tuples are all strings, Python performs lexicographical sorting, which means that 'a' comes before 'b' and so on. The sorted myLst will be [('a', 27), ('b', 43), ('c', 25), ('d', 30)]

Output

Dictionary contents
5 : number numbernumbernumber

a : string stringstringstring

(1, 2) : tuple tupletupletuple

Explanation

d1 is a dictionary containing three key-value pairs.
x in d1.keys() represents that x will iterate on the keys of d1.
The iterations are summarized below:

Output

{left} and {right} or {right} and {left}

Explanation

The argument of print function is a string as it is enclosed in single quotes. Hence, it will get printed as is on the screen.

Output

>
>

end

Explanation

1. print(d['left'] and d['right'] or d['right'] and d['left'])
   1. and operator has higher precedence than or so d['left'] and d['right'] and d['right'] and d['left']) will be evaluated first.
   2. d['left'] and d['right'] will return value of d['right'] i.e. '>' because first operand of and operator is true so it will return the value of second operand.
   3. Similarly, d['right'] and d['left']) will return value of d['left'] i.e. '<'.
   4. Now the expression becomes '>' or '<'. This expression will evaluate to '>' as or operator returns its first operand if the first operand is true. (or operator returns its second operand only when its first operand is false). Thus, '>' gets printed as the first line of the output.
2. print(d['left'] and d['right'] or d['right'] and d['left'] and d['end'])
   1. and operator has higher precedence than or so d['left'] and d['right'] and d['right'] and d['left'] and d['end'] will be evaluated first.
   2. d['left'] and d['right'] will return value of d['right'] i.e. '>'.
   3. d['right'] and d['left'] will return value of d['left'] i.e. '<'. d['right'] and d['left'] and d['end'] becomes '<' and ' '. and operator returns its second operand in this case so the expression evaluates to ' '.
   4. Now the expression becomes '>' or ' '. or operator will return first operand in this case. Thus, '>' gets printed as the second line of the output.
3. print((d['left'] and d['right'] or d['right'] and d['left']) and d['end'])
   1. (d['left'] and d['right'] or d['right'] and d['left']) will be evaluated first as it is enclosed in parentheses. From part 1, we know this expression will return '>'.
   2. Now the expression becomes '>' and d['end'] i.e., '>' and ' '. and operator returns ' ', its second argument as its first argument is true. Thus, ' ' gets printed as the third line of the output.

Output

{'a': 7, 'b': 4, 'r': 4, 'c': 3, 'd': 1} 
['a', 'b', 'r', 'c', 'd']

Explanation

This python program counts the frequency of each character in a string. Here is a step-by-step explanation of the program:

1. Initialize the variables
   1. The text variable stores the input string "abracadabraaabbccrr".
   2. The counts variable is a dictionary that stores the frequency of each character in the string.
   3. The ct variable is a counter that keeps track of the total number of characters in the string.
   4. The lst variable is a list that stores the unique characters in the string.
2. Loop through each character word in the text string
   1. If the character has not been seen before, it is added to the lst list and a new key is added to the counts dictionary with a value of 0.
   2. The ct variable is incremented by 1.
   3. The value of the character's key in the counts dictionary is incremented by 1. This value keeps a count of the number of times this character has appeared in the string so far.
3. Finally, the counts dictionary and the lst list are printed to the console. The counts dictionary displays the frequency of each character in the string, and the lst list displays the unique characters in the string.

Output

{2: 3, 3: 3, 5: 2, 1: 2} 
{2: 6, 3: 9, 5: 10, 1: 2} 

Explanation

This python program counts the frequency of each number in a list and then multiplies each frequency by its corresponding number. Here is a step-by-step explanation of the program:

1. Initialize the variables
   1. The list1 variable stores the input list [2, 3, 3, 2, 5, 3, 2, 5, 1, 1].
   2. The counts variable is a dictionary that stores the frequency of each number in the list.
   3. The ct variable is a counter that keeps track of the total number of numbers in the list.
   4. The lst variable is a list that stores the unique numbers in the list.
2. Loop through each number num in the list1
   1. If the number has not been seen before, it is added to the lst list and a new key is added to the counts dictionary with a value of 0.
   2. The ct variable is incremented by 1.
   3. The value of the number's key in the counts dictionary is incremented by 1.
3. The counts dictionary is printed to the console after the first loop, displaying the frequency of each number in the list.
4. Another loop is executed through the keys in the counts dictionary. For each key, its corresponding value is multiplied by the key and the new value is assigned back to the key in the counts dictionary.
5. The final counts dictionary is printed to the console, showing the frequency of each number multiplied by the number itself.

>>> ODD = { 1 : 'One', 3 : 'Three', 5 : 'Five', 7 : 'Seven', 9 : 'Nine' }

>>> ODD.keys()
# (1) Display the keys

>>> ODD.values()
# (2) Display the values

>>> ODD.items()
# (3) Display the items

>>> len(ODD)
# (4) Find the length of the dictionary

>>> 7 in ODD
# (5) Check if 7 is present or not 

>>> 2 in ODD
# (6) Check if 2 is present or not 

>>> ODD[9]
# (7) Retrieve the value corresponding to the key 9

>>> del ODD[9]
# (8) Delete the item from the dictionary corresponding to the key 9

Output

dict_keys([1, 3, 5, 7, 9]) 
dict_values(['One', 'Three', 'Five', 'Seven', 'Nine'])  
dict_items([(1, 'One'), (3, 'Three'), (5, 'Five'), (7, 'Seven'), (9, 'Nine')]) 
5
True
False
Nine

Output

KeyError: 'a' 

Explanation

The line counts[word] = counts[word] + 1 will cause a KeyError because we are trying to access a key word of an empty dictionary. As the key is not present in dictionary counts, hence a KeyError is generated.

Output

TypeError: unhashable type: 'list'

Explanation

The line my_dict[[4,2,1]] = 10 is in error because a list is being used as a key of the dictionary. Lists being mutable data types are not allowed as keys in a dictionary.

Output

3
{'Apple': 1, 'banana': 1, 'apple': 1} 

Explanation

This python program counts the frequency of each fruit in a list and outputs the number of unique fruits and their frequency. The program does not account for the case sensitivity of the fruit names so "Apple" and "apple" are counted as separate fruits. Here is a step-by-step explanation of the program:

1. Initialize the variables
   1. The fruit variable is a dictionary that stores the frequency of each fruit.
   2. The L1 variable stores the input list ['Apple', 'banana', 'apple'].
2. Loop through each fruit index in the list L1
   1. If the fruit already exists as a key in the fruit dictionary, its value is incremented by 1.
   2. If the fruit is not in the fruit dictionary, a new key is added with a value of 1.
3. The length of the fruit dictionary is printed to the console, indicating the number of unique fruits.
4. The fruit dictionary is printed to the console, showing the frequency of each fruit.

Output

4

Explanation

This python program computes the sum of values of items in the dictionary.

The arr dictionary is created and initialized with two key-value pairs, arr[1] = 1 and arr['1'] = 2. After that, the value of arr[1] is incremented by 1. At this point arr = {1: 2, '1': 2}.

The program iterates through each key k in the arr dictionary and adds the value arr[k] to the sum variable.

The final value of the sum variable is printed to the console.

Output

1

Explanation

a is a dictionary containing two key-value pair.
(1,2) is a key of a. Therefore, a[1,2] represents value of key 1,2 i.e.,1

Output

KeyError: ('a', 'b')  

Explanation

a is a dictionary containing three key-value pairs.
a['a','b'] will throw an error since given key ('a','b') is not present in dictionary a.

The code given in set (a) will produce an error.
In the line print(len(crates[box])), we are trying to print the value from dictionary crates by taking mutable type dictionary i.e box as key — crates[box]. The keys of the dictionary cannot be of mutable type, hence this code produces this error.

The code given in set (b) is correct. Its output is as shown below:

Output of set (b) code

2

Explanation

crates['box'] will return the value of key 'box' from dictionary crates i.e, box. box is itself a dictionary containing two key-value pairs i.e:
{'biscuit': 1, 'cake': 3}
Therefore, the expression len(crates['box']) becomes len(box) which will return the length of box i.e., 2.

Output

1 0
1 4
6

Explanation

This python program computes the sum of values of items in the dictionary. It also demonstrates that dictionaries in Python can have both integer and string keys, but the keys must be unique.

The keys 1 and '1' will be treated as two different keys as the former is a number and the latter is a string. But the keys 1 and 1.0 are considered the same as both represent number 1.

Here is a step-by-step explanation of the program:

1. The dct dictionary is created and initialized with two key-value pairs, dct[1] = 1 and dct['1'] = 2.

2. After that, dct[1.0] = 4 updates the value of key 1 to 4 as the keys 1 and 1.0 are considered the same. At this point, dct = {1: 4, '1': 2}.

3. Loop through each key k in dct. Below table shows the loop iterations:

4. The final value of the sum variable is printed to the console.

1. items
2. value
3. key

The completed program is given below for reference:

d = {'a':1, 'b':2, 'c':3}
print(d)
fd = {}
for key, value in d.items():
  fd[value] = key 	
print(fd)