Dictionaries in Python (dict): Creating, Methods, Looping, Sorting and frozendict

A dictionary in Python (dict) is a collection of key–value pairs in which a value is found by its key almost instantly, no matter how many records there are. If you need to total expenses by category, store settings or quickly look up a user by id, you use a dictionary. Below is everything you need to work with a Python dict: creating it, methods, looping, sorting, merging and the novelty of 3.15 — frozendict.

What a dictionary is in Python

A dictionary stores pairs where the key is unique: if you write a value under an existing key, the old one is replaced. Internally it is a hash table, so searching, adding and deleting by key work in constant time on average, not by scanning.

A key must be a hashable object: a string, a number, a tuple of immutable values. A list cannot be a key — you will get TypeError: unhashable type: 'list'. Values, however, can be anything, including other dictionaries and lists.

Since Python 3.7 a dictionary is guaranteed to remember insertion order: when you iterate over it, you get the keys in the order they were added.

How to create a dictionary

There are several ways to create a dictionary, and all of them appear in real code.

spent = {"Food": 1200, "Taxi": 450}       # a literal
empty = {}                                 # an empty dictionary
also_empty = dict()                        # the same, via the dict function
user = dict(name="Anna", age=30)           # keyword arguments
pairs = dict([("a", 1), ("b", 2)])         # from a list of pairs
keys = dict.fromkeys(["x", "y"], 0)        # {'x': 0, 'y': 0}

Note that empty curly braces {} create an empty dictionary, not a set. An empty set is made only with set().

A convenient way to build a dictionary from two lists is zip:

names = ["Food", "Taxi", "Cinema"]
sums = [1200, 450, 600]
spent = dict(zip(names, sums))
print(spent)   # {'Food': 1200, 'Taxi': 450, 'Cinema': 600}

Access by key: d[k] and get

A value is read with square brackets. If the key is missing, Python raises KeyError. To avoid the error, use the get method: it returns None or a default value.

spent = {"Food": 1200}
print(spent["Food"])            # 1200
print(spent.get("Cinema"))      # None
print(spent.get("Cinema", 0))   # 0
spent["Cinema"]                 # KeyError: 'Cinema'

To check whether a key exists, use the in operator: "Food" in spent returns True. It checks keys, not values. For values write 1200 in spent.values().

Adding, changing and deleting

Adding or updating an entry is a single assignment line. For counting, the combination with get is very convenient:

spent = {}
for category, amount in [("Food", 250), ("Taxi", 300), ("Food", 400)]:
    spent[category] = spent.get(category, 0) + amount
print(spent)   # {'Food': 650, 'Taxi': 300}

You can delete a key with del d[k] (it raises KeyError if the key is missing) or with d.pop(k, default), which also returns the value. To empty a dictionary completely, use d.clear(). The length of a dictionary, that is the number of pairs, is len(d).

Dictionary methods: a cheat sheet

setdefault: filling a dictionary with lists

The setdefault method helps when the values are lists and you need to group items:

groups = {}
for item, cat in [("coffee", "Food"), ("metro", "Transport"), ("pizza", "Food")]:
    groups.setdefault(cat, []).append(item)
print(groups)   # {'Food': ['coffee', 'pizza'], 'Transport': ['metro']}

update: updating a dictionary

update changes a dictionary in place: new keys are added, matching keys are overwritten.

cfg = {"debug": False, "lang": "en"}
cfg.update({"debug": True, "theme": "dark"})
print(cfg)   # {'debug': True, 'lang': 'en', 'theme': 'dark'}

defaultdict: a dictionary with default values

collections.defaultdict is a subclass of dict that, when a missing key is accessed, creates the value itself using a factory. Counting and grouping code becomes shorter.

from collections import defaultdict

spent = defaultdict(int)
for cat, amount in [("Food", 250), ("Taxi", 300), ("Food", 400)]:
    spent[cat] += amount
print(dict(spent))   # {'Food': 650, 'Taxi': 300}

groups = defaultdict(list)
groups["Food"].append("coffee")

For simple counting of occurrences there is also collections.Counter: Counter(["a", "b", "a"]) gives Counter({'a': 2, 'b': 1}).

Iterating over a dictionary: the for loop

A for loop over a dictionary goes over the keys by default. To get the key and the value together, iterate over items() — this is the most common variant.

spent = {"Food": 650, "Taxi": 300}

for cat in spent:                    # keys
    print(cat)

for amount in spent.values():        # values
    print(amount)

for cat, amount in spent.items():    # pairs
    print(f"{cat}: {amount}")

You cannot change the size of a dictionary during iteration — you will get RuntimeError: dictionary changed size during iteration. If you need to delete some keys, iterate over a copy: for k in list(d):.

Printing a dictionary

print(d) prints the dictionary on one line. For a large or nested dictionary, the pprint module or json.dumps(d, ensure_ascii=False, indent=2) is more convenient — it prints the data with indentation, and non-Latin characters without escaping.

Sorting a dictionary

A dictionary itself is not sorted in place: it has no sort method. Sorting a dictionary means creating a new dictionary from the sorted pairs using sorted.

spent = {"Taxi": 300, "Food": 650, "Cinema": 120}

by_key = dict(sorted(spent.items()))
print(by_key)    # {'Cinema': 120, 'Food': 650, 'Taxi': 300}

by_value = dict(sorted(spent.items(), key=lambda p: p[1], reverse=True))
print(by_value)  # {'Food': 650, 'Taxi': 300, 'Cinema': 120}

If you only need the top N categories, do not convert the result back into a dictionary: sorted(spent.items(), key=lambda p: p[1], reverse=True)[:2] returns a list of pairs.

To sort a list of dictionaries by a field, use: sorted(users, key=lambda u: u["age"]).

Merging and combining dictionaries

Since Python 3.9, dictionaries are merged with the | operator, and |= updates a dictionary in place. When keys clash, the right operand wins.

a = {"x": 1, "y": 2}
b = {"y": 20, "z": 3}
print(a | b)          # {'x': 1, 'y': 20, 'z': 3}
print({**a, **b})     # the same via unpacking
a |= b                # the same as a.update(b)

Note that a + b does not work for dictionaries: it raises TypeError. If you really want to add the values for identical keys, use Counter: Counter(a) + Counter(b).

Unpacking a dictionary

Two asterisks ** unpack a dictionary into named arguments of a function or into another dictionary:

def greet(name, city):
    return f"{name} from {city}"

data = {"name": "Anna", "city": "Kazan"}
print(greet(**data))   # Anna from Kazan

Dictionary comprehension

A dictionary comprehension builds a dictionary in one line from any sequence:

squares = {n: n * n for n in range(5)}
print(squares)   # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

big = {k: v for k, v in spent.items() if v > 200}

inverted = {v: k for k, v in {"a": 1, "b": 2}.items()}
print(inverted)  # {1: 'a', 2: 'b'}

The last example shows how to invert a dictionary by swapping keys and values. It works if the values are unique and hashable; otherwise some pairs will be lost.

Nested dictionaries

A value can be another dictionary — this is how you describe structures such as JSON responses from APIs, or a dictionary of user dictionaries.

users = {
    101: {"name": "Anna", "skills": ["python", "sql"]},
    102: {"name": "Oleg", "skills": ["go"]},
}
print(users[101]["skills"][0])            # python
print(users.get(103, {}).get("name"))     # None, without KeyError

Copying a dictionary: a copy and a second name

The statement b = a does not copy a dictionary: it attaches a second name to the same object. Change it through b and you will see the change in a. The same happens when a dictionary is passed to a function: the function gets a reference to the shared object and can quietly spoil it.

import copy

a = {"limits": [0, 500]}
b = a.copy()              # shallow copy
b["limits"].append(1000)  # the nested list is shared!
print(a)                  # {'limits': [0, 500, 1000]}

c = copy.deepcopy(a)      # a fully independent copy

Comparing dictionaries

The == operator compares dictionaries by content: they are equal if all pairs match. The order of keys is not taken into account: {"a": 1, "b": 2} == {"b": 2, "a": 1} gives True. To find common keys, use set operations on the views: a.keys() & b.keys().

Typed dictionaries: annotations

A dictionary annotation is written as dict[str, int]. If a dictionary has a fixed set of fields of different types, the TypedDict class from the typing module is convenient:

from typing import TypedDict

class User(TypedDict):
    name: str
    age: int

u: User = {"name": "Anna", "age": 30}

Annotations are not checked at run time; they are read by IDEs and analysers such as mypy.

An immutable dictionary: frozendict in Python 3.15

Python 3.15 introduced the built-in type frozendict (PEP 814): no import is needed, and an attempt to change it immediately ends with a TypeError. Previously an immutable dictionary had to be imitated with a wrapper from the types module or with a third-party package. This is exactly what is needed for shared settings that no function should quietly change.

config = frozendict(min_amount=0, max_amount=500)
config["max_amount"] = 1000
# TypeError: 'frozendict' object does not support item assignment

strict = config | {"max_amount": 300}   # a new frozendict, the original is intact
cache = {config: "report for May"}      # hashable — works as a key

What to know, according to the course materials:

• frozendict inherits from object, not from dict, so isinstance(cfg, dict) returns False. To check for "any dictionary", use collections.abc.Mapping or isinstance(x, (dict, frozendict)).
• It is hashable only if its keys and values are hashable: frozendict(a=[1]) can be created, but hash() will fail. The immutability is shallow, like that of a tuple.
• The order is kept, but == does not take it into account.
• json.dumps, pickle and copy understand frozendict.

Common mistakes

• KeyError when reading — use get or an in check.
• A list as a key — convert it to a tuple: d[tuple(lst)].
• Changing a dictionary inside a loop — iterate over list(d).
• Expecting a copy from an assignment — use copy() or deepcopy.
• {} instead of an empty set — it is an empty dictionary.

Summary

The Python dict is the language's main data structure: fast lookup by key, preserved insertion order, convenient methods get, setdefault, update, iteration through items(), sorting through sorted and merging with the | operator. Remember about copying and hashable keys, and for settings in Python 3.15 use frozendict. Dictionaries, lists, tuples and sets are practised hands-on in our course "Python 3.15: from beginner to pro", using an expense tracker as the example.