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.

@property — Python Mastery

Day 23 · ~12 min●

Sometimes a class has an attribute that's derived from other attributes:

python

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    @property
    def area(self):
        return self.width * self.height

r = Rectangle(3, 4)
print(r.area)        # 12 — no parentheses

r.area without parens — but area is a method?

That's what @property does. It turns a method into something that looks like an attribute. When someone reads r.area, Python actually calls Rectangle.area(r) and returns the result. The caller doesn't know — and doesn't need to know — whether area is stored or computed.

Why hide it?

Two reasons. (1) Consistency. Calling code reads r.area, r.width, r.height — same syntax. The fact that one is computed and two are stored is an implementation detail. (2) Encapsulation. If you start with self.area = w * h in __init__, then later realise you need to recompute it when width changes, switching to @property lets you do that without breaking the calling code. The attribute access stays the same.

Can you assign to it?

Not by default. r.area = 99 raises AttributeError. To allow writes, you add a setter:

python

@area.setter
def area(self, value):
    # validate or compute, then assign to internals
    ...

Most properties are read-only. If you find yourself reaching for setters often, consider whether a regular method (set_area) would be clearer.

`@property` — methods that look like attributes

python

class Rectangle:
    def __init__(self, width: float, height: float):
        self.width = width
        self.height = height

    @property
    def area(self) -> float:
        return self.width * self.height

    @property
    def perimeter(self) -> float:
        return 2 * (self.width + self.height)

r = Rectangle(3, 4)
print(r.area)        # 12
print(r.perimeter)   # 14

What changes

Without `@property`	With `@property`
`r.area()` (call syntax)	`r.area` (attribute syntax)
Caller knows it's computed	Caller doesn't have to know
Migrating to/from stored is breaking	Migrate freely — call site doesn't change

Read-only by default

python

r = Rectangle(3, 4)
r.area = 99    # AttributeError: can't set attribute

Good — derived values usually shouldn't be set directly. If you want to allow it, add a setter:

Adding a setter

python

class Celsius:
    def __init__(self, value: float):
        self._value = value

    @property
    def value(self) -> float:
        return self._value

    @value.setter
    def value(self, v: float):
        if v < -273.15:
            raise ValueError("below absolute zero")
        self._value = v

c = Celsius(20)
print(c.value)        # 20
c.value = 30          # uses the setter — validates first

The _value (leading underscore) is a Python convention for "this is internal — don't access from outside." The public .value property mediates access.

When to use `@property`

Yes:

The value is cheap to compute (basic arithmetic, attribute lookups)
The value is conceptually a property of the object (area, full_name, is_active)
You want to add validation on assignment without changing calling code

No:

Computing the value is expensive (database call, network request) — make it a method compute_x() so the cost is visible
The value has side effects when read — methods are clearer
The class is a @dataclass and you just want a stored field — leave it as a regular field

Related: `@functools.cached_property`

For a property that's expensive but immutable for the lifetime of the instance:

python

from functools import cached_property

class Document:
    def __init__(self, text: str):
        self.text = text

    @cached_property
    def word_count(self) -> int:
        # computed once, then cached on the instance
        return len(self.text.split())

First access computes; subsequent accesses return the cached value.

Day 23 · ~12 min●

Sometimes a class has an attribute that's derived from other attributes:

python

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    @property
    def area(self):
        return self.width * self.height

r = Rectangle(3, 4)
print(r.area)        # 12 — no parentheses

r.area without parens — but area is a method?

Why hide it?

Can you assign to it?

Not by default. r.area = 99 raises AttributeError. To allow writes, you add a setter:

python

@area.setter
def area(self, value):
    # validate or compute, then assign to internals
    ...

Most properties are read-only. If you find yourself reaching for setters often, consider whether a regular method (set_area) would be clearer.

`@property` — methods that look like attributes

python

class Rectangle:
    def __init__(self, width: float, height: float):
        self.width = width
        self.height = height

    @property
    def area(self) -> float:
        return self.width * self.height

    @property
    def perimeter(self) -> float:
        return 2 * (self.width + self.height)

r = Rectangle(3, 4)
print(r.area)        # 12
print(r.perimeter)   # 14

What changes

Without `@property`	With `@property`
`r.area()` (call syntax)	`r.area` (attribute syntax)
Caller knows it's computed	Caller doesn't have to know
Migrating to/from stored is breaking	Migrate freely — call site doesn't change

Read-only by default

python

r = Rectangle(3, 4)
r.area = 99    # AttributeError: can't set attribute

Good — derived values usually shouldn't be set directly. If you want to allow it, add a setter:

Adding a setter

python

class Celsius:
    def __init__(self, value: float):
        self._value = value

    @property
    def value(self) -> float:
        return self._value

    @value.setter
    def value(self, v: float):
        if v < -273.15:
            raise ValueError("below absolute zero")
        self._value = v

c = Celsius(20)
print(c.value)        # 20
c.value = 30          # uses the setter — validates first

The _value (leading underscore) is a Python convention for "this is internal — don't access from outside." The public .value property mediates access.

When to use `@property`

Yes:

The value is cheap to compute (basic arithmetic, attribute lookups)
The value is conceptually a property of the object (area, full_name, is_active)
You want to add validation on assignment without changing calling code

No:

Computing the value is expensive (database call, network request) — make it a method compute_x() so the cost is visible
The value has side effects when read — methods are clearer
The class is a @dataclass and you just want a stored field — leave it as a regular field

Related: `@functools.cached_property`

For a property that's expensive but immutable for the lifetime of the instance:

python

from functools import cached_property

class Document:
    def __init__(self, text: str):
        self.text = text

    @cached_property
    def word_count(self) -> int:
        # computed once, then cached on the instance
        return len(self.text.split())

First access computes; subsequent accesses return the cached value.

`@property` — methods that look like attributes

What changes

Read-only by default

Adding a setter

When to use `@property`

Related: `@functools.cached_property`

`@property` — methods that look like attributes

What changes

Read-only by default

Adding a setter

When to use `@property`

Related: `@functools.cached_property`

`@property` — methods that look like attributes

What changes

Read-only by default

Adding a setter

When to use `@property`

Related: `@functools.cached_property`

Sign up to practice

`@property` — methods that look like attributes

What changes

Read-only by default

Adding a setter

When to use `@property`

Related: `@functools.cached_property`

Sign up to practice

@property — methods that look like attributes

What changes

Read-only by default

Adding a setter

When to use @property

Related: @functools.cached_property

@property — methods that look like attributes

What changes

Read-only by default

Adding a setter

When to use @property

Related: @functools.cached_property

@property — methods that look like attributes

What changes

Read-only by default

Adding a setter

When to use @property

Related: @functools.cached_property

Sign up to practice

@property — methods that look like attributes

What changes

Read-only by default

Adding a setter

When to use @property

Related: @functools.cached_property

Sign up to practice

`@property` — methods that look like attributes

When to use `@property`

Related: `@functools.cached_property`

`@property` — methods that look like attributes

When to use `@property`

Related: `@functools.cached_property`

`@property` — methods that look like attributes

When to use `@property`

Related: `@functools.cached_property`

`@property` — methods that look like attributes

When to use `@property`

Related: `@functools.cached_property`