Décorateur de propriété de mémorisation / recherche différée Python

Récemment, j'ai parcouru une base de code existante contenant de nombreuses classes où les attributs d'instance reflètent les valeurs stockées dans une base de données. J'ai remanié beaucoup de ces attributs pour que leurs recherches dans la base de données soient différées, c'est-à-dire. ne pas être initialisé dans le constructeur mais uniquement lors de la première lecture. Ces attributs ne changent pas au cours de la durée de vie de l'instance, mais ils constituent un véritable goulot d'étranglement pour calculer cette première fois et ne sont vraiment accessibles que pour des cas particuliers. Par conséquent, ils peuvent également être mis en cache après avoir été récupérés de la base de données (cela correspond donc à la définition de la mémoisation où l'entrée est simplement "aucune entrée").

Je me surprends à taper encore et encore l'extrait de code suivant pour divers attributs dans différentes classes:

class testA(object):

  def __init__(self):
    self._a = None
    self._b = None

  @property
  def a(self):
    if self._a is None:
      # Calculate the attribute now
      self._a = 7
    return self._a

  @property
  def b(self):
    #etc

Existe-t-il déjà un décorateur pour faire cela en Python dont je ne suis tout simplement pas au courant? Ou y a-t-il un moyen raisonnablement simple de définir un décorateur qui fait cela?

Je travaille sous Python 2.5, mais les réponses 2.6 peuvent être intéressantes si elles sont significativement différentes.

Remarque

Cette question a été posée avant que Python n'inclue beaucoup de décorateurs prêts à l'emploi pour cela. Je l'ai mis à jour uniquement pour corriger la terminologie.

Pour toutes sortes de grands utilitaires, j'utilise des boulons .

Dans le cadre de cette bibliothèque, vous avez mis en cache la propriété :

from boltons.cacheutils import cachedproperty

class Foo(object):
    def __init__(self):
        self.value = 4

    @cachedproperty
    def cached_prop(self):
        self.value += 1
        return self.value


f = Foo()
print(f.value)  # initial value
print(f.cached_prop)  # cached property is calculated
f.value = 1
print(f.cached_prop)  # same value for the cached property - it isn't calculated again
print(f.value)  # the backing value is different (it's essentially unrelated value)

Voici un exemple d'implémentation d'un décorateur de propriété paresseux:

import functools

def lazyprop(fn):
    attr_name = '_lazy_' + fn.__name__

    @property
    @functools.wraps(fn)
    def _lazyprop(self):
        if not hasattr(self, attr_name):
            setattr(self, attr_name, fn(self))
        return getattr(self, attr_name)

    return _lazyprop


class Test(object):

    @lazyprop
    def a(self):
        print 'generating "a"'
        return range(5)

Session interactive:

>>> t = Test()
>>> t.__dict__
{}
>>> t.a
generating "a"
[0, 1, 2, 3, 4]
>>> t.__dict__
{'_lazy_a': [0, 1, 2, 3, 4]}
>>> t.a
[0, 1, 2, 3, 4]

J'ai écrit celui-ci pour moi-même ... A utiliser pour de vraies propriétés paresseuses calculées une seule fois . Je l'aime car cela évite de coller des attributs supplémentaires sur les objets, et une fois activé, ne perd pas de temps à vérifier la présence d'attributs, etc.:

import functools

class lazy_property(object):
    '''
    meant to be used for lazy evaluation of an object attribute.
    property should represent non-mutable data, as it replaces itself.
    '''

    def __init__(self, fget):
        self.fget = fget

        # copy the getter function's docstring and other attributes
        functools.update_wrapper(self, fget)

    def __get__(self, obj, cls):
        if obj is None:
            return self

        value = self.fget(obj)
        setattr(obj, self.fget.__name__, value)
        return value


class Test(object):

    @lazy_property
    def results(self):
        calcs = 1  # Do a lot of calculation here
        return calcs

Remarque: La lazy_propertyclasse est un descripteur sans données , ce qui signifie qu'elle est en lecture seule. L'ajout d'une __set__méthode l'empêcherait de fonctionner correctement.

Voici une appelable qui prend un argument de délai d' attente en option, dans la __call__vous pouvez aussi copier le __name__, __doc__, __module__de l'espace de noms de func:

import time

class Lazyproperty(object):

    def __init__(self, timeout=None):
        self.timeout = timeout
        self._cache = {}

    def __call__(self, func):
        self.func = func
        return self

    def __get__(self, obj, objcls):
        if obj not in self._cache or \
          (self.timeout and time.time() - self._cache[key][1] > self.timeout):
            self._cache[obj] = (self.func(obj), time.time())
        return self._cache[obj]

ex:

class Foo(object):

    @Lazyproperty(10)
    def bar(self):
        print('calculating')
        return 'bar'

>>> x = Foo()
>>> print(x.bar)
calculating
bar
>>> print(x.bar)
bar
...(waiting 10 seconds)...
>>> print(x.bar)
calculating
bar

propertyest une classe. Un descripteur pour être exact. Dérivez-en simplement et implémentez le comportement souhaité.

class lazyproperty(property):
   ....

class testA(object):
   ....
  a = lazyproperty('_a')
  b = lazyproperty('_b')

Ce que vous voulez vraiment, c'est le décorateur reify(lié à la source!) De Pyramid:

À utiliser comme décorateur de méthode de classe. Il fonctionne presque exactement comme le @propertydécorateur Python , mais il place le résultat de la méthode qu'il décore dans l'instance dict après le premier appel, remplaçant effectivement la fonction qu'il décore par une variable d'instance. C'est, dans le langage Python, un descripteur sans données. Voici un exemple et son utilisation:

>>> from pyramid.decorator import reify

>>> class Foo(object):
...     @reify
...     def jammy(self):
...         print('jammy called')
...         return 1

>>> f = Foo()
>>> v = f.jammy
jammy called
>>> print(v)
1
>>> f.jammy
1
>>> # jammy func not called the second time; it replaced itself with 1
>>> # Note: reassignment is possible
>>> f.jammy = 2
>>> f.jammy
2

Il y a un mélange de termes et / ou une confusion des concepts à la fois en question et dans les réponses jusqu'à présent.

L'évaluation paresseuse signifie simplement que quelque chose est évalué au moment de l'exécution au dernier moment possible lorsqu'une valeur est nécessaire. C'est @propertyexactement ce que fait le décorateur standard . (*) La fonction décorée est évaluée uniquement et chaque fois que vous avez besoin de la valeur de cette propriété. (voir l'article de wikipedia sur l'évaluation paresseuse)

(*) En fait, une véritable évaluation paresseuse (comparer par exemple haskell) est très difficile à réaliser en python (et aboutit à un code qui est loin d'être idiomatique).

La mémorisation est le terme correct pour ce que le demandeur semble rechercher. Les fonctions pures qui ne dépendent pas des effets secondaires pour l'évaluation de la valeur de retour peuvent être mémorisées en toute sécurité et il y a en fait un décorateur dans les fonctools @functools.lru_cache donc pas besoin d'écrire ses propres décorateurs sauf si vous avez besoin d'un comportement spécialisé.

Vous pouvez faire cela facilement et facilement en construisant une classe à partir de la propriété native Python:

class cached_property(property):
    def __init__(self, func, name=None, doc=None):
        self.__name__ = name or func.__name__
        self.__module__ = func.__module__
        self.__doc__ = doc or func.__doc__
        self.func = func

    def __set__(self, obj, value):
        obj.__dict__[self.__name__] = value

    def __get__(self, obj, type=None):
        if obj is None:
            return self
        value = obj.__dict__.get(self.__name__, None)
        if value is None:
            value = self.func(obj)
            obj.__dict__[self.__name__] = value
        return value

Nous pouvons utiliser cette classe de propriété comme une propriété de classe régulière (elle prend également en charge l'attribution d'éléments comme vous pouvez le voir)

class SampleClass():
    @cached_property
    def cached_property(self):
        print('I am calculating value')
        return 'My calculated value'


c = SampleClass()
print(c.cached_property)
print(c.cached_property)
c.cached_property = 2
print(c.cached_property)
print(c.cached_property)

Valeur calculée uniquement la première fois et après cela, nous avons utilisé notre valeur enregistrée

Production:

I am calculating value
My calculated value
My calculated value
2
2