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.

try / except — Python Foundations

Day 27 · ~11 min●

What happens when this runs?

python

pairs = [(10, 2), (8, 0), (15, 3)]
for a, b in pairs:
    print(a / b)

First iteration prints 5.0. Second one — divide by zero — crashes the whole script. Third one never runs.

Right. Python raises a ZeroDivisionError and stops. To keep going, you wrap the risky line in try and tell Python what to do except when it fails:

python

for a, b in pairs:
    try:
        print(a / b)
    except ZeroDivisionError:
        print("undefined")

Now you get 5.0, undefined, 5.0. The script survives the bad case.

When should I use try/except?

When the error is something you can handle — a known shape (file missing, network down, key not in dict) where the right move is to log and continue, or fall back to a default. Don't wrap try/except around bugs — bugs should crash so you find them. Wrap it around expected failure modes: external systems flake, user input is wrong, data has gaps.

`try` / `except` — survive expected failures

python

try:
    risky_thing()
except SomeError:
    handle_it()

If risky_thing() raises SomeError, control jumps to the except block. If no error, the except block is skipped.

Catching a specific error

python

try:
    x = 10 / 0
except ZeroDivisionError:
    print("can't divide by zero")

Common error types

Error	When
`ZeroDivisionError`	`a / 0`
`KeyError`	`d["missing"]` on a dict
`IndexError`	`lst[100]` past the end
`ValueError`	`int("hello")` — wrong shape input
`TypeError`	`"a" + 1` — wrong types
`FileNotFoundError`	`open("missing.txt")`

Catching the error value

python

try:
    int("hello")
except ValueError as e:
    print("failed to parse:", e)
# failed to parse: invalid literal for int() with base 10: 'hello'

The as e binds the error to a name so you can print or log it.

Catching multiple types

python

try:
    do_thing()
except (ValueError, TypeError):
    print("bad input")

Or with separate handlers:

python

try:
    do_thing()
except ValueError:
    print("bad value")
except TypeError:
    print("bad type")

Anti-pattern — bare `except`

python

try:
    do_thing()
except:    # ← catches EVERYTHING — even Ctrl-C
    pass

Bare except swallows all errors silently. You'll never see real bugs. Always name the error type. If you genuinely need to catch any non-system exception, use except Exception: — at least it leaves Ctrl-C alone.

When NOT to use try/except

Conditionally check first. if key in d: ... else: ... is clearer than try: d[key] except KeyError: ... for predictable cases.
Don't hide bugs. If a function shouldn't raise an error in normal operation, don't wrap it. Let the error surface so you can fix it.

When to use it

External world: file I/O, network, parsing user input, parsing API responses
Expected partial failures: "some of these might fail; keep processing the rest"
Cleanup: try / except / finally to always close a file or release a lock (later)

Day 27 · ~11 min●

What happens when this runs?

python

pairs = [(10, 2), (8, 0), (15, 3)]
for a, b in pairs:
    print(a / b)

First iteration prints 5.0. Second one — divide by zero — crashes the whole script. Third one never runs.

Right. Python raises a ZeroDivisionError and stops. To keep going, you wrap the risky line in try and tell Python what to do except when it fails:

python

for a, b in pairs:
    try:
        print(a / b)
    except ZeroDivisionError:
        print("undefined")

Now you get 5.0, undefined, 5.0. The script survives the bad case.

When should I use try/except?

`try` / `except` — survive expected failures

python

try:
    risky_thing()
except SomeError:
    handle_it()

If risky_thing() raises SomeError, control jumps to the except block. If no error, the except block is skipped.

Catching a specific error

python

try:
    x = 10 / 0
except ZeroDivisionError:
    print("can't divide by zero")

Common error types

Error	When
`ZeroDivisionError`	`a / 0`
`KeyError`	`d["missing"]` on a dict
`IndexError`	`lst[100]` past the end
`ValueError`	`int("hello")` — wrong shape input
`TypeError`	`"a" + 1` — wrong types
`FileNotFoundError`	`open("missing.txt")`

Catching the error value

python

try:
    int("hello")
except ValueError as e:
    print("failed to parse:", e)
# failed to parse: invalid literal for int() with base 10: 'hello'

The as e binds the error to a name so you can print or log it.

Catching multiple types

python

try:
    do_thing()
except (ValueError, TypeError):
    print("bad input")

Or with separate handlers:

python

try:
    do_thing()
except ValueError:
    print("bad value")
except TypeError:
    print("bad type")

Anti-pattern — bare `except`

python

try:
    do_thing()
except:    # ← catches EVERYTHING — even Ctrl-C
    pass

When NOT to use try/except

Conditionally check first. if key in d: ... else: ... is clearer than try: d[key] except KeyError: ... for predictable cases.
Don't hide bugs. If a function shouldn't raise an error in normal operation, don't wrap it. Let the error surface so you can fix it.

When to use it

External world: file I/O, network, parsing user input, parsing API responses
Expected partial failures: "some of these might fail; keep processing the rest"
Cleanup: try / except / finally to always close a file or release a lock (later)

`try` / `except` — survive expected failures

Catching a specific error

Common error types

Catching the error value

Catching multiple types

Anti-pattern — bare `except`

When NOT to use try/except

When to use it

`try` / `except` — survive expected failures

Catching a specific error

Common error types

Catching the error value

Catching multiple types

Anti-pattern — bare `except`

When NOT to use try/except

When to use it

`try` / `except` — survive expected failures

Catching a specific error

Common error types

Catching the error value

Catching multiple types

Anti-pattern — bare `except`

When NOT to use try/except

When to use it

Sign up to practice

`try` / `except` — survive expected failures

Catching a specific error

Common error types

Catching the error value

Catching multiple types

Anti-pattern — bare `except`

When NOT to use try/except

When to use it

Sign up to practice

try / except — survive expected failures

Catching a specific error

Common error types

Catching the error value

Catching multiple types

Anti-pattern — bare except

When NOT to use try/except

When to use it

try / except — survive expected failures

Catching a specific error

Common error types

Catching the error value

Catching multiple types

Anti-pattern — bare except

When NOT to use try/except

When to use it

try / except — survive expected failures

Catching a specific error

Common error types

Catching the error value

Catching multiple types

Anti-pattern — bare except

When NOT to use try/except

When to use it

Sign up to practice

try / except — survive expected failures

Catching a specific error

Common error types

Catching the error value

Catching multiple types

Anti-pattern — bare except

When NOT to use try/except

When to use it

Sign up to practice

`try` / `except` — survive expected failures

Anti-pattern — bare `except`

`try` / `except` — survive expected failures

Anti-pattern — bare `except`

`try` / `except` — survive expected failures

Anti-pattern — bare `except`

`try` / `except` — survive expected failures

Anti-pattern — bare `except`