Si cela ne vous dérange pas des solutions alternatives, je recommanderais lru_cache

Par exemple

from functools import lru_cache
class Test:
    @property
    @lru_cache(maxsize=None)
    def calc(self):
        print("Calculating")
        return 1

Résultats escomptés

In [2]: t = Test()

In [3]: t.calc
Calculating
Out[3]: 1

In [4]: t.calc
Out[4]: 1

Je pense que vous êtes mieux avec un descripteur personnalisé, car c'est exactement le genre de descripteurs de choses. Comme ça:

class CachedProperty:
    def __init__(self, name, get_the_value):
        self.name = name
        self.get_the_value = get_the_value
    def __get__(self, obj, typ): 
        name = self.name
        while True:
            try:
                return getattr(obj, name)
            except AttributeError:
                get_the_value = self.get_the_value
                try:
                    # get_the_value can be a string which is the name of an obj method
                    value = getattr(obj, get_the_value)()
                except AttributeError:
                    # or it can be another external function
                    value = get_the_value()
                setattr(obj, name, value)
                continue
            break


class Mine:
    cached_property = CachedProperty("_cached_property ", get_cached_property_value)

# OR: 

class Mine:
    cached_property = CachedProperty("_cached_property", "get_cached_property_value")
    def get_cached_property_value(self):
        return "the_value"

EDIT: au fait, vous n'avez même pas besoin d'un descripteur personnalisé. Vous pouvez simplement mettre en cache la valeur à l'intérieur de votre fonction de propriété. Par exemple:

@property
def test(self):
    while True:
        try:
            return self._test
        except AttributeError:
            self._test = get_initial_value()

C'est tout ce qu'il y a à faire.

Cependant, beaucoup considéreraient cela comme un abus de property, et comme une façon inattendue de l'utiliser. Et inattendu signifie généralement que vous devriez le faire une autre façon, plus explicite. Un descripteur CachedProperty personnalisé est très explicite, donc pour cette raison je le préférerais à l'approche property, bien qu'il nécessite plus de code.

, Vous pouvez utiliser quelque chose comme ceci:

def cached(timeout=None):
    def decorator(func):
        def wrapper(self, *args, **kwargs):
            value = None
            key = '_'.join([type(self).__name__, str(self.id) if hasattr(self, 'id') else '', func.__name__])

            if settings.CACHING_ENABLED:
                value = cache.get(key)

            if value is None:
                value = func(self, *args, **kwargs)

                if settings.CACHING_ENABLED:
                    # if timeout=None Django cache reads a global value from settings
                    cache.set(key, value, timeout=timeout)

            return value

        return wrapper

    return decorator

Lors de l'ajout au dictionnaire de cache, il génère des clés basées sur la convention class_id_function dans le cas où vous mettez en cache des entités et que la propriété pourrait éventuellement renvoyer une valeur différente pour chacune d'elles.

Il vérifie également une touche de paramètres CACHING_ENABLED au cas où vous souhaiteriez l'éteindre temporairement lorsque vous effectuez des benchmarks.

Mais il n'encapsule pas le décorateur standard property donc vous devriez toujours l'appeler comme une fonction, ou vous pouvez l'utiliser comme ceci (pourquoi le restreindre aux propriétés uniquement):

@cached
@property
def total_sales(self):
    # Some calculations here...
    pass

En outre, il peut être intéressant de noter que dans le cas où vous mettez en cache un résultat à partir de relations de clés étrangères paresseuses, il y a des moments en fonction de vos données où il serait plus rapide d'exécuter simplement une fonction d'agrégat lorsque vous effectuez votre requête select et récupérez tout à la fois, Utilisez donc un outil comme django-debug-toolbar pour votre framework afin de comparer ce qui fonctionne le mieux dans votre scénario.

La version de Django de ce décorateur fait exactement ce que vous décrivez et est simple, donc en plus de mon commentaire, je vais simplement le Copier ici:

class cached_property(object):
    """
    Decorator that converts a method with a single self argument into a
    property cached on the instance.

    Optional ``name`` argument allows you to make cached properties of other
    methods. (e.g.  url = cached_property(get_absolute_url, name='url') )
    """
    def __init__(self, func, name=None):
        self.func = func
        self.__doc__ = getattr(func, '__doc__')
        self.name = name or func.__name__

    def __get__(self, instance, type=None):
        if instance is None:
            return self
        res = instance.__dict__[self.name] = self.func(instance)
        return res

(source).

Comme vous pouvez le voir, il utilise func.name pour déterminer le nom de la fonction (pas besoin de jouer avec inspecter.stack) et il remplace la méthode par son résultat en Mutant instance.__dict__. Donc, les "appels" suivants ne sont qu'une recherche d'attribut et il n'y a pas besoin de caches, et cetera.