How much does zuzu.codes cost?

The starter track is free — read all lessons and practice for free. Full access to every track (current and future) is $14.99/month. Cancel anytime.

How long does each track take?

Each track is designed as a 30-day challenge — one lesson per day, about 15 minutes each. Go at your own pace, but the structure is built around daily consistency.

What's the lesson format?

Each lesson is a student-teacher dialogue with code examples, followed by a hands-on code challenge in an in-browser editor. You read, you understand, then you write real code.

Do I need prior coding experience?

Our beginner track starts from absolute zero — no prior experience needed. Advanced tracks build on earlier ones, and the platform tells you exactly where to start.

How is zuzu.codes different from freeCodeCamp or Codecademy?

zuzu.codes uses a structured 30-day track format with dialogue-based teaching, an in-browser code editor, and gamification (XP, streaks, progress tracking). The format builds genuine understanding through daily practice.

Nested dicts — Python Patterns

Day 13 · ~11 min●

A dict's values can be any type — including other dicts. That gives you a two-level lookup table:

python

scores = {
    "x": {"a": 1, "b": 2},
    "y": {"a": 3, "b": 4},
}

Two top-level keys ("x", "y"); each maps to a small dict with keys "a" and "b".

And to look up an inner value?

Chain the brackets:

python

print(scores["x"]["a"])    # 1
print(scores["y"]["b"])    # 4

First bracket fetches the inner dict; second bracket fetches its value.

What about iteration — looking at every "a" across the top level?

A for over .items() gives you each top-level key and its inner dict:

python

for key, inner in scores.items():
    print(key, inner["a"])
# x 1
# y 3

And missing keys still raise KeyError?

At every level. scores["z"] raises; scores["x"]["c"] raises. With nested dicts, .get() is your friend for safe traversal — though we'll see better tools for this in week 4 (defaultdict).

Nested dicts — dicts as values

python

data = {
    "x": {"a": 1, "b": 2},
    "y": {"a": 3, "b": 4},
}

Lookup — chain brackets

python

data["x"]["a"]    # 1
data["y"]["b"]    # 4

Each [] does one lookup. The first one returns a dict; the second indexes into it.

Missing keys — `KeyError`

python

data["z"]            # KeyError: 'z'
data["x"]["c"]       # KeyError: 'c'
data["z"]["a"]       # KeyError: 'z' — fails at the first lookup

Safe traversal with `.get()`

python

data.get("x", {}).get("a")    # 1
data.get("z", {}).get("a")    # None — "z" missing, falls back to {}
data.get("x", {}).get("c")    # None — "x" exists but no "c"

The {} default at each level keeps the chain alive when something's missing.

Iteration — outer keys, inner dicts

python

for key, inner in data.items():
    print(key, inner)
# x {'a': 1, 'b': 2}
# y {'a': 3, 'b': 4}

Iteration — outer × inner

python

for outer_key, inner_dict in data.items():
    for inner_key, value in inner_dict.items():
        print(outer_key, inner_key, value)
# x a 1
# x b 2
# y a 3
# y b 4

The nested loops run every combination — outer × inner.

Modifying a nested dict

Assignment works the same way:

python

data["x"]["a"] = 99
data["x"]["new"] = 5
data["z"] = {"a": 0, "b": 0}    # add a whole inner dict

When nested dicts are the right shape

Use them when one piece of data has a natural two-key index — e.g., "per-region per-day count." If you find yourself doing three levels of lookup constantly, consider whether a flat dict with tuple keys would be cleaner: data[(region, day)] = count.

Anti-pattern — deep manual checks

python

if key in data and inner_key in data[key]:
    value = data[key][inner_key]
else:
    value = default

Works but is verbose. data.get(key, {}).get(inner_key, default) does the same in one line. (And defaultdict from week 4 makes building these even cleaner.)

Day 13 · ~11 min●

A dict's values can be any type — including other dicts. That gives you a two-level lookup table:

python

scores = {
    "x": {"a": 1, "b": 2},
    "y": {"a": 3, "b": 4},
}

Two top-level keys ("x", "y"); each maps to a small dict with keys "a" and "b".

And to look up an inner value?

Chain the brackets:

python

print(scores["x"]["a"])    # 1
print(scores["y"]["b"])    # 4

First bracket fetches the inner dict; second bracket fetches its value.

What about iteration — looking at every "a" across the top level?

A for over .items() gives you each top-level key and its inner dict:

python

for key, inner in scores.items():
    print(key, inner["a"])
# x 1
# y 3

And missing keys still raise KeyError?

At every level. scores["z"] raises; scores["x"]["c"] raises. With nested dicts, .get() is your friend for safe traversal — though we'll see better tools for this in week 4 (defaultdict).

Nested dicts — dicts as values

python

data = {
    "x": {"a": 1, "b": 2},
    "y": {"a": 3, "b": 4},
}

Lookup — chain brackets

python

data["x"]["a"]    # 1
data["y"]["b"]    # 4

Each [] does one lookup. The first one returns a dict; the second indexes into it.

Missing keys — `KeyError`

python

data["z"]            # KeyError: 'z'
data["x"]["c"]       # KeyError: 'c'
data["z"]["a"]       # KeyError: 'z' — fails at the first lookup

Safe traversal with `.get()`

python

data.get("x", {}).get("a")    # 1
data.get("z", {}).get("a")    # None — "z" missing, falls back to {}
data.get("x", {}).get("c")    # None — "x" exists but no "c"

The {} default at each level keeps the chain alive when something's missing.

Iteration — outer keys, inner dicts

python

for key, inner in data.items():
    print(key, inner)
# x {'a': 1, 'b': 2}
# y {'a': 3, 'b': 4}

Iteration — outer × inner

python

for outer_key, inner_dict in data.items():
    for inner_key, value in inner_dict.items():
        print(outer_key, inner_key, value)
# x a 1
# x b 2
# y a 3
# y b 4

The nested loops run every combination — outer × inner.

Modifying a nested dict

Assignment works the same way:

python

data["x"]["a"] = 99
data["x"]["new"] = 5
data["z"] = {"a": 0, "b": 0}    # add a whole inner dict

When nested dicts are the right shape

Anti-pattern — deep manual checks

python

if key in data and inner_key in data[key]:
    value = data[key][inner_key]
else:
    value = default

Works but is verbose. data.get(key, {}).get(inner_key, default) does the same in one line. (And defaultdict from week 4 makes building these even cleaner.)

Nested dicts — dicts as values

Lookup — chain brackets

Missing keys — `KeyError`

Safe traversal with `.get()`

Iteration — outer keys, inner dicts

Iteration — outer × inner

Modifying a nested dict

When nested dicts are the right shape

Anti-pattern — deep manual checks

Nested dicts — dicts as values

Lookup — chain brackets

Missing keys — `KeyError`

Safe traversal with `.get()`

Iteration — outer keys, inner dicts

Iteration — outer × inner

Modifying a nested dict

When nested dicts are the right shape

Anti-pattern — deep manual checks

Nested dicts — dicts as values

Lookup — chain brackets

Missing keys — `KeyError`

Safe traversal with `.get()`

Iteration — outer keys, inner dicts

Iteration — outer × inner

Modifying a nested dict

When nested dicts are the right shape

Anti-pattern — deep manual checks

Sign up to practice

Nested dicts — dicts as values

Lookup — chain brackets

Missing keys — `KeyError`

Safe traversal with `.get()`

Iteration — outer keys, inner dicts

Iteration — outer × inner

Modifying a nested dict

When nested dicts are the right shape

Anti-pattern — deep manual checks

Sign up to practice

Nested dicts — dicts as values

Lookup — chain brackets

Missing keys — KeyError

Safe traversal with .get()

Iteration — outer keys, inner dicts

Iteration — outer × inner

Modifying a nested dict

When nested dicts are the right shape

Anti-pattern — deep manual checks

Nested dicts — dicts as values

Lookup — chain brackets

Missing keys — KeyError

Safe traversal with .get()

Iteration — outer keys, inner dicts

Iteration — outer × inner

Modifying a nested dict

When nested dicts are the right shape

Anti-pattern — deep manual checks

Nested dicts — dicts as values

Lookup — chain brackets

Missing keys — KeyError

Safe traversal with .get()

Iteration — outer keys, inner dicts

Iteration — outer × inner

Modifying a nested dict

When nested dicts are the right shape

Anti-pattern — deep manual checks

Sign up to practice

Nested dicts — dicts as values

Lookup — chain brackets

Missing keys — KeyError

Safe traversal with .get()

Iteration — outer keys, inner dicts

Iteration — outer × inner

Modifying a nested dict

When nested dicts are the right shape

Anti-pattern — deep manual checks

Sign up to practice

Missing keys — `KeyError`

Safe traversal with `.get()`

Missing keys — `KeyError`

Safe traversal with `.get()`

Missing keys — `KeyError`

Safe traversal with `.get()`

Missing keys — `KeyError`

Safe traversal with `.get()`