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.

@dataclass — Python Mastery

Day 5 · ~12 min●

Look at yesterday's Item:

python

class Item:
    def __init__(self, name, value):
        self.name = name
        self.value = value

Four lines just to say "Item has name and value." The standard library has a shorter version:

python

from dataclasses import dataclass

@dataclass
class Item:
    name: str
    value: int

a = Item("a", 5)
print(a.name, a.value)

No __init__ at all? Where did it go?

@dataclass writes it for you. The decorator (we cover decorators in week 2) reads the type-hinted fields and synthesises __init__(self, name, value) — same body as you'd have written. It also writes a __repr__ (so print(a) shows Item(name='a', value=5) instead of <Item object at 0x...>) and an __eq__ (so two items with the same fields compare equal).

What about methods I want to add?

Same as before — def is_high(self): inside the class body. @dataclass only generates the boilerplate; you still write the behaviour.

When would I write a hand-written class instead of @dataclass?

When the constructor needs significant logic — validating arguments, computing derived fields, raising on bad input. @dataclass gives you the no-logic version. For the 80% of cases that is the no-logic version, @dataclass is the right default.

`@dataclass` — boilerplate-free classes

python

from dataclasses import dataclass

@dataclass
class Item:
    name: str
    value: int

That's it. The decorator reads the type-annotated fields and generates:

__init__(self, name: str, value: int) — assigns the args to attributes
__repr__ — Item(name='a', value=5) instead of <Item object at 0x...>
__eq__ — Item("a", 5) == Item("a", 5) is True

Compare

python

# Hand-written
class Item:
    def __init__(self, name, value):
        self.name = name
        self.value = value

    def __repr__(self):
        return f"Item(name={self.name!r}, value={self.value!r})"

    def __eq__(self, other):
        if not isinstance(other, Item):
            return NotImplemented
        return self.name == other.name and self.value == other.value

# @dataclass
@dataclass
class Item:
    name: str
    value: int

Same behaviour. Three lines vs. eleven.

Defaults

python

@dataclass
class Item:
    name: str
    value: int = 0    # default

Item("a") works — value defaults to 0. Same rules as function default arguments: defaults must come after non-defaults.

Methods still go in the body

python

@dataclass
class Item:
    name: str
    value: int

    def is_high(self) -> bool:
        return self.value > 10

a = Item("a", 5)
print(a.is_high())    # False

`repr` for free is a real win

python

a = Item("a", 5)
print(a)               # Item(name='a', value=5)
print([a, Item("b", 12)])    # [Item(name='a', value=5), Item(name='b', value=12)]

Debugging is much nicer when print actually shows the data instead of <...>.

When NOT to use `@dataclass`

Constructor needs logic (validate inputs, derive fields, raise on bad data) — write __init__ by hand
The class needs to inherit from a non-dataclass base in a complex way
You want immutability — use @dataclass(frozen=True)

For 80% of the "named bag of fields" cases, @dataclass is the right default.

Day 5 · ~12 min●

Look at yesterday's Item:

python

class Item:
    def __init__(self, name, value):
        self.name = name
        self.value = value

Four lines just to say "Item has name and value." The standard library has a shorter version:

python

from dataclasses import dataclass

@dataclass
class Item:
    name: str
    value: int

a = Item("a", 5)
print(a.name, a.value)

No __init__ at all? Where did it go?

What about methods I want to add?

Same as before — def is_high(self): inside the class body. @dataclass only generates the boilerplate; you still write the behaviour.

When would I write a hand-written class instead of @dataclass?

`@dataclass` — boilerplate-free classes

python

from dataclasses import dataclass

@dataclass
class Item:
    name: str
    value: int

That's it. The decorator reads the type-annotated fields and generates:

__init__(self, name: str, value: int) — assigns the args to attributes
__repr__ — Item(name='a', value=5) instead of <Item object at 0x...>
__eq__ — Item("a", 5) == Item("a", 5) is True

Compare

python

# Hand-written
class Item:
    def __init__(self, name, value):
        self.name = name
        self.value = value

    def __repr__(self):
        return f"Item(name={self.name!r}, value={self.value!r})"

    def __eq__(self, other):
        if not isinstance(other, Item):
            return NotImplemented
        return self.name == other.name and self.value == other.value

# @dataclass
@dataclass
class Item:
    name: str
    value: int

Same behaviour. Three lines vs. eleven.

Defaults

python

@dataclass
class Item:
    name: str
    value: int = 0    # default

Item("a") works — value defaults to 0. Same rules as function default arguments: defaults must come after non-defaults.

Methods still go in the body

python

@dataclass
class Item:
    name: str
    value: int

    def is_high(self) -> bool:
        return self.value > 10

a = Item("a", 5)
print(a.is_high())    # False

`repr` for free is a real win

python

a = Item("a", 5)
print(a)               # Item(name='a', value=5)
print([a, Item("b", 12)])    # [Item(name='a', value=5), Item(name='b', value=12)]

Debugging is much nicer when print actually shows the data instead of <...>.

When NOT to use `@dataclass`

Constructor needs logic (validate inputs, derive fields, raise on bad data) — write __init__ by hand
The class needs to inherit from a non-dataclass base in a complex way
You want immutability — use @dataclass(frozen=True)

For 80% of the "named bag of fields" cases, @dataclass is the right default.

`@dataclass` — boilerplate-free classes

Compare

Defaults

Methods still go in the body

`repr` for free is a real win

When NOT to use `@dataclass`

`@dataclass` — boilerplate-free classes

Compare

Defaults

Methods still go in the body

`repr` for free is a real win

When NOT to use `@dataclass`

`@dataclass` — boilerplate-free classes

Compare

Defaults

Methods still go in the body

`repr` for free is a real win

When NOT to use `@dataclass`

Sign up to practice

`@dataclass` — boilerplate-free classes

Compare

Defaults

Methods still go in the body

`repr` for free is a real win

When NOT to use `@dataclass`

Sign up to practice

@dataclass — boilerplate-free classes

Compare

Defaults

Methods still go in the body

__repr__ for free is a real win

When NOT to use @dataclass

@dataclass — boilerplate-free classes

Compare

Defaults

Methods still go in the body

__repr__ for free is a real win

When NOT to use @dataclass

@dataclass — boilerplate-free classes

Compare

Defaults

Methods still go in the body

__repr__ for free is a real win

When NOT to use @dataclass

Sign up to practice

@dataclass — boilerplate-free classes

Compare

Defaults

Methods still go in the body

__repr__ for free is a real win

When NOT to use @dataclass

Sign up to practice

`@dataclass` — boilerplate-free classes

`repr` for free is a real win

When NOT to use `@dataclass`

`@dataclass` — boilerplate-free classes

`repr` for free is a real win

When NOT to use `@dataclass`

`@dataclass` — boilerplate-free classes

`repr` for free is a real win

When NOT to use `@dataclass`

`@dataclass` — boilerplate-free classes

`repr` for free is a real win

When NOT to use `@dataclass`