manière pythonique seulement ne fonctionnent première fois une variable est appelée

Question

ma classe Python a des variables qui nécessitent un travail pour calculer la première fois qu'ils sont appelés. Les appels suivants devraient simplement la valeur précalculée.

Je ne veux pas perdre de temps à faire ce travail à moins qu'ils ne sont réellement nécessaires par l'utilisateur. Alors, est-il un moyen Pythonic propre à mettre en œuvre ce cas d'utilisation?

Ma première pensée était d'utiliser la propriété () pour appeler une fonction pour la première fois, puis remplacer la variable:

class myclass(object):
    def get_age(self):
        self.age = 21 # raise an AttributeError here
        return self.age

    age = property(get_age)

Merci

Answer 1

class myclass(object):
    def __init__(self):
        self.__age=None
    @property
    def age(self):
        if self.__age is None:
            self.__age=21  #This can be a long computation
        return self.__age

Alex dit que vous pouvez utiliser __getattr__, voici comment cela fonctionne

class myclass(object):
    def __getattr__(self, attr):
        if attr=="age":
            self.age=21   #This can be a long computation
        return super(myclass, self).__getattribute__(attr)

__getattr__() est invoquée lorsque l'attribut n'existe pas sur l'objet, par exemple. la première fois que vous essayez d'accéder age. Chaque fois après, age existe donc __getattr__ ne soit pas appelé

Answer 2

property, comme vous l'avez vu, ne vous laissera pas remplacer. Vous devez utiliser une approche légèrement différente, par exemple:

class myclass(object):

    @property
    def age(self):
      if not hasattr(self, '_age'):
        self._age = self._big_long_computation()
      return self._age

Il existe d'autres approches telles que __getattr__ ou une classe de descripteur personnalisé, mais celui-ci est plus simple -)

Answer 3

est décorateur Python Cookbook pour ce problème:

class CachedAttribute(object):
    ''' Computes attribute value and caches it in the instance. '''
    def __init__(self, method, name=None):
        # record the unbound-method and the name
        self.method = method
        self.name = name or method.__name__
    def __get__(self, inst, cls):
        if inst is None:
            # instance attribute accessed on class, return self
            return self
        # compute, cache and return the instance's attribute value
        result = self.method(inst)
        setattr(inst, self.name, result)
        return result

Answer 4

Oui, vous pouvez utiliser les propriétés, bien que l'évaluation paresseuse est souvent réalisée en utilisant des descripteurs, voir par exemple:

http://blog.pythonisito.com/2008/08/lazy -descriptors.html