2.5. Built-in Decorators: @property, @staticmethod, and @classmethod

The @property decorator allows you to use methods like attributes. It’s a way to add getter, setter, and deleter methods in a Pythonic way.

class Circle:
    def __init__(self, radius):
        self._radius = radius
    
    @property
    def radius(self):
        return self._radius
    
    @radius.setter
    def radius(self, value):
        if value <= 0:
            raise ValueError("Radius must be positive")
        self._radius = value
    
    @property
    def area(self):
        import math
        return math.pi * (self._radius ** 2)

c = Circle(5)
print(c.radius) # 5
print(c.area) # 78.53981633974483
c.radius = 10
print(c.area) # 314.1592653589793

The @property decorator allows you to define a method that can be accessed like an attribute. In the example, the Circle class has a private variable _radius. Using @property, you can define a method called radius to get the value of _radius without directly exposing it. Additionally, you can use @radius.setter to define a method for setting the value of _radius while also performing validation (ensuring the radius is positive). Lastly, @property can also create methods that calculate values, like area, which computes the area of the circle based on the current radius.

Thus, this approach enhances encapsulation, as it allows for validation and calculation within the method while keeping the attribute access syntax simple.

Think of a property as a well-maintained garden where the public can view its beauty but is not allowed to enter and disturb the plants. The radius and area methods are like garden staff who manage the access to the garden (the actual value of _radius) and ensure everything is taken care of (validating inputs and calculating values) without exposing the inner workings to visitors.

A static method is a method inside a class that does not operate on an instance or the class itself.

class Math:
    @staticmethod
    def add(x, y):
        return x + y

print(Math.add(3, 4)) # 7

The @staticmethod decorator indicates that a method belongs to the class rather than an instance of the class. In the example, the Math class has a static method add, which can be called directly using the class name, like Math.add(3, 4). Static methods do not have access to the instance (self) or the class (cls). They are primarily used for utility functions that are related to the class but do not need to modify the class or instance state.

Imagine a library that has a static method called catalog_book. This method could help organize books based on genre without needing to refer to any particular library branch or book instance. You can just call Library.catalog_book(book) without context about any specific book.

Class methods receive the class (cls) as the first argument and can modify class state.

class Person:
    population = 0
    
    def __init__(self, name):
        self.name = name
        Person.population += 1

    @classmethod
    def get_population(cls):
        return cls.population

p1 = Person("Alice")
p2 = Person("Bob")
print(Person.get_population()) # 2

The @classmethod decorator allows the method to receive the class itself as the first argument (cls). This means you can interact with class variables or methods directly. In the example, the Person class has a class variable population that tracks the number of Person instances created. The get_population class method accesses and returns this variable. This way, it allows for operations that influence the class state rather than just an instance state.

Think of a factory that produces cars. Each car produced (an instance) contributes to the total number of cars made (the class state). The class method get_population is like a factory manager who counts and reports how many cars have been manufactured so far.

--