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.

Default arguments — Python Patterns

Day 9 · ~11 min●

A function with two parameters where the second is usually the same value:

python

def add(a, b):
    return a + b

add(3, 5)    # caller always passes b
add(3, 5)
add(7, 5)

If b is almost always 5, can I make that the default?

Exactly the use case for default arguments. Put =value after the parameter name in the def:

python

def add(a, b=5):
    return a + b

add(3)       # 8   — b defaults to 5
add(3, 7)    # 10  — caller overrides

Are there rules about which parameters can have defaults?

One rule: defaults come after required parameters. def f(a=1, b) is illegal — Python wouldn't know whether f(5) is calling with a=5 or with b=5. Required first, then optional.

And the default value — when is it evaluated?

Once, at def time. This is famous because it bites people:

python

def append_to(item, target=[]):    # ⚠ shared mutable default
    target.append(item)
    return target

append_to(1)    # [1]
append_to(2)    # [1, 2]   — same list reused!

For today: stick to immutable defaults — numbers, strings, None, tuples. We'll come back to this trap in lesson 11.

Default arguments — the basic shape

python

def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"

greet("Ada")              # 'Hello, Ada!'
greet("Ada", "Hi")        # 'Hi, Ada!'

The default applies when the caller omits the argument. Passing None is not omission — greet("Ada", None) passes None and you get "None, Ada!".

Required first, optional after

python

def ok(a, b=1, c=2): ...           # legal
def bad(a=1, b, c=2): ...           # SyntaxError — required after default

If you find yourself wanting required-after-default, you probably want keyword-only arguments — coming up in lesson 10.

Defaults are evaluated once

The default expression runs at def time, not at each call:

python

import time
def f(t=time.time()):
    return t

f()    # always returns the time the def line ran, not the call time

This trips people up most often with mutable defaults:

python

def append_to(item, target=[]):    # ⚠
    target.append(item)
    return target

The single [] created at def time is shared across every call that omits target. The fix — use None as the sentinel and create a fresh list inside:

python

def append_to(item, target=None):
    if target is None:
        target = []
    target.append(item)
    return target

Anti-pattern — `if x:` to mean "x not given"

python

def f(x=None):
    if not x:               # ⚠ also true for 0, '', [], {} ...
        x = default()

Use if x is None: — that distinguishes "caller passed nothing" from "caller passed a falsy value."

Day 9 · ~11 min●

A function with two parameters where the second is usually the same value:

python

def add(a, b):
    return a + b

add(3, 5)    # caller always passes b
add(3, 5)
add(7, 5)

If b is almost always 5, can I make that the default?

Exactly the use case for default arguments. Put =value after the parameter name in the def:

python

def add(a, b=5):
    return a + b

add(3)       # 8   — b defaults to 5
add(3, 7)    # 10  — caller overrides

Are there rules about which parameters can have defaults?

One rule: defaults come after required parameters. def f(a=1, b) is illegal — Python wouldn't know whether f(5) is calling with a=5 or with b=5. Required first, then optional.

And the default value — when is it evaluated?

Once, at def time. This is famous because it bites people:

python

def append_to(item, target=[]):    # ⚠ shared mutable default
    target.append(item)
    return target

append_to(1)    # [1]
append_to(2)    # [1, 2]   — same list reused!

For today: stick to immutable defaults — numbers, strings, None, tuples. We'll come back to this trap in lesson 11.

Default arguments — the basic shape

python

def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"

greet("Ada")              # 'Hello, Ada!'
greet("Ada", "Hi")        # 'Hi, Ada!'

The default applies when the caller omits the argument. Passing None is not omission — greet("Ada", None) passes None and you get "None, Ada!".

Required first, optional after

python

def ok(a, b=1, c=2): ...           # legal
def bad(a=1, b, c=2): ...           # SyntaxError — required after default

If you find yourself wanting required-after-default, you probably want keyword-only arguments — coming up in lesson 10.

Defaults are evaluated once

The default expression runs at def time, not at each call:

python

import time
def f(t=time.time()):
    return t

f()    # always returns the time the def line ran, not the call time

This trips people up most often with mutable defaults:

python

def append_to(item, target=[]):    # ⚠
    target.append(item)
    return target

The single [] created at def time is shared across every call that omits target. The fix — use None as the sentinel and create a fresh list inside:

python

def append_to(item, target=None):
    if target is None:
        target = []
    target.append(item)
    return target

Anti-pattern — `if x:` to mean "x not given"

python

def f(x=None):
    if not x:               # ⚠ also true for 0, '', [], {} ...
        x = default()

Use if x is None: — that distinguishes "caller passed nothing" from "caller passed a falsy value."

Default arguments — the basic shape

Required first, optional after

Defaults are evaluated once

Anti-pattern — `if x:` to mean "x not given"

Default arguments — the basic shape

Required first, optional after

Defaults are evaluated once

Anti-pattern — `if x:` to mean "x not given"

Default arguments — the basic shape

Required first, optional after

Defaults are evaluated once

Anti-pattern — `if x:` to mean "x not given"

Sign up to practice

Default arguments — the basic shape

Required first, optional after

Defaults are evaluated once

Anti-pattern — `if x:` to mean "x not given"

Sign up to practice

Default arguments — the basic shape

Required first, optional after

Defaults are evaluated once

Anti-pattern — if x: to mean "x not given"

Default arguments — the basic shape

Required first, optional after

Defaults are evaluated once

Anti-pattern — if x: to mean "x not given"

Default arguments — the basic shape

Required first, optional after

Defaults are evaluated once

Anti-pattern — if x: to mean "x not given"

Sign up to practice

Default arguments — the basic shape

Required first, optional after

Defaults are evaluated once

Anti-pattern — if x: to mean "x not given"

Sign up to practice

Anti-pattern — `if x:` to mean "x not given"

Anti-pattern — `if x:` to mean "x not given"

Anti-pattern — `if x:` to mean "x not given"

Anti-pattern — `if x:` to mean "x not given"