Python Property: Getters, Setters, and Validation
Learn how to use Python's property decorator to control attribute access, add validation, and compute values with clean, readable code.

The @property decorator lets you intercept attribute access on a class without exposing getter and setter methods to callers. It turns a method into an attribute, so you can add validation, compute values, or make attributes read-only while keeping the interface simple. Instead of writing obj.get_value() and obj.set_value(), you write obj.value and obj.value = new_value, and the underlying logic runs automatically.
The @property Decorator Syntax
The most common way to define a property is with the @property decorator. A method decorated with @property becomes the getter. To add a setter, you use the @<property_name>.setter decorator on a method with the same name. The same pattern works for a deleter with @<property_name>.deleter.
class Temperature:
def __init__(self, celsius):
self.celsius = celsius
@property
def celsius(self):
return self._celsius
@celsius.setter
def celsius(self, value):
if value < -273.15:
raise ValueError("Temperature below absolute zero")
self._celsius = valueHere, _celsius is the internal attribute. The property celsius exposes it with validation. When you assign temp.celsius = 25, the setter runs and checks the value. When you read temp.celsius, the getter returns the stored value. This keeps the validation logic in one place and prevents the same checks from being duplicated across request handlers or other parts of the code.
Using property() Without Decorators
The property() built-in function is the underlying mechanism behind the decorator. You can call it directly with getter, setter, and deleter functions. This is useful when you need to define a property dynamically or when you prefer a more explicit style.
class Rectangle:
def __init__(self, width, height):
self._width = width
self._height = height
def get_width(self):
return self._width
def set_width(self, value):
self._width = value
def get_area(self):
return self._width * self._height
width = property(get_width, set_width)
area = property(get_area)In this example, width is a property with a getter and setter, while area is read-only because it has only a getter. The property() function accepts up to four arguments: fget, fset, fdel, and doc. This form is equivalent to the decorator syntax, but the decorator is usually more readable when you have several properties in a class.
Adding Validation in Setters
A common use of properties is to validate data before it is stored. The setter runs every time the attribute is assigned, so you can enforce type checks, range limits, or business rules without scattering validation code across your application.
class Account:
def __init__(self, balance):
self.balance = balance
@property
def balance(self):
return self._balance
@balance.setter
def balance(self, amount):
if not isinstance(amount, (int, float)):
raise TypeError("Balance must be a number")
if amount < 0:
raise ValueError("Balance cannot be negative")
self._balance = amountNow any assignment to account.balance is checked. If you later need to add a logging step or a database update, you can do it in the setter without changing the public interface. This is especially valuable when the class is used in multiple places, because the validation is centralized.
Computed Properties and Read-Only Access
Properties are not limited to storing and retrieving values. They can compute a value on the fly from other attributes. This keeps derived data consistent and avoids the need to manually update a cached field.
class Circle:
def __init__(self, radius):
self.radius = radius
@property
def area(self):
return 3.14159 * self.radius ** 2
@property
def diameter(self):
return self.radius * 2area and diameter are computed each time they are accessed. If the radius changes, the computed values automatically reflect the new radius. This is preferable to storing area as a separate attribute, which could become stale.
To make a property read-only, simply omit the setter. Any attempt to assign to a read-only property raises an AttributeError. This is useful for values that should never change after initialization, such as a unique identifier or a creation timestamp.
The Deleter and Property Lifecycle
A property can also define a deleter, which runs when you use del obj.attribute. The deleter is useful for cleanup or to reset an attribute to a default state.
class Session:
def __init__(self):
self._token = None
@property
def token(self):
return self._token
@token.setter
def token(self, value):
self._token = value
@token.deleter
def token(self):
self._token = NoneDeleting a property attribute does not delete the underlying internal attribute unless you explicitly do so. In this example, del session.token resets the token to None, which might be the desired behavior for logging out. The deleter gives you control over what happens when a caller removes the attribute.
Performance and Overhead
Accessing a property is a method call, so it is slightly slower than accessing a plain attribute. In most applications, this overhead is negligible. However, in tight loops that access an attribute millions of times, the difference can become measurable. If you are optimizing a performance-critical path, consider whether a property is necessary.
Plain attributes are faster because they do not involve a function call. If you only need to store and retrieve a value without any validation or computation, a plain attribute is the better choice. Properties add flexibility at the cost of a small runtime penalty. You can mitigate this by caching computed values if the underlying data changes infrequently, but that adds complexity.
When to Use Properties vs Plain Attributes
Use a property when you need to control access to an attribute. Typical reasons include validation, lazy computation, or the need to change the internal representation without breaking external code. For example, if you store temperature in Celsius but want to expose it in Fahrenheit, you can use a property to convert on the fly.
Use a plain attribute when you have simple data storage and no need for control. A class that just holds a name and an email address does not benefit from properties. Adding properties to every attribute makes the code more verbose and slower without providing value.
The decision should be based on the actual requirements. If you are writing a class that will be used as a public API, properties allow you to evolve the internal implementation without changing the interface. If the class is internal to a module and you control all access, plain attributes are often sufficient.
Inheritance and Property Overriding
Properties behave like methods when it comes to inheritance. You can override behavior in a subclass by defining a property with the same name. The most direct way is to redefine the whole property, including the getter and setter that you want to change:
class Base:
def __init__(self, value):
self._value = value
@property
def value(self):
return self._value
@value.setter
def value(self, v):
self._value = v
class Derived(Base):
@property
def value(self):
return self._value * 2
@value.setter
def value(self, v):
self._value = v + 10In Derived, reading value returns twice the stored value, and assigning value adds 10 before storing. This allows subclasses to modify behavior while keeping the same attribute interface.
If you only need to replace the setter, you do not have to redefine the getter. Apply @Base.value.setter to a method named value; this returns a new property that keeps the base getter and uses your new setter.
Properties are a fundamental tool in Python for creating clean, maintainable class interfaces. They let you add logic to attribute access without forcing callers to change how they interact with your objects. By using them judiciously, you can keep your code expressive and robust.
Try matching browser tools
All toolsSmall utilities that fit Python work — they run entirely in this browser tab, so nothing you paste leaves your device.
Related Python guides
All Python guidesPython iter(): How the Built-in Function Works
Explains Python's iter() built-in: how it creates iterators, the two-argument sentinel form, custom iterator classes, and common edge cases.
Python Pika: Queues, Exchanges, Routing Keys, and Acknowledgements
Learn how to use Python's Pika client with RabbitMQ: declare queues and exchanges, publish with routing keys, consume messages, and handle acknowledgements reliably.
Python Kafka: kafka-python vs Confluent Client
python kafka python vs confluent kafka: Compare kafka-python and Confluent Kafka Python clients: API differences, performance, feature coverage, and when to choose eac...
Python Kafka Offsets, Partitions, and Manual Commits
Learn how Kafka offsets and partitions work and how to manually commit offsets in Python consumers with kafka-python and confluent-kafka. Covers sync vs async commits, rebalances, and seeking.
More in Python
All Python guidesThe guides filed next to this one in Python, in library order.