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.

Slicing — Python Patterns

Day 26 · ~12 min●

Foundations showed list[0] for one item. Today: list[a:b] for a range of items.

python

numbers = [10, 20, 30, 40, 50]
numbers[1:4]    # [20, 30, 40]

1:4 — starts at index 1, stops before index 4. Three items.

Right. The shape is [start:stop] — start is inclusive, stop is exclusive. The number of items is stop - start.

What if I omit one or both?

Defaults are sensible:

python

numbers[:3]      # [10, 20, 30]    — from start to index 3
numbers[2:]      # [30, 40, 50]    — from index 2 to end
numbers[:]       # [10, 20, 30, 40, 50]   — copy of the whole list

Negative indices work too — counting from the end:

python

numbers[-2:]     # [40, 50]        — last two
numbers[:-2]     # [10, 20, 30]    — everything except last two

And there's a third number I've seen — the step?

[start:stop:step]. Default step is 1. Step 2 takes every other item:

python

numbers[::2]     # [10, 30, 50]    — every other, from start
numbers[1::2]    # [20, 40]        — every other, starting at index 1

Negative step reverses:

python

numbers[::-1]    # [50, 40, 30, 20, 10]    — reversed copy

[::-1] is the canonical Python idiom for "reverse a list or string."

Same syntax for strings?

Same syntax — strings are sliceable too:

python

"hello"[1:4]       # 'ell'
"hello"[::-1]      # 'olleh'

Slicing — `[start:stop:step]`

python

sequence[start:stop]           # default step = 1
sequence[start:stop:step]

start — first index included (default 0)
stop — first index excluded (default len(sequence))
step — gap between indices (default 1)

Lists and strings — same rules

python

numbers = [10, 20, 30, 40, 50]
text = "hello"

numbers[1:4]     # [20, 30, 40]
text[1:4]        # 'ell'

Common shapes

python

xs[:n]           # first n items
xs[-n:]          # last n items
xs[n:]           # everything from index n onward
xs[:-n]          # everything except last n
xs[::2]          # every other item
xs[::-1]         # reversed copy
xs[:]            # full copy (useful when you need a mutable copy)

Negative step — reverse

python

"abcde"[::-1]    # 'edcba'
[1, 2, 3][::-1]  # [3, 2, 1]

More generally, step = -1 walks backwards:

python

numbers[4:1:-1]    # [50, 40, 30]    — from index 4 down to (but not including) 1

Readable? Marginally. Most code sticks to [::-1] for full reverse and uses regular slices for everything else.

Slicing never raises IndexError

A single-index lookup past the end raises:

python

[1, 2, 3][10]    # IndexError

A slice past the end is silently truncated:

python

[1, 2, 3][10:20]    # []  — no error
[1, 2, 3][:100]     # [1, 2, 3]

Useful — and a small footgun (you might miss bugs that produce empty slices).

Slicing returns a new list/string

python

original = [1, 2, 3, 4]
part = original[1:3]
part.append(99)
original           # [1, 2, 3, 4]    — unchanged

The slice is a fresh copy. Modifying it doesn't touch the original. (Strings are immutable, so this only matters for lists.)

Slice assignment — replace a chunk in place

python

xs = [1, 2, 3, 4, 5]
xs[1:4] = [99]    # replace indices 1-3 with a single item
xs                # [1, 99, 5]

Length can change. The right-hand side can be any iterable.

Common gotchas

Inclusive start, exclusive stop. xs[1:4] is items at indices 1, 2, 3 — not 4.
Slicing copies. For huge lists this is non-trivial; for everyday work it's fine.
Negative indices != negative step. xs[-1] is the last item; xs[::-1] is the whole thing reversed. Different operators, different effects.

Day 26 · ~12 min●

Foundations showed list[0] for one item. Today: list[a:b] for a range of items.

python

numbers = [10, 20, 30, 40, 50]
numbers[1:4]    # [20, 30, 40]

1:4 — starts at index 1, stops before index 4. Three items.

Right. The shape is [start:stop] — start is inclusive, stop is exclusive. The number of items is stop - start.

What if I omit one or both?

Defaults are sensible:

python

numbers[:3]      # [10, 20, 30]    — from start to index 3
numbers[2:]      # [30, 40, 50]    — from index 2 to end
numbers[:]       # [10, 20, 30, 40, 50]   — copy of the whole list

Negative indices work too — counting from the end:

python

numbers[-2:]     # [40, 50]        — last two
numbers[:-2]     # [10, 20, 30]    — everything except last two

And there's a third number I've seen — the step?

[start:stop:step]. Default step is 1. Step 2 takes every other item:

python

numbers[::2]     # [10, 30, 50]    — every other, from start
numbers[1::2]    # [20, 40]        — every other, starting at index 1

Negative step reverses:

python

numbers[::-1]    # [50, 40, 30, 20, 10]    — reversed copy

[::-1] is the canonical Python idiom for "reverse a list or string."

Same syntax for strings?

Same syntax — strings are sliceable too:

python

"hello"[1:4]       # 'ell'
"hello"[::-1]      # 'olleh'

Slicing — `[start:stop:step]`

python

sequence[start:stop]           # default step = 1
sequence[start:stop:step]

start — first index included (default 0)
stop — first index excluded (default len(sequence))
step — gap between indices (default 1)

Lists and strings — same rules

python

numbers = [10, 20, 30, 40, 50]
text = "hello"

numbers[1:4]     # [20, 30, 40]
text[1:4]        # 'ell'

Common shapes

python

xs[:n]           # first n items
xs[-n:]          # last n items
xs[n:]           # everything from index n onward
xs[:-n]          # everything except last n
xs[::2]          # every other item
xs[::-1]         # reversed copy
xs[:]            # full copy (useful when you need a mutable copy)

Negative step — reverse

python

"abcde"[::-1]    # 'edcba'
[1, 2, 3][::-1]  # [3, 2, 1]

More generally, step = -1 walks backwards:

python

numbers[4:1:-1]    # [50, 40, 30]    — from index 4 down to (but not including) 1

Readable? Marginally. Most code sticks to [::-1] for full reverse and uses regular slices for everything else.

Slicing never raises IndexError

A single-index lookup past the end raises:

python

[1, 2, 3][10]    # IndexError

A slice past the end is silently truncated:

python

[1, 2, 3][10:20]    # []  — no error
[1, 2, 3][:100]     # [1, 2, 3]

Useful — and a small footgun (you might miss bugs that produce empty slices).

Slicing returns a new list/string

python

original = [1, 2, 3, 4]
part = original[1:3]
part.append(99)
original           # [1, 2, 3, 4]    — unchanged

The slice is a fresh copy. Modifying it doesn't touch the original. (Strings are immutable, so this only matters for lists.)

Slice assignment — replace a chunk in place

python

xs = [1, 2, 3, 4, 5]
xs[1:4] = [99]    # replace indices 1-3 with a single item
xs                # [1, 99, 5]

Length can change. The right-hand side can be any iterable.

Common gotchas

Inclusive start, exclusive stop. xs[1:4] is items at indices 1, 2, 3 — not 4.
Slicing copies. For huge lists this is non-trivial; for everyday work it's fine.
Negative indices != negative step. xs[-1] is the last item; xs[::-1] is the whole thing reversed. Different operators, different effects.

Slicing — `[start:stop:step]`

Lists and strings — same rules

Common shapes

Negative step — reverse

Slicing never raises IndexError

Slicing returns a new list/string

Slice assignment — replace a chunk in place

Common gotchas

Slicing — `[start:stop:step]`

Lists and strings — same rules

Common shapes

Negative step — reverse

Slicing never raises IndexError

Slicing returns a new list/string

Slice assignment — replace a chunk in place

Common gotchas

Slicing — `[start:stop:step]`

Lists and strings — same rules

Common shapes

Negative step — reverse

Slicing never raises IndexError

Slicing returns a new list/string

Slice assignment — replace a chunk in place

Common gotchas

Sign up to practice

Slicing — `[start:stop:step]`

Lists and strings — same rules

Common shapes

Negative step — reverse

Slicing never raises IndexError

Slicing returns a new list/string

Slice assignment — replace a chunk in place

Common gotchas

Sign up to practice

Slicing — [start:stop:step]

Lists and strings — same rules

Common shapes

Negative step — reverse

Slicing never raises IndexError

Slicing returns a new list/string

Slice assignment — replace a chunk in place

Common gotchas

Slicing — [start:stop:step]

Lists and strings — same rules

Common shapes

Negative step — reverse

Slicing never raises IndexError

Slicing returns a new list/string

Slice assignment — replace a chunk in place

Common gotchas

Slicing — [start:stop:step]

Lists and strings — same rules

Common shapes

Negative step — reverse

Slicing never raises IndexError

Slicing returns a new list/string

Slice assignment — replace a chunk in place

Common gotchas

Sign up to practice

Slicing — [start:stop:step]

Lists and strings — same rules

Common shapes

Negative step — reverse

Slicing never raises IndexError

Slicing returns a new list/string

Slice assignment — replace a chunk in place

Common gotchas

Sign up to practice

Slicing — `[start:stop:step]`

Slicing — `[start:stop:step]`

Slicing — `[start:stop:step]`

Slicing — `[start:stop:step]`