Python: Dictionaries

Python Dictionaries

python
dictionaries
The file system is organized into a hierarchical structure, starting with the root directory
Author

Isaac Boixaderas

Published

Sunday, June 1, 2025

Modified

Sunday, November 16, 2025

1 Overview

📘 Dictionaries in Python

Python dictionaries are mutable, ordered, and built-in data structures that store data as key-value pairs. Each key in a dictionary is unique and immutable, meaning it can be of types such as strings, numbers, or tuples, but not mutable types like lists. Values associated with keys can be of any data type and duplicates are allowed. Dictionaries are mutable, so their contents can be changed after creation by adding, updating, or removing key-value pairs.

Dictionaries are unordered in versions before Python 3.7, but from Python 3.7 onward, they maintain insertion order. Internally, dictionaries use a hash table to provide efficient operations such as lookup, insertion, and deletion with average constant time complexity. Keys must be hashable to enable this hashing mechanism. The structure is typically defined using curly braces where each key is separated from its value by a colon, and pairs are separated by commas.

Dictionaries can be created using literals with curly braces, the dict() constructor, or comprehensions. They are versatile for associating data where keys serve as unique identifiers for their values, facilitating fast data retrieval and modification.

2 Dictionaries

2.1 Without dictionaries (option 1)

  • Suppose you want to store student names with their grades.
  • One option is to have two parallel lists:
students = ["Alice", "Bob", "Charlie"]
grades = [85, 92, 78]

# To find Bob's grade:
index = students.index("Bob")

print(grades[index])
92

2.2 Problems

  • You need two lists in sync → easy to mess up if one changes.
  • Finding Bob’s grade requires searching (.index()), which is O(n).
  • Readability suffers — you always have to remember which list matches what.
  • Imagine storing more fields: email, surname, address…

2.3 Without dictionaries (option 2)

  • Another option is to group students in sublists:
records = [
    ["Alice", 85],
    ["Bob", 92],
    ["Charlie", 78],
]

# To find Bob's grade:
for record in records:
    if record[0] == "Bob":
        print(record[1])
92

2.4 Problems

  • All sublists must follow the same order: [name, grade].
  • Finding Bob’s grade requires searching in O(n) again.
  • Still not very readable — you have to remember record[0] is the name.
  • Imagine storing more fields: email, surname, address…

3 Dictionaries

  • Dictionaries (abbreviated as dicts) are mutable collection of key-value pairs.
my_dict = {'key1': 1, 'key2': 2, 'key3': 3}

print(my_dict)
{‘key1’: 1, ‘key2’: 2, ‘key3’: 3}

  • Get value of specific key:

    print(my_dict['key1'])
    1
  • Now the student grades’ code is more clear and efficient (O(1) on average):
grades = {
    'Alice': 85,
    'Bob': 92,
    'Charlie': 78
}

# To find Bob's grade:
print(grades['Bob'])
92
  • With more fields we could do something like a dict of dicts:
students = {
    'ID1': {
        'name': 'Alice',
        'surname': 'Smith',
        'email': 'alice.smith@...'
        'grade': 85,
    },
    'ID2': {
        'name': 'Bob',
        'surname': 'Carpenter',
        'email': 'bob.carpenter@...'
        'grade': 92,
    },
}

# To get Bob's grade:
print(grades['ID2']['grade'])
92

4 Consider

  • Keys have to be unique and of an immutable type (e.g., int, string, tuple).
  • Values can have any type.
  • Creating a dictionary with a mutable key type gives error.
print({[1, 2]: 1})
TypeError: unhashable type: ‘list’
  • With tuples it works just fine.
print({(1, 2): 1})
{(1, 2): 1}
  • Values are overlapped if keys are the same, keeping the last one:
print({'key1': 1, 'key1': 2, 'key3': 3})
{‘key1’: 2, ‘key3’: 3}
  • Use keys for accessing, updating and creating dict values:
my_dict = {'key1': 1, 'key2': 2, 'key3': 3}

# Access 'key3' value
print(my_dict['key3'])
3 
my_dict = {'key1': 1, 'key2': 2, 'key3': 3}

# Update 'key3' value
my_dict['key3'] = 5
print(my_dict)
{‘key1’: 1, ‘key2’: 2, ‘key3’: 5} 
my_dict = {'key1': 1, 'key2': 2, 'key3': 3}

# Create a new key-value pair
my_dict['key4'] = 4
print(my_dict)
{‘key1’: 1, ‘key2’: 2, ‘key3’: 3, ‘key4’: 4}
  • If the key does not exist, it crashes:
my_dict = {'key1': 1, 'key2': 2, 'key3': 3}

print(my_dict['12345'])
KeyError: ‘12345’

5 Multiple types

my_dict = {1001: 'hola', True: 2.6, (3, 1, 2): [1, 2, 3]}

print(my_dict[True])
print(my_dict[1001])
print(my_dict[(3, 1, 2)])
2.6
‘hola’
[1, 2, 3] 
## Comparison
- Dicts are equal if they have the same key-value pairs, even if “unordered”.
```python
print({'key1': 1, 'key2': 2} == {'key2': 2, 'key1': 1})
True 
print({'key1': 1, 'key2': 2} == {'key1': 1, 'key2': 55})
False 
print({'key1': 1, 'key2': 2, 'key3': 3} == {'key1': 1, 'key2': 2})
False 

---

## Functions

- Common built-in functions: `len()`.

```python
my_dict = {'key1': 1, 'key2': 2, 'key3': 3}

print(len(my_dict))
3

6 Methods

Dictionary methods: https://www.w3schools.com/python/python_ref_dictionary.asp

  • keys(): Returns a view object displaying a list of all the keys in the dictionary.
# Keys

my_dict = {'key1': 1, 'key2': 2, 'key3': 3}

# Gives the keys in a special view object
print(my_dict.keys())

# Convert to list for manipulating the keys
print(list(my_dict.keys()))
dict_keys([‘key1’, ‘key2’, ‘key3’])
[‘key1’, ‘key2’, ‘key3’]
  • values(): Returns a view object displaying a list of all the values in the dictionary.
# Values

my_dict = {'key1': 1, 'key2': 2, 'key3': 3}

# Gives the values in a spetial view object
print(my_dict.values())

# Convert to list for manipulating the values
print(list(my_dict.values()))
dict_values([1, 2, 3])
[1, 2, 3]
  • items(): Returns a view object displaying a list of the dictionary’s key-value pairs as tuples.
# Items

my_dict = {'key1': 1, 'key2': 2, 'key3': 3}

# Gives the key-value pairs as tuples in a special view object
print(my_dict.items())

# Convert to list for manipulating the elements
print(list(my_dict.items()))
dict_items([(‘key1’, 1), (‘key2’, 2), (‘key3’, 3)])
[(‘key1’, 1), (‘key2’, 2), (‘key3’, 3)]
  • As dictionaries are mutable, changing one of the them affects the other:
my_dict = {'key1': 1, 'key2': 2, 'key3': 3}
second_dict = my_dict

# Both my_dict and second_dict refer to the same object
my_dict['key1'] = 5

# As my_dict has changed, so has second_dict
print(second_dict)
{‘key1’: 5, ‘key2’: 2, ‘key3’: 3}
  • copy(): This method returns a shallow copy of the dictionary.
my_dict = {'key1': 1, 'key2': 2, 'key3': 3}
# second_dict is a copy of my_dict, but they refer to different objects
second_dict = my_dict.copy()

my_dict['key1'] = 5
# Even if my_dict changes, second_dict remains the same
print(second_dict)
{‘key1’: 1, ‘key2’: 2, ‘key3’: 3}
  • Update a dictionary with another dictionary with .update()
  • In case they have equal keys, the keys of the dict given in the update are used.
my_dict = {'key1': 1, 'key2': 2, 'key3': 3}
second_dict = {'key3': 10, 'key4': 4}

my_dict.update(second_dict)
print(my_dict)
{‘key1’: 1, ‘key2’: 2, ‘key3’: 10, ‘key4’: 4}
  • Accessing a non-existen key with indexing gives an error.
  • Avoid this error with .get(), as it returns None by default.
  • Optionally, a default value can be specified if the key does not exist.
my_dict = {'key1': 1, 'key2': 2, 'key3': 3}

print(my_dict.get('key1'))  # Returns value of 'key1'
print(my_dict.get('key4'))  # Returns None because 'key4' doesn't exist
print(my_dict.get('key4', 0))  # Returns 0 because 'key4' doesn't exist
1
None
0

7 in

  • The in keword can be used to verify if a key is found in a dictionary.
my_dict = {'key1': 1, 'key2': 2, 'key3': 3}

print('key2' in my_dict)
print('abcd' in my_dict)
True
False

8 Iteration

  • Typically iterate through tuples of (key, value) pairs with .items():
my_dict = {'key1': 1, 'key2': 2, 'key3': 3}

for key, value in my_dict.items():
    print(f'The key is {key} and the value is {value}.')
The key is key1 and the value is 1.
The key is key2 and the value is 2.
The key is key3 and the value is 3.
  • Or keys only:
my_dict = {'key1': 1, 'key2': 2, 'key3': 3}

for key in my_dict.keys():
    print(f'The key is {key} and the value is {my_dict[key]}.')
The key is key1 and the value is 1.
The key is key2 and the value is 2.
The key is key3 and the value is 3.
  • Or values only:
my_dict = {'key1': 1, 'key2': 2, 'key3': 3}

for value in my_dict.values():
    print(f'The value is {value}.')
The value is 1.
The value is 2.
The value is 3.

9 Comprehension

  • Similar to lists, tuples and sets:
even_dict = {i: i * 2 for i in range(5)}
print(even_dict)
{0: 0, 1: 2, 2: 4, 3: 6, 4: 8}

10 Empty

  • By default, an empty {} in Python is an empty dictionary, not an empty set!
print(type({}))
[‘dict’]
  • If we want to create an empty set:
a = set()

11 Example

Given a string, create a dictionary with the frequency of each word in the string.

text = "one two three four three two one and one"

# Create empty dictionary for word frequency
word_frequency = {}

# Split text into words and iterate over each word
for word in text.split(' '):
    # Add word to dictionary if it doesn't exist with a
    # default value of 0, otherwise increment count
    word_frequency[word] = word_frequency.get(word, 0) + 1

print(word_frequency)
{‘one’: 3, ‘two’: 2, ‘three’: 2, ‘four’: 1, ‘and’: 1}
Back to top