beginnerintermediateadvanced

Python · Properties

Properties

Reading and writing an attribute-style value that actually runs a method underneath

@propertyobj.name, no parentheses — a method read like an attribute
@name.settermakes obj.name = value run real code, most often validation
@name.deleterdefines what del obj.name does — often a reset, not a true removal
Computed propertiesderived from other attributes on every read — cannot go stale

1.@property

@property turns a method into something read like a plain attribute — obj.value instead of obj.value(). The method still runs every time the attribute is read, so it can compute, validate, or look something up on the fly.

Key features

@property goes directly above a method that takes only self
Callers read it as obj.name, with no parentheses — it looks like a plain attribute
The method runs fresh on every read — nothing is cached automatically
Converting a plain attribute to a property later does not break existing callers
A property with no setter is read-only — assigning to it raises AttributeError

Plain attribute vs. @property, from the caller's side

Plain attribute vs. @property, from the caller's side
Caller writes	What actually happens
obj.name (plain attribute)	reads a stored value directly, no code runs
obj.name (with @property)	calls a method behind the scenes, returns its result
obj.name = x (no setter defined)	AttributeError — read-only property
obj.name()	wrong — a property is read without parentheses

Reading a property runs a method, but looks like an attribute

obj.area

no parentheses, looks like an attribute

@property method runs

computes the value fresh, every read

returns a plain value

caller never sees the method call

Command

python

class Name:
    @property
    def value(self):
        return self._value      # computed, validated, or looked up

@property makes a method readable as obj.name, no parentheses — it reruns on every read and is read-only unless a setter is added.

2.Property setters

@name.setter defines what obj.name = value actually does — most often validating the incoming value before storing it. Without a setter, a @property is read-only; adding one makes assignment run real code instead of failing.

Key features

@name.setter must reuse the SAME method name as the @property it pairs with
The setter method takes self and exactly one value parameter
Common use: validate the incoming value, then store it in a differently-named attribute
A setter can transform the value before storing it, not just accept or reject
Defining a setter is what turns a property from read-only into read-write

Getter alone vs. getter + setter

Getter alone vs. getter + setter
Definition	What obj.name = value does
Only @property (getter)	AttributeError — no setter defined
@property + @name.setter	runs the setter method with value as the argument
Setter raises inside its body	the raised exception propagates — assignment never completes
Setter stores under a different name (self._name)	avoids infinite recursion into the property itself

t.celsius = -300 — the setter runs before storage

FalseTrue

t.celsius = -300

@celsius.setter runs

value = -300

value < -273.15?

self._celsius = value

ValueError raised

_celsius left untouched

Command

python

class Name:
    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, new_value):
        self._value = new_value    # validate/transform here

@name.setter must reuse the same method name as its @property — a mismatched name never attaches, and self.name inside it recurses forever.

3.Property deleters

@name.deleter defines what del obj.name actually does — the least common of the three property methods, used for cleanup, resetting to a default, or blocking deletion outright by raising inside it.

Key features

@name.deleter must reuse the same method name as its @property, like the setter does
del obj.name calls the deleter instead of the getter or setter
Without a deleter, del obj.name raises AttributeError on a property
A deleter commonly resets the underlying attribute rather than truly removing it
A deleter can also just raise, to explicitly forbid deletion with a clear message

What del obj.name does, by definition

What del obj.name does, by definition
Definition	del obj.name behaviour
@property only, no deleter	AttributeError — cannot delete
@property + @name.deleter	runs the deleter method
Deleter does del self._name	genuinely removes the underlying storage
Deleter raises	blocks deletion with a custom, explicit error

Command

python

class Name:
    @property
    def value(self):
        return self._value

    @value.deleter
    def value(self):
        del self._value          # or reset, or raise to forbid it

@name.deleter defines what del obj.name does — often a reset rather than a true removal. Without one, deleting a property raises AttributeError.

4.Computed properties

A computed property derives its value from other attributes every time it is read, instead of being stored directly — like full_name computed from first_name and last_name. It can never go stale, because there is nothing stored to go stale.

Key features

A computed property derives its value from other attributes, not from its own stored state
It stays correct automatically — there is no separate copy that can drift out of sync
The trade-off is cost: it recomputes on every single read, with no caching by default
Caching a computed property (lazy, first-read) is opt-in — see property deleters
A computed property can still validate or transform, exactly like any property getter

Stored attribute vs. computed property, for the same information

Stored attribute vs. computed property, for the same information
Approach	What can go wrong
self.full_name = f"{first} {last}" (stored once)	stale if first_name/last_name change afterward
@property def full_name(self): (computed)	always correct, but recomputed on every read
Cached computed property (lazy, reset on write)	correct AND cheap, but adds real bookkeeping
Recomputing something expensive on every read	correct but potentially slow — measure before caching

A computed property never stores its own answer

first_name, last_name

the real, stored state

full_name property

recomputes from them on every read

always in sync

nothing separate to go stale

Command

python

class Person:
    @property
    def full_name(self):
        return f"{self.first_name} {self.last_name}"   # derived, not stored

A computed property derives its value on every read, so it can never go stale — only the cost of recomputing is the trade-off.

Spotted a mistake on this page? Tell us.

Read Sheet