2.6. Descriptor Protocol: __get__, __set__, and __delete__

A descriptor is an object attribute with “binding behavior,” meaning it defines methods to control attribute access. Descriptors are the low-level mechanism behind properties, methods, and more.

A descriptor in Python is a special kind of object that controls how attributes are accessed. This means that whenever you try to get, set, or delete an attribute of a class, a descriptor can intervene and customize this behavior. Descriptors are essential in Python as they serve as the foundation for the functionality of properties and methods. They provide a structured way to enforce rules for attribute management.

Think of a descriptor as a security guard at a building. Just as the guard controls who can enter and leave the premises based on certain rules, a descriptor controls how attributes can be accessed in a class. If a person (the class attribute) wants to enter (be accessed) the building (the instance), the guard (descriptor) checks if they can come in and whether they follow the necessary protocols.

The descriptor protocol defines three methods:

• get(self, instance, owner) — Retrieve the attribute value.
• set(self, instance, value) — Set the attribute value.
• delete(self, instance) — Delete the attribute.

The descriptor protocol specifies three key methods that you can define in a descriptor class. The get method is called when the attribute is accessed. The set method is used when you want to assign a new value to the attribute, while delete is invoked when you intend to remove the attribute. These methods give you the flexibility to implement custom behavior whenever the attribute is used.

Imagine these methods as different actions of a robot. When you want to get information (get), the robot retrieves details and presents them. When you want to change something (set), the robot updates the information, and if you need something removed (delete), the robot clears it away. Each action is handled in a specific way that you can control.

Descriptors are used as class variables. When accessed via an instance, Python calls the descriptor’s methods.

Example: Simple Descriptor

class Descriptor:
    def __get__(self, instance, owner):
        print("Getting attribute")
        return instance._value
    def __set__(self, instance, value):
        print("Setting attribute")
        instance._value = value
    def __delete__(self, instance):
        print("Deleting attribute")
        del instance._value

class MyClass:
    attr = Descriptor()

obj = MyClass()
obj.attr = 42 # Setting attribute
print(obj.attr) # Getting attribute, Output: 42
del obj.attr # Deleting attribute

In this example, we define a class called Descriptor with the three methods of the descriptor protocol. When these methods are called, they print messages indicating what action is occurring. The class MyClass includes a class variable named attr which is an instance of Descriptor. When we set obj.attr = 42, the __set__ method is invoked, printing 'Setting attribute'. When we print the value of obj.attr, the __get__ method is called, which prints 'Getting attribute' and returns the value. Finally, calling del obj.attr triggers the __delete__ method, printing 'Deleting attribute' and removing the value.

Think of it as a smart vault that controls access to valuable items (attributes). When you need to put something in the vault (set), it acknowledges the action. When you take something out (get), it checks in with you, confirming you're allowed to access it. And if you want to completely remove something from the vault (delete), it ensures the item is securely disposed of after confirming your request.

--