Zwischenspeichern von Klassenattributen in Python

Ich schreibe eine Klasse in Python und habe ein Attribut, dessen Berechnung relativ lange dauert. Daher möchte ich es nur einmal ausführen . Außerdem wird es nicht von jeder Instanz der Klasse benötigt, daher möchte ich es nicht standardmäßig in tun__init__ .

Ich bin neu in Python, aber nicht in der Programmierung. Ich kann mir einen Weg ausdenken, dies ziemlich einfach zu tun, aber ich habe immer wieder festgestellt, dass die 'Pythonic'-Art, etwas zu tun, oft viel einfacher ist als das, was ich mir aus meiner Erfahrung in anderen Sprachen ausgedacht habe.

Gibt es in Python einen "richtigen" Weg, dies zu tun?

Python ≥ 3.8 @property und @functools.lru_cachewurden in kombiniert @cached_property.

import functools
class MyClass:
    @functools.cached_property
    def foo(self):
        print("long calculation here")
        return 21 * 2

Python ≥ 3,2 <3,8

Sie sollten beide @propertyund @functools.lru_cacheDekorateure verwenden:

import functools
class MyClass:
    @property
    @functools.lru_cache()
    def foo(self):
        print("long calculation here")
        return 21 * 2

Diese Antwort enthält detailliertere Beispiele und erwähnt auch einen Backport für frühere Python-Versionen.

Python <3.2

Das Python-Wiki verfügt über einen zwischengespeicherten Property Decorator (MIT-lizenziert), der folgendermaßen verwendet werden kann:

import random
# the class containing the property must be a new-style class
class MyClass(object):
   # create property whose value is cached for ten minutes
   @cached_property(ttl=600)
   def randint(self):
       # will only be evaluated every 10 min. at maximum.
       return random.randint(0, 100)

Oder jede Implementierung, die in den anderen Antworten erwähnt wird und Ihren Anforderungen entspricht.
Oder der oben erwähnte Backport.

Früher habe ich das so gemacht, wie es der Knabber vorschlug, aber irgendwann hatte ich die kleinen Reinigungsschritte satt.

Also habe ich meinen eigenen Deskriptor erstellt:

class cached_property(object):
    """
    Descriptor (non-data) for building an attribute on-demand on first use.
    """
    def __init__(self, factory):
        """
        <factory> is called such: factory(instance) to build the attribute.
        """
        self._attr_name = factory.__name__
        self._factory = factory

    def __get__(self, instance, owner):
        # Build the attribute.
        attr = self._factory(instance)

        # Cache the value; hide ourselves.
        setattr(instance, self._attr_name, attr)

        return attr

So würden Sie es verwenden:

class Spam(object):

    @cached_property
    def eggs(self):
        print 'long calculation here'
        return 6*2

s = Spam()
s.eggs      # Calculates the value.
s.eggs      # Uses cached value.

Der übliche Weg wäre, das Attribut zu einer Eigenschaft zu machen und den Wert bei der ersten Berechnung zu speichern

import time

class Foo(object):
    def __init__(self):
        self._bar = None

    @property
    def bar(self):
        if self._bar is None:
            print "starting long calculation"
            time.sleep(5)
            self._bar = 2*2
            print "finished long caclulation"
        return self._bar

foo=Foo()
print "Accessing foo.bar"
print foo.bar
print "Accessing foo.bar"
print foo.bar

Python 3.8 enthält den functools.cached_propertyDekorator.

Transformieren Sie eine Methode einer Klasse in eine Eigenschaft, deren Wert einmal berechnet und dann als normales Attribut für die Lebensdauer der Instanz zwischengespeichert wird. Ähnlich wie property()beim Hinzufügen von Caching. Nützlich für teure berechnete Eigenschaften von Instanzen, die ansonsten effektiv unveränderlich sind.

Dieses Beispiel stammt direkt aus den Dokumenten:

from functools import cached_property

class DataSet:
    def __init__(self, sequence_of_numbers):
        self._data = sequence_of_numbers

    @cached_property
    def stdev(self):
        return statistics.stdev(self._data)

    @cached_property
    def variance(self):
        return statistics.variance(self._data)

Die Einschränkung besteht darin, dass das Objekt mit der Eigenschaft, die zwischengespeichert werden soll, ein __dict__Attribut haben muss , das eine veränderbare Zuordnung ist und Klassen mit ausschließt, __slots__sofern dies nicht __dict__in definiert ist __slots__.

class MemoizeTest:

      _cache = {}
      def __init__(self, a):
          if a in MemoizeTest._cache:
              self.a = MemoizeTest._cache[a]
          else:
              self.a = a**5000
              MemoizeTest._cache.update({a:self.a})

Sie könnten versuchen, sich mit Memoisierung zu befassen. Wenn Sie einer Funktion dieselben Argumente übergeben, wird das zwischengespeicherte Ergebnis zurückgegeben. Weitere Informationen zur Implementierung in Python finden Sie hier .

Abhängig davon, wie Ihr Code eingerichtet ist (Sie sagen, dass er nicht von allen Instanzen benötigt wird), können Sie auch versuchen, ein Fliegengewichtsmuster oder ein verzögertes Laden zu verwenden.

Das dickensPaket (nicht meine) Angebote cachedproperty, classpropertyund cachedclasspropertyDekorateure.

So speichern Sie eine Klasseneigenschaft zwischen :

from descriptors import cachedclassproperty

class MyClass:
    @cachedclassproperty
    def approx_pi(cls):
        return 22 / 7

Der einfachste Weg, dies zu tun, wäre wahrscheinlich, einfach eine Methode zu schreiben (anstatt ein Attribut zu verwenden), die das Attribut umschließt (Getter-Methode). Beim ersten Aufruf berechnet, speichert und gibt diese Methode den Wert zurück. später wird nur der gespeicherte Wert zurückgegeben.

Mit Python 2, aber nicht mit Python 3, mache ich Folgendes. Dies ist ungefähr so ​​effizient wie möglich:

class X:
    @property
    def foo(self):
        r = 33
        self.foo = r
        return r

Erläuterung: Grundsätzlich überlade ich nur eine Eigenschaftsmethode mit dem berechneten Wert. Nach dem ersten Zugriff auf die Eigenschaft (für diese Instanz) ist foosie keine Eigenschaft mehr und wird zu einem Instanzattribut. Der Vorteil dieses Ansatzes besteht darin, dass ein Cache-Treffer so billig wie möglich self.__dict__ist, da er als Cache verwendet wird, und dass kein Instanz-Overhead entsteht, wenn die Eigenschaft nicht verwendet wird.

Dieser Ansatz funktioniert nicht mit Python 3.