Codectionary / Developer documentation / Python

@property

The @property decorator lets you define a method that can be accessed like a plain attribute, without parentheses. This is useful for computed values that should look like simple attributes, and for adding validation logic that runs whenever an attribute is set, via a matching @x.setter. Properties let you start with simple public attributes and later add logic without breaking any code that uses the class.

Syntax

@property\ndef attr(self):\n    return self._attr

Examples

Basic Property

Exposing a computed value that looks like a regular attribute.

class Circle:
    def __init__(self, radius):
        self.radius = radius

    @property
    def area(self):
        return 3.14159 * self.radius ** 2

c = Circle(5)
print(c.area)  # 78.53975 (called without parentheses, like an attribute)

Property with a Setter

Adding validation logic that runs whenever the attribute is assigned to.

class Product:
    def __init__(self, name, price):
        self.name = name
        self._price = price

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

    @price.setter
    def price(self, value):
        if value < 0:
            raise ValueError("Price cannot be negative")
        self._price = value

item = Product("Mouse", 25)
item.price = 30       # calls the setter
print(item.price)     # 30

try:
    item.price = -10  # raises ValueError
except ValueError as e:
    print(e)

Read-Only Property

Defining a property with no setter to make it effectively read-only from outside the class.

class Employee:
    def __init__(self, first, last):
        self.first = first
        self.last = last

    @property
    def full_name(self):
        return f"{self.first} {self.last}"

emp = Employee("Fola", "A")
print(emp.full_name)  # Fola A

# emp.full_name = "New Name"  # would raise AttributeError - no setter defined

Best practices

  • Use @property for computed or derived values that should behave like attributes, not method calls with parentheses
  • Add a @x.setter only when you need validation or side effects on assignment - a plain attribute is simpler when no logic is needed
  • Store the underlying data in a conventionally "private" attribute (prefixed with an underscore) to avoid naming conflicts with the property itself
  • Start a class with plain public attributes, and convert to a property later if you need to add logic - this keeps the external interface unchanged

At a glance

Purpose
Scripting and general-purpose applications
File extension
.py
Runs in
Python interpreter
Usually used with
Python standard library and packages

Specifications & further reading

Related Python documentation

class
The class keyword defines a blueprint for creating objects in Python. Classes are the foundation of Object-Oriented Programming (OOP), allowing you to bundle data (attributes) and functionality (methods) together. A class defines what attributes an object will have and what operations can be performed on it. Think of a class as a template or a factory for creating objects with similar characteristics.
Inheritance & super()
Inheritance lets a class (the child or subclass) reuse and extend the attributes and methods of another class (the parent or superclass), written as class Child(Parent). The built-in super() function gives access to the parent class's methods from within the child, most commonly used to call the parent's __init__ so the child doesn't have to duplicate its setup logic. Python also supports multiple inheritance, where a class inherits from more than one parent.
Magic (Dunder) Methods
Magic methods, also called dunder (double underscore) methods, let your custom classes hook into Python's built-in syntax and behavior. __init__ runs on object creation, __str__ controls how an object is displayed with print(), __eq__ and __lt__ control comparisons, __len__ controls the len() function, and __add__ lets objects respond to the + operator. Implementing these makes your custom classes feel like natural, first-class Python types.
@staticmethod and @classmethod
Regular instance methods automatically receive self, the specific object they were called on. @staticmethod methods receive neither self nor the class - they behave like a plain function that just happens to live inside a class, grouped there for organizational purposes. @classmethod methods receive the class itself (conventionally named cls) instead of an instance, making them useful for alternative constructors that build an instance in a different way.