Utilisation délicate du décorateur @property en Python (exemple de code)

Ce que cet article vous apporte concerne l'utilisation technique du décorateur @property en Python (exemples de code). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Le décorateur @property peut transformer une méthode en propriété et l'appeler. Jetons un coup d'œil à l'analyse des compétences d'utilisation du décorateur @property par magie noire

@ À quoi servent les attributs ? ? En apparence, il semble qu’une méthode soit accessible en tant qu’attribut.

Le code ci-dessus

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

montre que bien que la zone soit définie comme une méthode, après avoir ajouté @property, elle est accessible directement c.area en tant que propriété.

Voici maintenant le problème. Chaque fois que c.area est appelé, il sera calculé une fois. C'est un gaspillage de CPU. Comment peut-il être calculé une seule fois ? C'est la propriété de la paresse.

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

Comme vous pouvez le voir, « évaluer » n'est affiché qu'une seule fois, vous devez donc avoir une bonne compréhension du mécanisme de @Lazy.

Ici, la classe paresseuse a une méthode __get__, indiquant qu'il s'agit d'un descripteur. Lorsque c.area a été exécuté pour la première fois, en raison de problèmes d'ordre, elle a d'abord été recherchée dans Ç.__dict__. n'a pas été trouvé, allez simplement dans l'espace de classe pour le trouver. Dans le cercle de classe, il y a la méthode Area(), elle est donc interceptée par __get__.

Dans __get__, appelez la méthode region() de l'instance pour calculer le résultat, ajoutez dynamiquement un attribut du même nom à l'instance et attribuez-lui le résultat, c'est-à-dire ajoutez-le à Ç. __ dict__.

Lors de l'exécution à nouveau de c.area, allez d'abord dans Ç.__ dict__ pour le trouver, car il existe déjà à ce moment-là, vous ne passerez donc pas par la méthode Area() et __get__.

Remarques

Veuillez prêter attention aux scénarios de code suivants :

Extrait de code 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

Extrait de code 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

La différence entre les codes 1 et 2 c'est que

classe Parrot (objet) :

Sous python2, lancez le test séparément

Fragment 1 : Une erreur attendue sera demandé Information AttributeError : Impossible de définir la propriété

Fragment 2 : Opération correcte

Reportez-vous à la documentation python2, @property fournira un attribut prêt uniquement, le code ci-dessus ne fournit pas le correspondant @voltage.setter, il va de soi. Le code de l'extrait 2 provoquera une erreur d'exécution. Dans la documentation python2, nous pouvons trouver les informations suivantes :

BIF :

property([fget). [,fset[,fdel[,doc]]]] )

Renvoie les propriétés d'attribut de la nouvelle classe de style (classes dérivées de Object).

Il s'avère que sous python2, l'objet de type intégré n'est pas la classe de base par défaut. S'il n'y a pas d'explication claire lors de la définition de la classe (extrait de code 2), le Parrot que nous avons défini (extrait de code 2). ) n'héritera pas de l'objet

La classe d'objet fournit simplement la fonction @property dont nous avons besoin. Nous pouvons trouver les informations suivantes dans le document :

Nouvelle classe de style

N'importe quelle classe. qui hérite de l'objet. Cela inclut tous les types intégrés tels que list et dict. Seules les classes de nouveau style peuvent utiliser les fonctionnalités génériques les plus récentes de Python telles que __slots__, les descripteurs, les attributs et __getattribute__().

En même temps, nous pouvons également vérifier via la méthode suivante

class A: 
  pass 
>>type(A) 
<type &#39;classobj&#39;>

class A(object): 
  pass 
>>type(A) 
<type &#39;type&#39;>

Cela peut être vu à partir du , est le type d'objet dont nous avons besoin (python 3.0 utilise la classe d'objet comme classe de base par défaut, donc tous renverront )

Afin de considérer la version python du code Concernant les problèmes de compatibilité pendant la période de transition, je pense que lors de la définition des fichiers de classe, les objets doivent être explicitement définis comme une bonne habitude

Le code final sera le suivant :

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!