Python property() Function Explained (With Examples)

When working with object-oriented programming in Python, you often encounter situations where you want to control how attributes are accessed or modified. The property() function is a powerful tool that allows you to define customized getter, setter, and deleter methods for class attributes. This functionality ensures data encapsulation and helps maintain the integrity of your class’s data. In this tutorial, we’ll explore the property() function in detail, along with practical examples to illustrate its usage.

Table of Contents

1. Introduction to property()
2. The Need for Property Methods
3. Creating Property Methods

• Basic Usage
• Getter Method
• Setter Method
• Deleter Method

1. Example 1: Temperature Converter
2. Example 2: Bank Account Simulation
3. Advantages of Using property()
4. Conclusion

1. Introduction to property()

In Python, properties are a way to add managed attributes to classes. A property is defined as a special kind of attribute that computes its value when accessed and allows you to control the behavior when the attribute is assigned or deleted. The property() function provides a convenient way to create these managed attributes by attaching getter, setter, and deleter methods to them.

The general syntax of the property() function is as follows:

property(fget=None, fset=None, fdel=None, doc=None)

Here’s what each argument represents:

• fget: This argument is a function that will be used as the getter method for the property.
• fset: This argument is a function that will be used as the setter method for the property.
• fdel: This argument is a function that will be used as the deleter method for the property.
• doc: An optional argument that represents the docstring for the property.

2. The Need for Property Methods

Properties are essential when you want to expose class attributes but still maintain control over their accessibility and modification. Consider a scenario where you’re building a class to represent a bank account. You want to ensure that the account balance is never set directly to an arbitrary value, and you also want to provide a formatted version of the balance when accessed. This is where property methods come into play.

3. Creating Property Methods

Basic Usage

Let’s start with a basic example to demonstrate the use of the property() function. Suppose we have a Circle class with a radius attribute, and we want to calculate and retrieve the area of the circle using a property:

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

    def calculate_area(self):
        return 3.14 * self.radius ** 2

    area = property(fget=calculate_area)

# Creating an instance of the Circle class
circle = Circle(5)
print("Circle Area:", circle.area)  # Output: Circle Area: 78.5

In this example, the calculate_area() method computes the area based on the radius. By attaching this method to the area property using the property() function, we can access the area as if it were a regular attribute.

Getter Method

The getter method retrieves the value of the property when accessed. It allows you to perform any computations or formatting before returning the value. Here’s an example demonstrating the use of a getter method:

class Person:
    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name

    def full_name(self):
        return f"{self.first_name} {self.last_name}"

    name = property(fget=full_name)

# Creating an instance of the Person class
person = Person("John", "Doe")
print("Full Name:", person.name)  # Output: Full Name: John Doe

In this example, the full_name() method returns the formatted full name of the person. The method is associated with the name property, allowing us to access the full name using person.name.

Setter Method

The setter method allows you to control how the property is assigned a value. It’s called whenever you assign a value to the property. Here’s an example illustrating the use of a setter method:

class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius

    def get_celsius(self):
        return self._celsius

    def set_celsius(self, value):
        if value < -273.15:
            raise ValueError("Temperature cannot be below absolute zero.")
        self._celsius = value

    celsius = property(fget=get_celsius, fset=set_celsius)

# Creating an instance of the Temperature class
temp = Temperature(25)
print("Temperature (Celsius):", temp.celsius)  # Output: Temperature (Celsius): 25

# Trying to set an invalid temperature
try:
    temp.celsius = -300
except ValueError as e:
    print("Error:", e)  # Output: Error: Temperature cannot be below absolute zero.

In this example, the set_celsius() method ensures that the assigned temperature is not below absolute zero. If an invalid value is provided, a ValueError is raised.

Deleter Method

The deleter method is called when the property is deleted using the del statement. It can be used to perform cleanup operations or prevent the property from being deleted under certain conditions. Here’s an example:

class Square:
    def __init__(self, side_length):
        self.side_length = side_length

    def get_area(self):
        return self.side_length ** 2

    def del_area(self):
        print("Deleting area property.")
        del self.side_length

    area = property(fget=get_area, fdel=del_area)

# Creating an instance of the Square class
square = Square(4)
print("Square Area:", square.area)  # Output: Square Area: 16

# Deleting the area property
del square.area  # Output: Deleting area property.

In this example, the del_area() method is triggered when the area property is deleted. It performs a cleanup operation by deleting the side_length attribute.

4. Example 1: Temperature Converter

Let’s consider a practical example of using the property() function to build a temperature converter. We’ll create a TemperatureConverter class that allows you to convert temperatures between Celsius and Fahrenheit. This example will demonstrate the use of getter and setter methods in conjunction with the property() function.

class TemperatureConverter:
    def __init__(self, celsius):
        self._celsius = celsius

    def get_celsius(self):
        return self._celsius

    def set_celsius(self, value):
        if value < -273.15:
            raise ValueError("Temperature cannot be below absolute zero.")
        self._celsius = value

    celsius = property(fget=get_celsius, fset=set_celsius)

    @property
    def fahrenheit(self):
        return (self._celsius * 9/5) + 32

    @fahrenheit.setter
    def fahrenheit(self, value):
        celsius_value = (

value - 32) * 5/9
        self._celsius = celsius_value

# Creating an instance of the TemperatureConverter class
converter = TemperatureConverter(25)

# Converting Celsius to Fahrenheit
print("Celsius:", converter.celsius)
print("Fahrenheit:", converter.fahrenheit)

# Converting Fahrenheit to Celsius
converter.fahrenheit = 77
print("Celsius:", converter.celsius)
print("Fahrenheit:", converter.fahrenheit)

In this example, we define the TemperatureConverter class with two properties: celsius and fahrenheit. The getter and setter methods of the celsius property ensure that the temperature is within a valid range. The fahrenheit property provides a way to convert temperatures back and forth between Celsius and Fahrenheit.

5. Example 2: Bank Account Simulation

Let’s explore a more complex example involving a bank account simulation. We’ll use the property() function to control how the account balance is accessed and modified. The example will showcase getter, setter, and deleter methods working together to enforce business rules and encapsulate the account data.

class BankAccount:
    def __init__(self, initial_balance):
        self._balance = initial_balance

    def get_balance(self):
        return self._balance

    def set_balance(self, amount):
        if amount < 0:
            raise ValueError("Balance cannot be negative.")
        self._balance = amount

    def del_balance(self):
        print("Deleting account balance.")
        del self._balance

    balance = property(fget=get_balance, fset=set_balance, fdel=del_balance)

    @property
    def formatted_balance(self):
        return f"${self._balance:.2f}"

# Creating an instance of the BankAccount class
account = BankAccount(1000)

# Accessing the account balance
print("Account Balance:", account.balance)
print("Formatted Balance:", account.formatted_balance)

# Modifying the account balance
account.balance = 1500
print("Account Balance:", account.balance)
print("Formatted Balance:", account.formatted_balance)

# Trying to set a negative balance
try:
    account.balance = -200
except ValueError as e:
    print("Error:", e)

# Deleting the account balance
del account.balance  # Output: Deleting account balance.

In this example, the BankAccount class uses the balance property to manage the account balance. The getter, setter, and deleter methods ensure that the balance remains non-negative and is accessed and modified appropriately. Additionally, the formatted_balance property provides a formatted version of the balance with currency symbols.

6. Advantages of Using property()

Using the property() function offers several advantages when designing and implementing classes:

• Encapsulation: Property methods allow you to encapsulate the logic for attribute access, modification, and deletion. This enhances data integrity and prevents direct manipulation of attributes.
• Controlled Access: Property methods give you fine-grained control over how attributes are accessed and modified. This control is essential for enforcing business rules and maintaining the correctness of data.
• Code Clarity: By using properties, you make your code more readable and self-explanatory. Instead of directly accessing attributes, users of your class interact with properties that have meaningful names.
• Dynamic Computation: You can perform computations or transformations on the fly when accessing or setting properties. This enables you to abstract away complex logic from the class’s interface.

7. Conclusion

In this tutorial, we delved into the property() function in Python, exploring its usage in creating managed attributes with customized getter, setter, and deleter methods. We covered the basic syntax of the property() function, discussed the need for property methods, and demonstrated their usage through practical examples.

By utilizing the property() function, you can achieve data encapsulation, controlled attribute access, and enhanced code readability in your object-oriented Python programs. Whether you’re building simple conversions or complex simulations, the property() function empowers you to design classes with well-defined interfaces and maintainable code.