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.

enumerate and zip — Python Patterns

Day 25 · ~12 min●

A common shape — iterate a list, but you also want to know the index:

python

names = ["Ada", "Bob", "Cleo"]

# Manual index — works, but ugly
i = 0
for name in names:
    print(i, name)
    i += 1

I've written that pattern. There must be a better way.

enumerate. Wraps any iterable and yields (index, item) pairs:

python

for i, name in enumerate(names):
    print(i, name)
# 0 Ada
# 1 Bob
# 2 Cleo

The second argument to enumerate is the starting index — useful when humans want 1-based numbering:

python

for i, name in enumerate(names, 1):
    print(f"{i}. {name}")
# 1. Ada
# 2. Bob
# 3. Cleo

And iterating two lists at once?

zip. Takes two (or more) iterables and yields tuples of corresponding items:

python

names = ["Ada", "Bob", "Cleo"]
ages = [36, 41, 28]

for name, age in zip(names, ages):
    print(name, age)
# Ada 36
# Bob 41
# Cleo 28

What if the two lists are different lengths?

zip stops at the shortest. The longer iterable's tail is silently dropped. If you want to fail loudly, use zip(names, ages, strict=True) (Python 3.10+) — that raises ValueError on mismatch.

Anti-patterns to avoid?

Two:

for i in range(len(xs)). Use enumerate instead — same effect, fewer pieces.
for i in range(len(xs)): print(xs[i], ys[i]). Use zip instead — clearer intent.

If you find yourself writing range(len(...)), ask whether enumerate or zip does the same thing more directly.

`enumerate(iterable, start=0)` — index + item pairs

python

for i, item in enumerate(["a", "b", "c"]):
    print(i, item)
# 0 a
# 1 b
# 2 c

`start` parameter

python

for i, item in enumerate(["a", "b", "c"], start=1):
    print(i, item)
# 1 a
# 2 b
# 3 c

Use start=1 for human-facing line numbering.

Anti-pattern

python

# Don't write this
for i in range(len(xs)):
    process(i, xs[i])

# Write this
for i, x in enumerate(xs):
    process(i, x)

`zip(*iterables)` — pair items in parallel

python

for n, a in zip(["Ada", "Bob"], [36, 41]):
    print(n, a)
# Ada 36
# Bob 41

Three or more iterables

python

for a, b, c in zip(xs, ys, zs):
    ...

No limit on how many iterables you pass.

Stops at shortest

python

list(zip([1, 2, 3], ["a", "b"]))    # [(1, 'a'), (2, 'b')]

The trailing 3 is dropped silently.

`strict=True` (Python 3.10+)

python

list(zip([1, 2, 3], ["a", "b"], strict=True))
# ValueError: zip() argument 2 is shorter than argument 1

Use when matching lengths is a precondition you want to enforce.

Build a dict from two parallel lists

python

keys = ["a", "b", "c"]
values = [1, 2, 3]

dict(zip(keys, values))    # {'a': 1, 'b': 2, 'c': 3}

Combine `enumerate` and `zip`

python

for i, (name, age) in enumerate(zip(names, ages), 1):
    print(f"{i}. {name} ({age})")

The inner zip produces (name, age) pairs; enumerate adds the index. Note the parens around (name, age) — you're unpacking one item that happens to be a tuple.

Anti-patterns recap

Bad	Good
`for i in range(len(xs)): ... xs[i]`	`for i, x in enumerate(xs)`
`for i in range(len(xs)): ... xs[i], ys[i]`	`for x, y in zip(xs, ys)`
Manual `i = 0; for ...; i += 1`	`for i, x in enumerate(xs)`

Any time you reach for an index only because you need to look up another list — zip is your tool.

Day 25 · ~12 min●

A common shape — iterate a list, but you also want to know the index:

python

names = ["Ada", "Bob", "Cleo"]

# Manual index — works, but ugly
i = 0
for name in names:
    print(i, name)
    i += 1

I've written that pattern. There must be a better way.

enumerate. Wraps any iterable and yields (index, item) pairs:

python

for i, name in enumerate(names):
    print(i, name)
# 0 Ada
# 1 Bob
# 2 Cleo

The second argument to enumerate is the starting index — useful when humans want 1-based numbering:

python

for i, name in enumerate(names, 1):
    print(f"{i}. {name}")
# 1. Ada
# 2. Bob
# 3. Cleo

And iterating two lists at once?

zip. Takes two (or more) iterables and yields tuples of corresponding items:

python

names = ["Ada", "Bob", "Cleo"]
ages = [36, 41, 28]

for name, age in zip(names, ages):
    print(name, age)
# Ada 36
# Bob 41
# Cleo 28

What if the two lists are different lengths?

zip stops at the shortest. The longer iterable's tail is silently dropped. If you want to fail loudly, use zip(names, ages, strict=True) (Python 3.10+) — that raises ValueError on mismatch.

Anti-patterns to avoid?

Two:

for i in range(len(xs)). Use enumerate instead — same effect, fewer pieces.
for i in range(len(xs)): print(xs[i], ys[i]). Use zip instead — clearer intent.

If you find yourself writing range(len(...)), ask whether enumerate or zip does the same thing more directly.

`enumerate(iterable, start=0)` — index + item pairs

python

for i, item in enumerate(["a", "b", "c"]):
    print(i, item)
# 0 a
# 1 b
# 2 c

`start` parameter

python

for i, item in enumerate(["a", "b", "c"], start=1):
    print(i, item)
# 1 a
# 2 b
# 3 c

Use start=1 for human-facing line numbering.

Anti-pattern

python

# Don't write this
for i in range(len(xs)):
    process(i, xs[i])

# Write this
for i, x in enumerate(xs):
    process(i, x)

`zip(*iterables)` — pair items in parallel

python

for n, a in zip(["Ada", "Bob"], [36, 41]):
    print(n, a)
# Ada 36
# Bob 41

Three or more iterables

python

for a, b, c in zip(xs, ys, zs):
    ...

No limit on how many iterables you pass.

Stops at shortest

python

list(zip([1, 2, 3], ["a", "b"]))    # [(1, 'a'), (2, 'b')]

The trailing 3 is dropped silently.

`strict=True` (Python 3.10+)

python

list(zip([1, 2, 3], ["a", "b"], strict=True))
# ValueError: zip() argument 2 is shorter than argument 1

Use when matching lengths is a precondition you want to enforce.

Build a dict from two parallel lists

python

keys = ["a", "b", "c"]
values = [1, 2, 3]

dict(zip(keys, values))    # {'a': 1, 'b': 2, 'c': 3}

Combine `enumerate` and `zip`

python

for i, (name, age) in enumerate(zip(names, ages), 1):
    print(f"{i}. {name} ({age})")

The inner zip produces (name, age) pairs; enumerate adds the index. Note the parens around (name, age) — you're unpacking one item that happens to be a tuple.

Anti-patterns recap

Bad	Good
`for i in range(len(xs)): ... xs[i]`	`for i, x in enumerate(xs)`
`for i in range(len(xs)): ... xs[i], ys[i]`	`for x, y in zip(xs, ys)`
Manual `i = 0; for ...; i += 1`	`for i, x in enumerate(xs)`

Any time you reach for an index only because you need to look up another list — zip is your tool.

enumerate(iterable, start=0) — index + item pairs

start parameter

Anti-pattern

zip(*iterables) — pair items in parallel

Three or more iterables

Stops at shortest

strict=True (Python 3.10+)

Build a dict from two parallel lists

Combine enumerate and zip

Anti-patterns recap

enumerate(iterable, start=0) — index + item pairs

start parameter

Anti-pattern

zip(*iterables) — pair items in parallel

Three or more iterables

Stops at shortest

strict=True (Python 3.10+)

Build a dict from two parallel lists

Combine enumerate and zip

Anti-patterns recap

enumerate(iterable, start=0) — index + item pairs

start parameter

Anti-pattern

zip(*iterables) — pair items in parallel

Three or more iterables

Stops at shortest

strict=True (Python 3.10+)

Build a dict from two parallel lists

Combine enumerate and zip

Anti-patterns recap

Sign up to practice

enumerate(iterable, start=0) — index + item pairs

start parameter

Anti-pattern

zip(*iterables) — pair items in parallel

Three or more iterables

Stops at shortest

strict=True (Python 3.10+)

Build a dict from two parallel lists

Combine enumerate and zip

Anti-patterns recap

Sign up to practice

`enumerate(iterable, start=0)` — index + item pairs

`start` parameter

`zip(*iterables)` — pair items in parallel

`strict=True` (Python 3.10+)

Combine `enumerate` and `zip`

`enumerate(iterable, start=0)` — index + item pairs

`start` parameter

`zip(*iterables)` — pair items in parallel

`strict=True` (Python 3.10+)

Combine `enumerate` and `zip`

`enumerate(iterable, start=0)` — index + item pairs

`start` parameter

`zip(*iterables)` — pair items in parallel

`strict=True` (Python 3.10+)

Combine `enumerate` and `zip`

`enumerate(iterable, start=0)` — index + item pairs

`start` parameter

`zip(*iterables)` — pair items in parallel

`strict=True` (Python 3.10+)

Combine `enumerate` and `zip`