105. Property Decorators

Property decorators in Python are used to define getter, setter, and deleter methods for class attributes in a more readable and Pythonic way. Instead of manually defining methods like get_name() and set_name(), you can use the @property decorator to create getter methods and the @<property_name>.setter and @<property_name>.deleter decorators for setters and deleters, respectively.

Here are 10 Python snippets demonstrating how to use property decorators for managing class attributes.

1. Basic Property with Getter

class Person:
    def __init__(self, name):
        self._name = name
    
    @property
    def name(self):
        return self._name

# Usage
p = Person("Alice")
print(p.name)  # This calls the getter method

Explanation: The @property decorator is used to define the getter method for the name attribute.

---

2. Property with Setter

class Person:
    def __init__(self, name):
        self._name = name
    
    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, value):
        if not value:
            raise ValueError("Name cannot be empty")
        self._name = value

# Usage
p = Person("Alice")
p.name = "Bob"  # This calls the setter method
print(p.name)

Explanation: The setter method is defined using @name.setter. It allows you to set a value for the name attribute, with validation.

---

3. Property with Deleter

class Person:
    def __init__(self, name):
        self._name = name
    
    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, value):
        self._name = value

    @name.deleter
    def name(self):
        print("Deleting name...")
        del self._name

# Usage
p = Person("Alice")
print(p.name)  # Calls getter
del p.name  # Calls deleter

Explanation: The @name.deleter decorator is used to define the method for deleting the name attribute. In this case, we print a message before deleting it.

---

4. Property with a Computed Value

class Rectangle:
    def __init__(self, width, height):
        self._width = width
        self._height = height
    
    @property
    def area(self):
        return self._width * self._height

# Usage
rect = Rectangle(5, 3)
print(rect.area)  # Calls the property method

Explanation: The area property calculates a value dynamically rather than storing it. It’s automatically updated based on the width and height.

---

5. Property with Cached Getter

class Fibonacci:
    def __init__(self, n):
        self._n = n
        self._fib_cache = {}
    
    @property
    def fibonacci(self):
        if self._n in self._fib_cache:
            return self._fib_cache[self._n]
        if self._n <= 1:
            return self._n
        result = self._n * self.fibonacci  # Recursive logic for Fibonacci
        self._fib_cache[self._n] = result
        return result

# Usage
fib = Fibonacci(10)
print(fib.fibonacci)

Explanation: This example shows a computed property where the Fibonacci number is cached to optimize performance.

---

6. Setter with Validation

class Person:
    def __init__(self, age):
        self._age = age
    
    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, value):
        if value < 0:
            raise ValueError("Age cannot be negative")
        self._age = value

# Usage
p = Person(25)
p.age = -5  # This will raise a ValueError

Explanation: The setter ensures that the age attribute cannot be set to a negative value.

---

7. Read-Only Property

class Circle:
    def __init__(self, radius):
        self._radius = radius
    
    @property
    def radius(self):
        return self._radius
    
    @property
    def circumference(self):
        return 2 * 3.1416 * self._radius

# Usage
circle = Circle(10)
print(circle.radius)  # Getter
print(circle.circumference)  # Read-only computed property

Explanation: circumference is a read-only property derived from the radius.

---

8. Property with Logging

class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius
    
    @property
    def celsius(self):
        return self._celsius
    
    @celsius.setter
    def celsius(self, value):
        print(f"Setting temperature to {value}°C")
        self._celsius = value

# Usage
t = Temperature(25)
t.celsius = 30  # Logs the change

Explanation: The setter for celsius logs the change each time the temperature is set.

---

9. Private Attribute with Property Access

class BankAccount:
    def __init__(self, balance):
        self._balance = balance
    
    @property
    def balance(self):
        return self._balance
    
    @balance.setter
    def balance(self, amount):
        if amount < 0:
            raise ValueError("Balance cannot be negative")
        self._balance = amount

# Usage
account = BankAccount(1000)
account.balance = 500  # Setter changes the balance
print(account.balance)  # Getter retrieves the balance

Explanation: A private attribute (_balance) is accessed and modified using the property decorators.

---

10. Class Property

class Car:
    _total_cars = 0
    
    def __init__(self, model):
        self._model = model
        Car._total_cars += 1
    
    @classmethod
    @property
    def total_cars(cls):
        return cls._total_cars

# Usage
car1 = Car("Model X")
car2 = Car("Model Y")
print(Car.total_cars)  # Class property

Explanation: A class-level property is created using the @classmethod and @property decorators together. It tracks the total number of cars created.

---

Key Concepts:

1. Getter (@property): Defines a method to access the value of an attribute.

2. Setter (@property_name.setter): Defines a method to set the value of an attribute with validation or other logic.

3. Deleter (@property_name.deleter): Defines a method to delete an attribute.

4. Read-only Properties: Properties that can only be accessed but not modified.

5. Validation: Properties can include validation logic to ensure data integrity.

6. Caching/Optimization: You can cache values to improve performance, especially in computed properties.

7. Private Attributes: Properties provide controlled access to private attributes, which cannot be directly accessed outside the class.

Using property decorators helps to keep the class interface clean and intuitive, while still encapsulating the internal logic.