Dictionary

A dictionary is a collection of key-value pairs, similar to a hashmap. Dictionaries are mutable which means that elements can be added, modified, and removed. Keys must be immutable and hashable (like strings, numbers, or tuples), while values can be of any type, including mutable types like lists.

Creating a Dictionary

Dictionaries can be created using curly braces {} with key-value pairs separated by colons:

1
empty_dict = {}
2
weather = {
3
    "weather": "rainy",
4
    "temp": "-2.0C"
5
}
6
print(weather["weather"])  # rainy

Using the `dict()` Constructor

The dict() constructor can create dictionaries in several ways:

From keyword arguments: Pass key-value pairs as keyword arguments (keys must be valid Python identifiers):

1
weather = dict(weather="rainy", temp="-2.0C")
2
print(weather)  # {'weather': 'rainy', 'temp': '-2.0C'}

From a list/tuple of pairs: Pass an iterable containing key-value pairs:

1
# From a list of lists
2
pairs = [["weather", "rainy"], ["temp", "-2.0C"]]
3
weather = dict(pairs)
4
print(weather)  # {'weather': 'rainy', 'temp': '-2.0C'}
5

6
# From a list of tuples
7
pairs = [("weather", "rainy"), ("temp", "-2.0C")]
8
weather = dict(pairs)
9
print(weather)  # {'weather': 'rainy', 'temp': '-2.0C'}
10

11
# From a tuple of ranges (creates keys from range values)
12
ranges = (range(2), range(5, 7))
13
numbers = dict(ranges)
14
print(numbers)  # {0: 5, 1: 6}

Empty dictionary: Call dict() with no arguments:

1
empty = dict()
2
print(empty)  # {}

From both list of pairs and keyword arguments: Pass a list of pairs and keyword arguments:

1
weather = dict(("weather", "rainy"), ("temp", "-2.0C"), weather="rainy", temp="-2.0C", )
2
print(weather)  # {'weather': 'rainy', 'temp': '-2.0C'}

Warning
Dictionary keys must be unique. If the same key is specified multiple times, the last value will overwrite previous values.

Note
Keys must be hashable (immutable) types. Strings, numbers, and tuples (containing hashable elements) can be used as keys, but not lists or other dictionaries.

Accessing Dictionary Elements

There are several ways to access values in a dictionary:

Using Square Brackets

Given a key, its value can be accessed using square brackets d[key]:

1
weather = {"weather": "rainy", "temp": "-2.0C"}
2
print(weather["weather"])  # rainy

Warning
Accessing a key that doesn’t exist using square brackets will raise a KeyError:
1
weather = {"weather": "rainy"}
2
print(weather["temp"])  # KeyError: 'temp'

Using `.get()` Method

The .get(key, default=None) method returns the value associated with the given key. If the key is not present, it returns the default value (or None if no default is specified) instead of raising an error:

1
weather = {"weather": "rainy", "temp": "-2.0C"}
2

3
print(weather.get("weather"))  # rainy
4
print(weather.get("humidity"))  # None
5
print(weather.get("humidity", "unknown"))  # unknown

Dictionary Views

Dictionaries provide three view objects that reflect the current state of the dictionary:

.keys(): Returns a view of all keys in the dictionary
.values(): Returns a view of all values in the dictionary
.items(): Returns a view of all key-value pairs as tuples

1
weather = {"weather": "rainy", "temp": "-2.0C"}
2

3
print(weather.keys())  # dict_keys(['weather', 'temp'])
4
print(weather.values())  # dict_values(['rainy', '-2.0C'])
5
print(weather.items())  # dict_items([('weather', 'rainy'), ('temp', '-2.0C')])

Tip
These views are “live” which means they automatically reflect changes to the dictionary. They can be converted to lists if needed: list(dict.keys()).

Checking Membership

Keys can be checked for existence in a dictionary using the in and not in operators:

1
weather = {"weather": "rainy", "temp": "-2.0C"}
2

3
print("weather" in weather)  # True
4
print("humidity" in weather)  # False
5
print("temp" not in weather)  # False
6

7
# Can also check using .keys()
8
print("weather" in weather.keys())  # True

Note
The in operator checks for keys, not values. To check if a value exists, use value in dict.values().

Looping Over a Dictionary

A dictionary can be looped over in several ways:

Accessing Keys

Keys can be iterated over directly or using .keys():

1
weather = {"weather": "rainy", "temp": "-2.0C"}
2

3
# Iterate over keys directly
4
for key in weather:
5
    print(f"{key}={weather[key]}")
6

7
# Iterate using .keys()
8
for key in weather.keys():
9
    print(f"{key}={weather[key]}")

Accessing Values

Values can be iterated over using .values():

1
weather = {"weather": "rainy", "temp": "-2.0C"}
2

3
for value in weather.values():
4
    print(value)

Accessing Key-Value Pairs

The most Pythonic way is to iterate over .items() to get both keys and values:

1
weather = {"weather": "rainy", "temp": "-2.0C"}
2

3
for key, value in weather.items():
4
    print(f"{key}={value}")

Adding and Updating Elements

Single Update

Values can be added or modified by assigning to a key using square brackets. If the key doesn’t exist, it will be added; if it exists, its value will be updated:

1
weather = {"weather": "rainy"}
2

3
weather["temp"] = "-2.0C"  # Adds new key-value pair
4
weather["weather"] = "sunny"  # Updates existing key
5
print(weather)  # {'weather': 'sunny', 'temp': '-2.0C'}

Bulk Update with `.update()`

The .update([E,]**F) method allows merging dictionaries or updating from iterables:

If E has a .keys() method (like a dictionary), it does: for k in E: D[k] = E[k]
If E lacks .keys() method (like a list of pairs), it does: for k, v in E: D[k] = v
Then it processes keyword arguments: for k in F: D[k] = F[k]

1
d = {}
2

3
# Update with dictionary and keyword arguments
4
d.update({"a": "b"}, c="d", e="f")
5
print(d)  # {'a': 'b', 'c': 'd', 'e': 'f'}
6

7
# Update with keyword arguments
8
d.update(g="h")
9
print(d)  # {'a': 'b', 'c': 'd', 'e': 'f', 'g': 'h'}
10

11
# Update with dictionary
12
d.update({"i": "j"})
13
print(d)  # {'a': 'b', 'c': 'd', 'e': 'f', 'g': 'h', 'i': 'j'}
14

15
# Update with list of pairs
16
d.update([("k", "l")])
17
print(d)  # {'a': 'b', 'c': 'd', 'e': 'f', 'g': 'h', 'i': 'j', 'k': 'l'}
18

19
# Update with tuple of pairs
20
d.update((("m", "n"),))
21
print(d)  # {'a': 'b', 'c': 'd', 'e': 'f', 'g': 'h', 'i': 'j', 'k': 'l', 'm': 'n'}

Removing Elements

There are several ways to remove elements from a dictionary:

Using `.pop()`

The .pop(key[, default]) method removes the item associated with the key and returns its value. If the key is not present, it returns the default value (if specified) or raises a KeyError:

1
weather = {"weather": "rainy", "temp": "-2.0C"}
2

3
value = weather.pop("weather")
4
print(value)  # rainy
5
print(weather)  # {'temp': '-2.0C'}
6

7
# With default value
8
value = weather.pop("humidity", "unknown")
9
print(value)  # unknown (key didn't exist, returned default)
10

11
# Without default (raises KeyError if key doesn't exist)
12
value = weather.pop("humidity")  # KeyError: 'humidity'

Using `.clear()`

The .clear() method removes all elements from the dictionary:

1
weather = {"weather": "rainy", "temp": "-2.0C"}
2
weather.clear()
3
print(weather)  # {}

Using `del` Statement

The del statement can remove a specific key-value pair:

1
weather = {"weather": "rainy", "temp": "-2.0C"}
2
del weather["weather"]
3
print(weather)  # {'temp': '-2.0C'}

Notable Dictionary Methods

`.copy()`

Creates a shallow copy of the dictionary:

1
original = {"a": 1, "b": 2}
2
copy = original.copy()
3
copy["a"] = 10
4
print(original)  # {'a': 1, 'b': 2}
5
print(copy)  # {'a': 10, 'b': 2}

`.fromkeys(iterable, value=None)`

Creates a new dictionary with keys from the iterable and all values set to the specified value:

1
keys = ["a", "b", "c"]
2
d = dict.fromkeys(keys, 0)
3
print(d)  # {'a': 0, 'b': 0, 'c': 0}
4

5
# Without value (defaults to None)
6
d = dict.fromkeys(keys)
7
print(d)  # {'a': None, 'b': None, 'c': None}

`.setdefault(key, default=None)`

Inserts the key with the default value if the key is not in the dictionary, then returns the value associated with the key:

1
weather = {"weather": "rainy"}
2

3
# Key exists, returns existing value
4
value = weather.setdefault("weather", "sunny")
5
print(value)  # rainy
6
print(weather)  # {'weather': 'rainy'}
7

8
# Key doesn't exist, adds it and returns default
9
value = weather.setdefault("temp", "-2.0C")
10
print(value)  # -2.0C
11
print(weather)  # {'weather': 'rainy', 'temp': '-2.0C'}

Built-in Functions with Dictionaries

Several built-in functions can be used with dictionaries:

len(dict): Returns the number of key-value pairs
all(dict): Returns True if all keys are truthy
any(dict): Returns True if any key is truthy
sum(dict): Returns the sum of all keys (if they are numeric)

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

3
print(len(d))  # 3
4
print(all(d))  # True (all keys are truthy)
5
print(any(d))  # True (at least one key is truthy)
6
print(sum(d))  # 6 (sum of keys: 1 + 2 + 3)

Why Must Dictionary Keys Be Immutable?

Dictionary keys must be immutable and hashable for several important reasons:

Hash Function: Dictionaries use a hash function to quickly locate values. The hash function generates a unique hash code for each key based on its value. If a key could change after being used, its hash would change, and the dictionary wouldn’t be able to find the value associated with that key.
Consistency: If a key could change, it would create ambiguity. For example, if a key initially maps to value A, then the key changes—should it still map to value A, or should it map to something else? The dictionary wouldn’t know how to handle this.

Exercises

Exercise 1: Create a dictionary with squared values

Create a dictionary such that the keys are from 1 to 10 and for each key x, the value is x**2. Print the dictionary.

Answer:

1
d = {}
2
for x in range(1, 11):
3
    d[x] = x ** 2
4
print(d)

Exercise 2: Merge two dictionaries

Write a program that reads the number of key-value pairs for the first dictionary, then reads each key-value pair, then reads the number of key-value pairs for the second dictionary, then reads each key-value pair, and creates a new dictionary that is the concatenation (merge) of both dictionaries. If there are duplicate keys, the values from the second dictionary should overwrite those from the first. Print the merged dictionary.

Answer:

1
n1 = int(input())
2
dict1 = {}
3
for i in range(n1):
4
    key = input()
5
    value = input()
6
    dict1[key] = value
7

8
n2 = int(input())
9
dict2 = {}
10
for i in range(n2):
11
    key = input()
12
    value = input()
13
    dict2[key] = value
14

15
merged = dict1.copy()
16
merged.update(dict2)
17
print(merged)

Exercise 3: Convert dictionary values to joined strings

Given a dictionary where values are lists of strings, write a program that converts the dictionary into a list of strings where each string is the values from each key joined together. For example, given {"a": ["A", "B"], "b": ["C", "D"]}, the output should be ["AB", "CD"].

Answer:

1
D = {"a": ["A", "B"], "b": ["C", "D"]}
2
result = []
3
for key in D:
4
    joined = "".join(D[key])
5
    result.append(joined)
6
print(result)

Exercise 4: What is the output of the following code

What is the output of the following code:

1
D = {1: 1, 2: '2', '1': 1, '2': 3}
2
D['1'] = 2
3
print(D[D[D[str(D[1])]]])

Answer:

The output is: 3

Let’s trace through step by step:

D = {1: 1, 2: '2', '1': 1, '2': 3} - Creates a dictionary with mixed key types (integer and string keys)
D['1'] = 2 - Updates the value for key '1' from 1 to 2, so D = {1: 1, 2: '2', '1': 2, '2': 3}
Now evaluating D[D[D[str(D[1])]]]:
- D[1] = 1 (gets value for integer key 1)
- str(D[1]) = str(1) = '1' (converts to string)
- D[str(D[1])] = D['1'] = 2 (gets value for string key '1')
- D[D[str(D[1])]] = D[2] = '2' (gets value for integer key 2, which is the string '2')
- D[D[D[str(D[1])]]] = D['2'] = 3 (gets value for string key '2')

So the final output is 3.

Exercise 5: What is the output of the following code

What is the output of the following code:

1
D = dict()
2
for i in range(3):
3
    for j in range(2):
4
        D[i] = j
5
print(D)

Answer:

The output is: {0: 1, 1: 1, 2: 1}

Let’s trace through the nested loops:

i = 0:
- j = 0: D[0] = 0
- j = 1: D[0] = 1 (overwrites previous value)
i = 1:
- j = 0: D[1] = 0
- j = 1: D[1] = 1 (overwrites previous value)
i = 2:
- j = 0: D[2] = 0
- j = 1: D[2] = 1 (overwrites previous value)

So the final dictionary is {0: 1, 1: 1, 2: 1}.

Exercise 6: Count frequency of characters

Write a program that reads a string and counts the frequency of each character using a dictionary. Print each character and its count on a separate line in the order they first appear.

Answer:

1
text = input()
2
freq = {}
3
for char in text:
4
    if char in freq:
5
        freq[char] += 1
6
    else:
7
        freq[char] = 1
8

9
for char in text:
10
    if freq[char] > 0:
11
        print(f"{char} {freq[char]}")
12
        freq[char] = 0

Exercise 7: Invert a dictionary

Write a program that reads a dictionary size, then reads key-value pairs, and creates a new dictionary where keys and values are swapped. If there are duplicate values in the original dictionary, the last key should be used.

Answer:

1
n = int(input())
2
d = {}
3
for i in range(n):
4
    key = input()
5
    value = input()
6
    d[key] = value
7

8
inverted = {}
9
for key, value in d.items():
10
    inverted[value] = key
11

12
print(inverted)

Exercise 8: Find keys with maximum value

Write a program that reads a dictionary size, then reads key-value pairs (where values are integers), and finds all keys that have the maximum value. Print the keys on separate lines.

Answer:

1
n = int(input())
2
d = {}
3
for i in range(n):
4
    key = input()
5
    value = int(input())
6
    d[key] = value
7

8
max_value = max(d.values())
9
for key, value in d.items():
10
    if value == max_value:
11
        print(key)

Exercise 9: Dictionary from two lists

Write a program that reads the size n, then reads n keys, then reads n values, and creates a dictionary from these two lists where the i-th key is paired with the i-th value.

Answer:

1
n = int(input())
2
keys = []
3
for i in range(n):
4
    keys.append(input())
5
values = []
6
for i in range(n):
7
    values.append(input())
8

9
d = {}
10
for i in range(n):
11
    d[keys[i]] = values[i]
12

13
print(d)

Exercise 10: Remove all keys with even values

Write a program that reads a dictionary size, then reads key-value pairs (where values are integers), and removes all keys whose values are even numbers. Print the modified dictionary.

Answer:

1
n = int(input())
2
d = {}
3
for i in range(n):
4
    key = input()
5
    value = int(input())
6
    d[key] = value
7

8
keys_to_remove = []
9
for key, value in d.items():
10
    if value % 2 == 0:
11
        keys_to_remove.append(key)
12

13
for key in keys_to_remove:
14
    del d[key]
15

16
print(d)

Table of Contents

Table of Contents

Course Progress

Exercise 1: Create a dictionary with squared values

Exercise 2: Merge two dictionaries

Exercise 3: Convert dictionary values to joined strings

Exercise 4: What is the output of the following code

Exercise 5: What is the output of the following code

Exercise 6: Count frequency of characters

Exercise 7: Invert a dictionary

Exercise 8: Find keys with maximum value

Exercise 9: Dictionary from two lists

Exercise 10: Remove all keys with even values

Course Progress