Encapsulation

Enables computed or validated attribute access with plain attribute syntax, preserving API stability across implementation changes

OOP design: exposing a derived value such as a full name from first and last name components. Data validation: intercepting attribute reads to compute or enforce constraints before returning. API stability: migrating a stored attribute to a computed one without breaking existing caller code.

Python class definitions, Django model properties, dataclass computed fields, Pydantic model properties

@property def getter_name(self): return self.attribute

@property def ...(self): return ...

getter_name: valid Python identifier used as the attribute name, attribute: any expression or class attribute to return

• @getter_name.setter
• @getter_name.deleter
• property()
• functools.cached_property
• @property\ndef full_name(self):\n return f'{self.first} {self.last}'getattribute@property\ndef full_name(self):\n return f'{self.first} {self.last}'

• property(getter
• setter): older explicit form with same behavior but less readable. functools.cached_property: caches result after first call
• avoids recomputation on repeated access. Regular method call obj.get_name(): explicit but forces parentheses at every call site. @property\ndef full_name(self):\n return f'{self.first} {self.last}'getattr@property\ndef full_name(self):\n return f'{self.first} {self.last}': intercepts all missing attributes
• broader but less targeted than a named property.

Forgetting @property and calling the method with parentheses, causing TypeError when treating the return value as an attribute. Defining a setter with a mismatched name so @full_name.setter is silently ignored and assignment raises AttributeError. Omitting the return statement, making the property silently evaluate to None. Performing expensive I/O or network calls inside @property, hiding latency behind what callers assume is a cheap attribute read.

functools.cached_property: caches result after first access, @property recomputes every time. @property\ndef full_name(self):\n return f'{self.first} {self.last}'getattr@property\ndef full_name(self):\n return f'{self.first} {self.last}': catches all missing attributes broadly, @property targets one specific name. Regular method: requires parentheses, @property does not. Descriptor protocol: lower-level mechanism, @property is a built-in descriptor shortcut.

Coming from Java: may write explicit getFullName() methods instead of @property, missing Python's idiomatic attribute-style access. Coming from C#: may expect auto-backed properties with implicit storage, but Python @property requires explicit return logic. Coming from JavaScript: may confuse @property with getter syntax inside object literals, which use the get keyword not a decorator.

• @property getter
• @property setter
• @property deleter
• functools.cached_property
• property() builtin
• descriptor protocol

Do NOT use @property for expensive operations such as network calls or heavy computation because callers assume attribute access is cheap and fast. Every access re-executes the method body with no implicit caching. Properties are data descriptors and their @property\ndef full_name(self):\n return f'{self.first} {self.last}'set@property\ndef full_name(self):\n return f'{self.first} {self.last}' takes precedence over instance @property\ndef full_name(self):\n return f'{self.first} {self.last}'dict@property\ndef full_name(self):\n return f'{self.first} {self.last}', which can cause subtle surprises if you try to set an instance attribute with the same name.

Allows transparent migration from stored attributes to computed or validated ones without breaking any caller code, preserving backward compatibility in public APIs.

Like a vending machine button that looks like a simple switch but runs a hidden computation each time you press it — same push, fresh result every time.

A property object is a data descriptor, meaning it overrides instance dictionary entries for the same key, unlike non-data descriptors such as plain methods.

@getter_name.setter for read-write properties; functools.cached_property for memoized computed attributes; custom descriptor classes for reusable property logic