Introduction to the usage of Python descriptors (with examples)

This article brings you an introduction to the usage of Python descriptors (with examples). It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

As a python user, you may have been using python for a while, but you may not have used descriptors in python. Next is an introduction to the use of descriptors

Scene introduction

In order to introduce the use of descriptors, we first design a very simple class:

class Product():

    def __init__(self,name,quantity,price):
        self.name = name
        self.quantity = quantity
        self.price = price

This is a commodity class that stores the name, quantity and price of the commodity.

For a product, we generally expect that its quantity and price will not be negative. In order to avoid this situation, we can add some judgments during initialization, such as the following:

class Product():

    def __init__(self,name,quantity,price):
        self.name = name
        if quantity<0:
            raise ValueError(&#39;quantity must be >= 0&#39;)
        self.quantity = quantity
        if quantity<0:
            raise ValueError(&#39;price must be >= 0&#39;)
        self.price = price

But there is also a disadvantage in that this judgment is only added during initialization, and then when assigning attributes to the class instance, there is still no guarantee that the assigned value is greater than 0

So we can use 'features' to solve this problem:

class Product():

    def __init__(self,name,quantity,price):
        self.name = name
        self.quantity = quantity
        self.price = price

    @property
    def quantity(self):
        return self._quantity

    @quantity.setter
    def quantity(self,value):
        if value = 0')
        else:
            self._quantity = value

    @property
    def price(self):
        return self._price

    @price.setter
    def price(self, value):
        if value = 0')
        else:
            self._price = value

book = Product('mybook',6,30)
print(book.quantity)

The @property and @quantity.setter here are two decorators, which can set the reading and writing of properties, which is equivalent to reading and writing properties. , but it actually executes a function. You can look it up by yourself for the specific introduction of the features. The main purpose here is to elicit the descriptor.

Through attributes, you can add judgment when assigning values ​​to attributes. But when there are more attributes in a class, and many attributes also need to add checks for non-negative assignments, using attributes will be too cumbersome, there will be a lot of code duplication, and a lot of decorators will be added. You can use descriptors to solve this problem.

Using descriptors

First look at the concept of descriptors

A descriptor is an object attribute of "binding behavior". In the descriptor protocol, it can be passed Method fills access to properties. These methods include get(), set(), and delete(). If any of these methods is defined in an object, the object is a descriptor

(These methods are special methods, double The underline is not displayed due to conversion)

We first modify the product class above according to the use of descriptors:

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

    def __set__(self, instance, value):
        if value = 0')
        else:
            instance.__dict__[self.name] = value

class Product():
    quantity = NotNegative('quantity')
    price = NotNegative('price')

    def __init__(self,name,quantity,price):
        self.name = name
        self.quantity = quantity
        self.price = price

book = Product('mybook',2,5)

NotNegative is the descriptor class, which is the class attribute of the Product class

In this example, if book.quantity=3 is executed, the interpreter will first search for the instance attributes and find that there is a quantity attribute, but the interpreter also finds that there is also a class attribute that is a descriptor, so the interpreter will eventually choose to go Descriptor for this path. Then because it is a descriptor, the set special method in the descriptor will be executed.

The parameters of the set special method in the descriptor are

self: It is the descriptor instance

instance: It is equivalent to the instance book

## in the example #value: It is the value to be assigned

Since these attributes have no special requirements for the value, the get special method is not implemented in the example.

The get method also has 3 parameters: self, instance, owner. self, instance are the same as those in set, and owner is the Product class in the example

Next, we will mainly look at the operations performed in the else part of the descriptor set method

instance.__dict__[self.name] = value

By calling the dict of the book instance , directly assign values ​​to attributes in dict, which is also an important reason for passing in instances in parameters. Since the descriptor object exists as a class attribute, there may be many objects of this class accessed. In order to prevent attribute overwriting, it is appropriate to store it directly in the attribute of the instance. But there is no way to assign values ​​to attributes here, otherwise it will fall into an infinite loop.

For data descriptors and non-data descriptors, if a class only defines the get() method but not the set(), delete() methods, it is considered a non-data descriptor; otherwise, then Become a data descriptor.

Finally, this article briefly introduces and explains the use of descriptors. If you need a more in-depth understanding, you can refer to the attribute descriptor section of "Smooth Python"

The above is the detailed content of Introduction to the usage of Python descriptors (with examples). For more information, please follow other related articles on the PHP Chinese website!