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 basics — Python Patterns

Day 5 · ~11 min●

Foundations introduced try / except in week 4. We're going deeper. The two-line shape:

python

try:
    risky()
except SomeError:
    handle()

If risky() raises SomeError, control jumps to the except block. If it doesn't raise, the except block is skipped.

And if it raises a different error — not SomeError?

That error propagates as if no try/except was there. The except is type-specific.

Why match a specific type? Why not catch everything?

Three reasons:

Bare except: swallows Ctrl-C. KeyboardInterrupt is an exception too — bare except catches it. Now you can't stop the script.
Bare except: hides bugs. A typo in a variable name raises NameError. If you catch everything, you mask the real problem.
Specific types document intent. except FileNotFoundError: tells the reader "I expected the file might not exist and I handled it." except: tells them nothing.

So today we open a file that probably doesn't exist and handle the failure gracefully?

Exactly that. open("nonexistent.txt") raises FileNotFoundError. We catch it, print "missing", move on.

`try` / `except` — the whole shape

python

try:
    body()                # might raise
except SpecificError:
    handle_it()           # only runs if SpecificError fired

Flow:

Python runs body().
If it returns normally — the except is skipped, execution continues after the whole block.
If it raises and the type matches SpecificError — handle_it() runs, then execution continues after the whole block.
If it raises with a different type — the exception propagates up, past this try/except, until something else catches it (or your script crashes).

`as` to capture the error

python

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

The as e binds the exception object to a name so you can inspect or log it. Useful for debug output.

Anti-patterns

python

# Bad — bare except
try:
    do_thing()
except:                 # catches EVERYTHING including KeyboardInterrupt
    pass

# Bad — except Exception with empty body
try:
    do_thing()
except Exception:
    pass                # silently swallows all real errors

# Better — name what you expect
try:
    do_thing()
except FileNotFoundError:
    print("file not found, using defaults")

When NOT to wrap in try/except

Bugs. If your function shouldn't raise in normal use, let it crash so you find the bug. Don't paper over it.
Predictable cases. if key in d: is clearer than try: d[key] except KeyError: for cases where the absence is expected.

When to wrap in try/except

External world failures. File I/O, network, parsing user/API input.
Expected partial failures. "Some of these inputs might be malformed; skip those, keep processing."

Today's exercise

Open a file that doesn't exist. FileNotFoundError fires. Catch it, print "missing", move on. The script doesn't crash.

Day 5 · ~11 min●

Foundations introduced try / except in week 4. We're going deeper. The two-line shape:

python

try:
    risky()
except SomeError:
    handle()

If risky() raises SomeError, control jumps to the except block. If it doesn't raise, the except block is skipped.

And if it raises a different error — not SomeError?

That error propagates as if no try/except was there. The except is type-specific.

Why match a specific type? Why not catch everything?

Three reasons:

Bare except: swallows Ctrl-C. KeyboardInterrupt is an exception too — bare except catches it. Now you can't stop the script.
Bare except: hides bugs. A typo in a variable name raises NameError. If you catch everything, you mask the real problem.
Specific types document intent. except FileNotFoundError: tells the reader "I expected the file might not exist and I handled it." except: tells them nothing.

So today we open a file that probably doesn't exist and handle the failure gracefully?

Exactly that. open("nonexistent.txt") raises FileNotFoundError. We catch it, print "missing", move on.

`try` / `except` — the whole shape

python

try:
    body()                # might raise
except SpecificError:
    handle_it()           # only runs if SpecificError fired

Flow:

Python runs body().
If it returns normally — the except is skipped, execution continues after the whole block.
If it raises and the type matches SpecificError — handle_it() runs, then execution continues after the whole block.
If it raises with a different type — the exception propagates up, past this try/except, until something else catches it (or your script crashes).

`as` to capture the error

python

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

The as e binds the exception object to a name so you can inspect or log it. Useful for debug output.

Anti-patterns

python

# Bad — bare except
try:
    do_thing()
except:                 # catches EVERYTHING including KeyboardInterrupt
    pass

# Bad — except Exception with empty body
try:
    do_thing()
except Exception:
    pass                # silently swallows all real errors

# Better — name what you expect
try:
    do_thing()
except FileNotFoundError:
    print("file not found, using defaults")

When NOT to wrap in try/except

Bugs. If your function shouldn't raise in normal use, let it crash so you find the bug. Don't paper over it.
Predictable cases. if key in d: is clearer than try: d[key] except KeyError: for cases where the absence is expected.

When to wrap in try/except

External world failures. File I/O, network, parsing user/API input.
Expected partial failures. "Some of these inputs might be malformed; skip those, keep processing."

Today's exercise

Open a file that doesn't exist. FileNotFoundError fires. Catch it, print "missing", move on. The script doesn't crash.

`try` / `except` — the whole shape

`as` to capture the error

Anti-patterns

When NOT to wrap in try/except

When to wrap in try/except

Today's exercise

`try` / `except` — the whole shape

`as` to capture the error

Anti-patterns

When NOT to wrap in try/except

When to wrap in try/except

Today's exercise

`try` / `except` — the whole shape

`as` to capture the error

Anti-patterns

When NOT to wrap in try/except

When to wrap in try/except

Today's exercise

Sign up to practice

`try` / `except` — the whole shape

`as` to capture the error

Anti-patterns

When NOT to wrap in try/except

When to wrap in try/except

Today's exercise

Sign up to practice

try / except — the whole shape

as to capture the error

Anti-patterns

When NOT to wrap in try/except

When to wrap in try/except

Today's exercise

try / except — the whole shape

as to capture the error

Anti-patterns

When NOT to wrap in try/except

When to wrap in try/except

Today's exercise

try / except — the whole shape

as to capture the error

Anti-patterns

When NOT to wrap in try/except

When to wrap in try/except

Today's exercise

Sign up to practice

try / except — the whole shape

as to capture the error

Anti-patterns

When NOT to wrap in try/except

When to wrap in try/except

Today's exercise

Sign up to practice

`try` / `except` — the whole shape

`as` to capture the error

`try` / `except` — the whole shape

`as` to capture the error

`try` / `except` — the whole shape

`as` to capture the error

`try` / `except` — the whole shape

`as` to capture the error