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.

**dict unpacking — Python Patterns

Day 24 · ~12 min●

Lesson 10 introduced **kwargs on the def side — collect extras into a dict. The same ** works the call side too — spread a dict into keyword arguments:

python

def greet(name, age):
    print(f"{name} is {age}")

person = {"name": "Ada", "age": 36}
greet(**person)    # equivalent to greet(name="Ada", age=36)

The dict's keys must match the function's parameter names. The values become the arguments.

Right. If a key doesn't match a parameter name, you get TypeError: got an unexpected keyword argument. If a parameter is missing, you get TypeError: missing required argument.

Beyond function calls — does ** work elsewhere?

Yes — for merging dicts:

python

defaults = {"timeout": 30, "retries": 3}
overrides = {"timeout": 60}

merged = {**defaults, **overrides}
# {'timeout': 60, 'retries': 3}

Left-to-right, later keys win. Useful for config patterns: "start with defaults, override with what the caller passed."

And forwarding — passing my own kwargs to another function?

That's the most common use. A wrapper takes **kwargs and forwards them on:

python

def log_then_call(target, **kwargs):
    print("calling with:", kwargs)
    return target(**kwargs)

Whatever keyword arguments the caller passes flow through to target. The wrapper doesn't need to know what they are.

`**dict` at the call site — spread into keyword arguments

python

def connect(host, port, timeout):
    ...

opts = {"host": "db.local", "port": 5432, "timeout": 30}
connect(**opts)
# Same as: connect(host="db.local", port=5432, timeout=30)

The dict keys become parameter names; the dict values become argument values.

Mix `**dict` with other arguments

python

connect("db.local", **{"port": 5432, "timeout": 30})
connect(host="db.local", **{"port": 5432, "timeout": 30})

A **dict can sit alongside positional and explicit keyword arguments — but it can't conflict. connect(host="x", **{"host": "y"}) is a TypeError because both specify host.

Argument forwarding — the wrapper pattern

python

def logged(fn):
    def wrapper(*args, **kwargs):
        print("called:", fn.__name__, args, kwargs)
        return fn(*args, **kwargs)
    return wrapper

The wrapper doesn't know or care what fn expects. It collects everything with *args, **kwargs and passes it on with the spread operators.

`**dict` in a dict literal — merge

Since Python 3.5+ you can spread dicts into dict construction:

python

a = {"x": 1, "y": 2}
b = {"y": 99, "z": 3}

merged = {**a, **b}
# {'x': 1, 'y': 99, 'z': 3}    — later keys win

Reads left-to-right. The keys from b overwrite same-named keys from a.

Newer alternative: `|` operator (Python 3.9+)

python

merged = a | b
# {'x': 1, 'y': 99, 'z': 3}

Same result, cleaner syntax. Both are common; ** is more universal because it also handles function calls.

Common patterns

Default settings + overrides

python

defaults = {"verbose": False, "timeout": 30}
user_settings = {"timeout": 60}
final = {**defaults, **user_settings}    # {'verbose': False, 'timeout': 60}

Forwarding to a constructor

python

row = {"name": "Ada", "age": 36, "city": "London"}
person = make_person(**row)
# Same as: make_person(name="Ada", age=36, city="London")

This lets you use a dict as a record and unpack it into a function in one line.

Adding one extra key

python

base = {"a": 1, "b": 2}
plus_c = {**base, "c": 3}
# {'a': 1, 'b': 2, 'c': 3}    — base unchanged

A non-mutating way to extend a dict.

`*` and `**` summary

Form	Direction	Container	Where it goes
`def f(*args)`	def-side	tuple	extra positionals
`def f(**kwargs)`	def-side	dict	extra keywords
`f(*lst)`	call-side	list/tuple	spread into positionals
`f(**dct)`	call-side	dict	spread into keywords
`[a, b]`	literal	list	merge two lists
`{a, b}`	literal	dict	merge two dicts

Same symbols, mirrored use.

Day 24 · ~12 min●

Lesson 10 introduced **kwargs on the def side — collect extras into a dict. The same ** works the call side too — spread a dict into keyword arguments:

python

def greet(name, age):
    print(f"{name} is {age}")

person = {"name": "Ada", "age": 36}
greet(**person)    # equivalent to greet(name="Ada", age=36)

The dict's keys must match the function's parameter names. The values become the arguments.

Right. If a key doesn't match a parameter name, you get TypeError: got an unexpected keyword argument. If a parameter is missing, you get TypeError: missing required argument.

Beyond function calls — does ** work elsewhere?

Yes — for merging dicts:

python

defaults = {"timeout": 30, "retries": 3}
overrides = {"timeout": 60}

merged = {**defaults, **overrides}
# {'timeout': 60, 'retries': 3}

Left-to-right, later keys win. Useful for config patterns: "start with defaults, override with what the caller passed."

And forwarding — passing my own kwargs to another function?

That's the most common use. A wrapper takes **kwargs and forwards them on:

python

def log_then_call(target, **kwargs):
    print("calling with:", kwargs)
    return target(**kwargs)

Whatever keyword arguments the caller passes flow through to target. The wrapper doesn't need to know what they are.

`**dict` at the call site — spread into keyword arguments

python

def connect(host, port, timeout):
    ...

opts = {"host": "db.local", "port": 5432, "timeout": 30}
connect(**opts)
# Same as: connect(host="db.local", port=5432, timeout=30)

The dict keys become parameter names; the dict values become argument values.

Mix `**dict` with other arguments

python

connect("db.local", **{"port": 5432, "timeout": 30})
connect(host="db.local", **{"port": 5432, "timeout": 30})

A **dict can sit alongside positional and explicit keyword arguments — but it can't conflict. connect(host="x", **{"host": "y"}) is a TypeError because both specify host.

Argument forwarding — the wrapper pattern

python

def logged(fn):
    def wrapper(*args, **kwargs):
        print("called:", fn.__name__, args, kwargs)
        return fn(*args, **kwargs)
    return wrapper

The wrapper doesn't know or care what fn expects. It collects everything with *args, **kwargs and passes it on with the spread operators.

`**dict` in a dict literal — merge

Since Python 3.5+ you can spread dicts into dict construction:

python

a = {"x": 1, "y": 2}
b = {"y": 99, "z": 3}

merged = {**a, **b}
# {'x': 1, 'y': 99, 'z': 3}    — later keys win

Reads left-to-right. The keys from b overwrite same-named keys from a.

Newer alternative: `|` operator (Python 3.9+)

python

merged = a | b
# {'x': 1, 'y': 99, 'z': 3}

Same result, cleaner syntax. Both are common; ** is more universal because it also handles function calls.

Common patterns

Default settings + overrides

python

defaults = {"verbose": False, "timeout": 30}
user_settings = {"timeout": 60}
final = {**defaults, **user_settings}    # {'verbose': False, 'timeout': 60}

Forwarding to a constructor

python

row = {"name": "Ada", "age": 36, "city": "London"}
person = make_person(**row)
# Same as: make_person(name="Ada", age=36, city="London")

This lets you use a dict as a record and unpack it into a function in one line.

Adding one extra key

python

base = {"a": 1, "b": 2}
plus_c = {**base, "c": 3}
# {'a': 1, 'b': 2, 'c': 3}    — base unchanged

A non-mutating way to extend a dict.

`*` and `**` summary

Form	Direction	Container	Where it goes
`def f(*args)`	def-side	tuple	extra positionals
`def f(**kwargs)`	def-side	dict	extra keywords
`f(*lst)`	call-side	list/tuple	spread into positionals
`f(**dct)`	call-side	dict	spread into keywords
`[a, b]`	literal	list	merge two lists
`{a, b}`	literal	dict	merge two dicts

Same symbols, mirrored use.

**dict at the call site — spread into keyword arguments

Mix **dict with other arguments

Argument forwarding — the wrapper pattern

**dict in a dict literal — merge

Newer alternative: | operator (Python 3.9+)

Common patterns

Default settings + overrides

Forwarding to a constructor

Adding one extra key

* and ** summary

**dict at the call site — spread into keyword arguments

Mix **dict with other arguments

Argument forwarding — the wrapper pattern

**dict in a dict literal — merge

Newer alternative: | operator (Python 3.9+)

Common patterns

Default settings + overrides

Forwarding to a constructor

Adding one extra key

* and ** summary

**dict at the call site — spread into keyword arguments

Mix **dict with other arguments

Argument forwarding — the wrapper pattern

**dict in a dict literal — merge

Newer alternative: | operator (Python 3.9+)

Common patterns

Default settings + overrides

Forwarding to a constructor

Adding one extra key

* and ** summary

Sign up to practice

**dict at the call site — spread into keyword arguments

Mix **dict with other arguments

Argument forwarding — the wrapper pattern

**dict in a dict literal — merge

Newer alternative: | operator (Python 3.9+)

Common patterns

Default settings + overrides

Forwarding to a constructor

Adding one extra key

* and ** summary

Sign up to practice

`**dict` at the call site — spread into keyword arguments

Mix `**dict` with other arguments

`**dict` in a dict literal — merge

Newer alternative: `|` operator (Python 3.9+)

`*` and `**` summary

`**dict` at the call site — spread into keyword arguments

Mix `**dict` with other arguments

`**dict` in a dict literal — merge

Newer alternative: `|` operator (Python 3.9+)

`*` and `**` summary

`**dict` at the call site — spread into keyword arguments

Mix `**dict` with other arguments

`**dict` in a dict literal — merge

Newer alternative: `|` operator (Python 3.9+)

`*` and `**` summary

`**dict` at the call site — spread into keyword arguments

Mix `**dict` with other arguments

`**dict` in a dict literal — merge

Newer alternative: `|` operator (Python 3.9+)

`*` and `**` summary