This article brings you the technical usage (code examples) of the @property decorator in Python. It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.
@property decorator can turn a method into a property and call it. Let’s take a look at Python’s black magic @property decorator usage skills analysis
@ What are attributes used for? On the surface, it seems that a method is accessed as an attribute.
The above code
class Circle(object): def __init__(self, radius): self.radius = radius @property def area(self): return 3.14 * self.radius ** 2 c = Circle(4) print c.radius print c.area
As you can see, although the area is defined in the form of a method, after adding @property, it can be accessed directly c.area as a property.
Now the question comes. Every time c.area is called, it will be calculated once. It is a waste of CPU. How can it be calculated only once? This is the property of laziness.
class lazy(object): def __init__(self, func): self.func = func def __get__(self, instance, cls): val = self.func(instance) setattr(instance, self.func.__name__, val) return val class Circle(object): def __init__(self, radius): self.radius = radius @lazy def area(self): print 'evalute' return 3.14 * self.radius ** 2 c = Circle(4) print c.radius print c.area print c.area print c.area
As you can see, 'evalute' is only output once, so you should have a good understanding of @Lazy's mechanism.
Here, the lazy class has a __get__ method, which indicates that it is a descriptor. When c.area is executed for the first time, due to order issues, it is first searched in Ç.__dict__. If it is not found, just Go to the class space to find it. In the class circle, there is the area() method, so it is intercepted by __get__.
In __get__, call the region() method of the instance to calculate the result, and dynamically add an attribute with the same name to the instance and assign the result to it, that is, add it to Ç.__ dict__.
When executing c.area again, first go to Ç.__ dict__ to find it, because it is already there at this time, so it will not go through the area () method and __get__.
Attention
Please pay attention to the following code scenarios:
Code snippet 1:
class Parrot(object): def __init__(self): self._voltage = 100000 @property def voltage(self): """Get the current voltage.""" return self._voltage if __name__ == "__main__": # instance p = Parrot() # similarly invoke "getter" via @property print p.voltage # update, similarly invoke "setter" p.voltage = 12
Code snippet 2:
class Parrot: def __init__(self): self._voltage = 100000 @property def voltage(self): """Get the current voltage.""" return self._voltage if __name__ == "__main__": # instance p = Parrot() # similarly invoke "getter" via @property print p.voltage # update, similarly invoke "setter" p.voltage = 12
Code 1 ,The difference between 2 is
class Parrot (object):
Under python2, run the test separately
Fragment 1: An expected error message AttributeError: Unable to be prompted Set properties
Fragment 2: Correct operation
Refer to the python2 documentation. @property will provide a ready-only attribute. The above code does not provide the corresponding @voltage.setter. It stands to reason that the code in Fragment 2 will Prompt running error, in the python2 documentation, we can find the following information:
BIF:
property([fget[,fset[,fdel[,doc]]]])
Returns the attribute properties of the new style class (classes derived from Object).
It turns out that under python2, the built-in type object is not the default base class. If there is no clear explanation when defining the class (code snippet 2), the Parrot we defined (code snippet 2) will not inherit Object
The object class just provides the @property function we need. We can find the following information in the document:
New style lesson
Any class that inherits from object . This includes all built-in types such as list and dict. Only new-style classes can use Python's newer, generic features such as __slots__, descriptors, attributes and __getattribute__().
At the same time, we can also verify through the following method
class A: pass >>type(A) <type 'classobj'>
class A(object): pass >>type(A) <type 'type'>
From the returned
In order to consider the compatibility of the python version of the code during the transition period Question, I think when defining a class file, you should explicitly define the object as a good habit
The final code will be as follows:
class Parrot(object): def __init__(self): self._voltage = 100000 @property def voltage(self): """Get the current voltage.""" return self._voltage @voltage.setter def voltage(self, new_value): self._voltage = new_value if __name__ == "__main__": # instance p = Parrot() # similarly invoke "getter" via @property print p.voltage # update, similarly invoke "setter" p.voltage = 12
The above is the detailed content of Tricky usage of @property decorator in Python (code example). For more information, please follow other related articles on the PHP Chinese website!