MEPX
Get started
Chapters
Python114 chapters

Basics

  1. Introduction
  2. Get Started
  3. Syntax
  4. Comments
  5. Variables
  6. Variable Names
  7. Multiple Assignment
  8. Global Variables
  9. Data Types
  10. Numbers
  11. Casting
  12. Booleans
  13. Operators
  14. User Input

Strings

  1. Strings
  2. Slicing
  3. Modify Strings
  4. Concatenation
  5. f-Strings
  6. String Formatting
  7. Escape Characters
  8. String Methods
  9. Text and Unicode

Collections

  1. Lists
  2. List Access
  3. Change Items
  4. Add Items
  5. Remove Items
  6. Loop Lists
  7. List Comprehension
  8. Sort Lists
  9. Copy Lists
  10. Join Lists
  11. List Methods
  12. Tuples
  13. Sets
  14. Dictionaries
  15. Nested Dictionaries
  16. Dictionary Methods
  17. Set Methods
  18. Dict and Set Comprehensions
  19. The collections Module

Control flow

  1. If...Else
  2. Match
  3. While Loops
  4. For Loops
  5. Break and Continue

Functions

  1. Functions
  2. Arguments
  3. args and kwargs
  4. Default Values
  5. Return Values
  6. Scope
  7. Recursion
  8. Lambda
  9. Decorators
  10. Generators
  11. Closures

Classes and objects

  1. Classes and Objects
  2. The __init__ Method
  3. The __str__ Method
  4. Methods
  5. self
  6. Inheritance
  7. Polymorphism
  8. Iterators
  9. Dataclasses
  10. Enums
  11. Magic Methods

Modules and the standard library

  1. Modules
  2. PIP
  3. Dates
  4. Math
  5. JSON
  6. RegEx
  7. itertools
  8. os and sys
  9. Random Numbers

Files and errors

  1. File Handling
  2. Read Files
  3. Write Files
  4. Delete Files
  5. Try...Except
  6. Raising Exceptions
  7. CSV Files
  8. Context Managers
  9. Paths with pathlib

Beyond the basics

  1. Virtual Environments
  2. Type Hints
  3. Async Basics
  4. NumPy Intro
  5. Pandas Intro
  6. Matplotlib Intro
  7. Working with APIs
  8. Testing
  9. Logging
  10. Command-line Arguments
  11. Debugging
  12. SQLite
  13. Packaging

Machine learning

  1. What Machine Learning Is
  2. Your First Model
  3. Features and Labels
  4. Train and Test Split
  5. Classification
  6. Regression
  7. Evaluating a Model
  8. Overfitting and Underfitting
  9. Preprocessing
  10. Pipelines
  11. Clustering
  12. Neural Networks
  13. Saving and Using a Model
  14. Where It Goes Wrong

CollectionsChapter 38 of 114

Nested Dictionaries

Dictionaries inside dictionaries, and how to read them without crashing.

Back: DictionariesNext: Dictionary Methods

Structure inside structure

A value can be another dictionary, or a list, to any depth. This is the shape JSON arrives in, so you will meet it constantly:

Python
people = {
    "ada": {"born": 1815, "fields": ["maths", "computing"]},
    "grace": {"born": 1906, "fields": ["computing"]},
}

print(people["ada"]["born"])
print(people["ada"]["fields"][0])

Output

1815
maths

Reading safely, one level at a time

Chained [] fails at whichever level is missing, and the KeyError only names that level:

Python
people = {"ada": {"born": 1815}}
try:
    print(people["alan"]["born"])
except KeyError as problem:
    print("KeyError:", problem)

Output

KeyError: 'alan'

Chaining get() is safe but reads badly past two levels:

Python
people = {"ada": {"born": 1815}}
print(people.get("alan", {}).get("born"))
print(people.get("ada", {}).get("born"))

Output

None
1815

The {} default is what makes the second get() legal — without it you would be calling get() on None.

A small helper is clearer when the path is long:

Python
def dig(data, *keys, default=None):
    for key in keys:
        if not isinstance(data, dict) or key not in data:
            return default
        data = data[key]
    return data

people = {"ada": {"address": {"city": "London"}}}
print(dig(people, "ada", "address", "city"))
print(dig(people, "alan", "address", "city", default="unknown"))

Output

London
unknown

Building nested structures

Assigning into a level that does not exist yet fails:

Python
groups = {}
try:
    groups["maths"]["ada"] = True
except KeyError as problem:
    print("KeyError:", problem)

Output

KeyError: 'maths'

setdefault() creates the level if it is missing and returns it either way:

Python
groups = {}
groups.setdefault("maths", []).append("ada")
groups.setdefault("maths", []).append("grace")
groups.setdefault("computing", []).append("katherine")
print(groups)

Output

{'maths': ['ada', 'grace'], 'computing': ['katherine']}

defaultdict does the same with less repetition when every value has the same shape:

Python
from collections import defaultdict

groups = defaultdict(list)
groups["maths"].append("ada")
groups["maths"].append("grace")
print(dict(groups))

Output

{'maths': ['ada', 'grace']}
Python
from collections import defaultdict

groups = defaultdict(list)
print(groups["physics"])
print(dict(groups))

Output

[]
{'physics': []}

Walking a nested structure

Python
people = {
    "ada": {"born": 1815, "fields": ["maths"]},
    "grace": {"born": 1906, "fields": ["computing", "navy"]},
}

for name, details in people.items():
    fields = ", ".join(details["fields"])
    print(f"{name}: born {details['born']}, {fields}")

Output

ada: born 1815, maths
grace: born 1906, computing, navy

Copying is shallow here too

Python
from copy import deepcopy

original = {"ada": {"fields": ["maths"]}}
shallow = original.copy()
deep = deepcopy(original)

shallow["ada"]["fields"].append("computing")
print(original["ada"]["fields"])
print(deep["ada"]["fields"])

Output

['maths', 'computing']
['maths']

The shallow copy shares the inner dictionary. Only deepcopy gives you a structure you can change without touching the original.

Test yourself

2 questions

Why does people.get("alan", {}).get("born") not crash?

Show the answer

The {} default means the second get() is called on a dictionary — Without the default the first get() returns None, and None has no get().

What does reading a missing key on a defaultdict do?

Show the answer

Creates the entry with a default value — Merely reading adds the key. Use 'in' to check without creating it.

Exercises for this chapter
Next chapter

Dictionary Methods

The full set of dict methods, and which ones change the dictionary.

Back: DictionariesNext: Dictionary Methods
Back: DictionariesNext: Dictionary Methods