The descriptor protocol is a mechanism used in Python to control attribute access behavior. Its core answer lies in implementing one or more of the __get__(), __set__() and __delete__() methods. 1. __get__(self, instance, owner) is used to obtain attribute value; 2. __set__(self, instance, value) is used to set attribute value; 3. __delete__(self, instance) is used to delete attribute value. The actual uses of descriptors include data verification, delayed calculation of properties, property access logging, and implementation of functions such as property and classmethod. The relationship between descriptors and property lies in that property is a simplified encapsulation of descriptors, and essentially uses a descriptor mechanism. Descriptors are divided into two categories: 1. The priority of data descriptors (implementing __set__ or __delete__) is higher than the instance attribute; 2. The priority of non-data descriptors (implementing only __get__) is lower than the data descriptor but higher than the class attribute. Understanding descriptors helps to have an in-depth understanding of the underlying logic of Python attribute systems and their application in framework development.

In Python, a descriptor is an object that implements a specific protocol, which includes one or more of __get__() , __set__() and __delete__() methods. Their core function is to control the access behavior of attributes . For example, when you access a property of a certain class, if the property is a descriptor object, Python will call its __get__() or __set__() methods to handle it.

This sounds a bit abstract, but in fact you have used it in your daily life. For example, property , classmethod and staticmethod are all implemented based on the descriptor mechanism.

What is the descriptor protocol?

A descriptor protocol refers to a class that defines one or more of the following three methods:

• __get__(self, instance, owner) : used to obtain attribute value
• __set__(self, instance, value) : used to set the attribute value
• __delete__(self, instance) : used to delete attribute values

As long as a class implements any of the methods, it is a descriptor. These methods are automatically called when it is accessed as a class attribute of another class.

To give a simple example:

 class DescriptorExample:
    def __get__(self, instance, owner):
        return "Getting the value"

class MyClass:
    attr = DescriptorExample()

obj = MyClass()
print(obj.attr) # Output: Getting the value

In this example, accessing obj.attr actually triggers the descriptor's __get__() method.

What is the practical use of descriptors?

The main purpose of descriptors is to encapsulate property access logic , allowing you to control the behavior of properties more refinedly. Common application scenarios include:

• Data verification (such as checking whether the assignment is legal)
• Delay calculation properties (similar to @property 's effect)
• Attribute access logging
• Implement built-in functions such as property and classmethod

Let’s give an example of data verification:

 class PositiveInteger:
    def __init__(self, name):
        self.name = name

    def __set__(self, instance, value):
        if not isinstance(value, int) or value <= 0:
            raise ValueError("must be a positive integer")
        instance.__dict__[self.name] = value

class Person:
    age = PositiveInteger(&#39;age&#39;)

p = Person()
p.age = 25 # Normal p.age = -1 # Throw ValueError

This ensures that age attribute is always legal.

What is the relationship between descriptor and property?

property is a built-in class in Python, which is essentially implemented using the descriptor mechanism. You can think of it as a simplified encapsulation of the descriptor.

For example, the following code:

 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 greater than 0")
        self._radius = value

@property and @radius.setter here are actually defining a descriptor object and mounting it as a class attribute on Circle.radius .

So it can be said that property is a high-level interface for descriptors , suitable for most ordinary scenarios; writing descriptors directly is more suitable for situations where more flexible control is required.

How to distinguish between data descriptors and non-data descriptors?

This is a key point in descriptor classification:

• Data descriptor : Descriptor implements __set__() or __delete__() descriptor
• Non-data descriptor : Only descriptors that implement __get__()

The difference is that the attribute search order is different. For class instances, the priority order of finding properties is as follows:

1. Data descriptor
2. Instance properties (in __dict__ )
3. Non-data descriptor
4. Class attributes

This means that if you define a data descriptor, it can overwrite the instance's own attribute value.

Basically that's it. Descriptors may seem a bit underlying, but are very useful when building elegant, maintainable class structures, especially often found in framework development. Although you don't necessarily write it yourself, understanding how it works will help you better understand Python's attribute system.

The above is the detailed content of What is descriptor in python. For more information, please follow other related articles on the PHP Chinese website!