One type of decorators are property getters and setters. These decorators allow for controlled access to variables in class instances.

Property getters and setters are designed specifically for the control of attributes in object-oriented programming. These are different from function decorators in that they are used for class attributes (check out my post on function decorators here).

Both function decorators and property getter and setter decorators modify code with reusable code and use '@' syntax. They both change functionality of the code.

Okay, let's get into it.

Property getters and setters are applied to methods within a class to define various behaviors. A setter sets the attribute to a value, and a getter grabs an attribute from a class. The attribute is set first.

Let's take a look at an example, and then we'll break it down:

class Shoe:
    def __init__(self, brand = "Adidas", size = 9):
        self.brand = brand
        self.size = size
        self._condition = "New"

    @property
    def size(self):
        """The size property"""
        return self._size

    @size.setter
    def size(self, size):
        """size must be an integer"""
        if isinstance(size, int):
            self._size = size
        else:
            print("size must be an integer")

    def cobble(self):
        """Repairs the shoe and sets the condition to 'New'."""
        self.condition = "New"
        print("Your shoe is as good as new!")

    @property
    def condition(self):
        """The condition property"""
        return self._condition

    @condition.setter
    def condition(self, condition):
        self._condition = condition

Let's go through some of this code:

The underscores before some of the attributes (condition, size) indicate to the developer that they are private; they are specific to each instance of the Shoe class (each shoe, lowercase).

You might notice that condition and size are instantiated differently. self._condition = "New" means that each instance (or object) of the shoe class is instantiated with a condition of "New". The same is done for the size attribute, but it is not written as self._size = 9 so that it will trigger the setter property validation, because size needs to be an integer (this is a process called validation). We are setting the condition of each individual shoe object directly, instead of running it through the property setter and getter methods.

The cobble method doesn't need a decorator because it is simply performing an action, not getting/setting an attribute of each shoe object.

Let's do one final change to our code. For example, what if we want to ensure that the size attribute cannot be changed later? After all, a shoe doesn't really change its size, does it?

We can use the hasattr() function to perform a check on each shoe object. Does it have a private attribute of size, indicated by the presence of '_size'? If so, it cannot be changed. Here is the code implemented:

 @size.setter
    def size(self, size):
        """size must be an integer and can't be changed once set"""
        if hasattr(self, '_size'):
            raise AttributeError("Can't change size once set")
        if isinstance(size, int):
            self._size = size
        else:
            raise ValueError("size must be an integer")

Property setters and getters are a bit challenging to grasp, but once understood, you will be coding Python like a pro!

Sources:

Flatiron school material