Python Academy · Lektion

functools: lru_cache und cached_property

Puffern Sie aufwendige Berechnungen mit lru_cache und cached_property.

functools: lru_cache und cached_property ist eine kostenlose Python Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Python Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist Memoization?

Memoization speichert das Ergebnis eines Funktionsaufrufs, das über seine Argumente bestimmt wird. Wiederholte Aufrufe mit denselben Argumenten geben sofort das zwischengespeicherte Ergebnis zurück.

def slow_fib(n):
    if n < 2: return n
    return slow_fib(n-1) + slow_fib(n-2)

# slow_fib(35) makes ~29 million calls
# With caching it makes only 35

@lru_cache

@functools.lru_cache(maxsize=128) speichert bis zu maxsize kürzlich verwendete Ergebnisse. Setzen Sie maxsize=None für einen unbegrenzten Cache.

import functools

@functools.lru_cache(maxsize=None)
def fib(n):
    if n < 2: return n
    return fib(n-1) + fib(n-2)

print(fib(50))  # instant

@cache — Python 3.9+

functools.cache ist eine Kurzform für lru_cache(maxsize=None) – ein unbegrenzter Cache mit einem klareren Namen.

import functools

@functools.cache
def factorial(n):
    return n * factorial(n-1) if n else 1

print(factorial(10))  # 3628800

Cache-Informationen und Leeren

Funktionen mit Cache stellen .cache_info() (Treffer, Fehlversuche, Größe) und .cache_clear() bereit.

import functools

@functools.lru_cache(maxsize=100)
def square(n):
    return n * n

for i in range(5): square(i % 3)
print(square.cache_info())
# CacheInfo(hits=2, misses=3, maxsize=100, currsize=3)
square.cache_clear()

LRU-Verdrängungsstrategie

LRU (Least Recently Used) verdrängt bei einem vollen Cache das Element, auf das am längsten nicht zugegriffen wurde.

import functools

@functools.lru_cache(maxsize=3)
def compute(n):
    print(f"computing {n}")
    return n**2

for x in [1,2,3,4,1]:   # 4 evicts 1 (LRU), then 1 re-computes
    compute(x)

Nur hashbare Argumente

lru_cache erfordert, dass alle Argumente hashbar sind. Listen und Dictionaries sind nicht hashbar; verwenden Sie stattdessen Tupel.

import functools

@functools.lru_cache(maxsize=None)
def sum_tuple(t):  # tuple is hashable
    return sum(t)

print(sum_tuple((1,2,3)))  # 6
# sum_tuple([1,2,3])  # TypeError

@cached_property

functools.cached_property berechnet eine Property einmal und speichert das Ergebnis in der Instanz, wobei der Deskriptor durch den Wert ersetzt wird.

import functools

class Circle:
    def __init__(self, r):
        self.r = r

    @functools.cached_property
    def area(self):
        import math
        print("computing...")
        return math.pi * self.r ** 2

c = Circle(5)
print(c.area)   # computing...  78.53...
print(c.area)   # 78.53... (cached, no print)

cached_property vs property

@property berechnet den Wert bei jedem Zugriff neu. @cached_property berechnet ihn einmal und speichert das Ergebnis in instance.__dict__.

import functools

class Expensive:
    @property
    def always(self):    # runs every access
        return sum(range(1_000_000))

    @functools.cached_property
    def once(self):      # runs only first access
        return sum(range(1_000_000))

Thread-Sicherheit von cached_property

cached_property ist nicht threadsicher. Wenn mehrere Threads gleichzeitig darauf zugreifen, kann die Berechnung mehr als einmal ausgeführt werden. Verwenden Sie bei Bedarf ein Lock.

import functools, threading

class SafeCache:
    _lock = threading.Lock()

    @functools.cached_property
    def data(self):
        with self._lock:
            return expensive_computation()

cached_property invalidieren

Löschen Sie das Instanzattribut, um den Cache zu invalidieren und beim nächsten Zugriff eine Neuberechnung zu erzwingen.

import functools

class Report:
    @functools.cached_property
    def summary(self):
        return compute_summary()

r = Report()
_ = r.summary      # computed
del r.summary      # invalidate
_ = r.summary      # recomputed

lru_cache als API-Cache verwenden

Speichern Sie API-Antworten für eine Sitzung zwischen, um redundante Netzwerkaufrufe zu vermeiden. Leeren Sie den Cache, wenn aktuelle Daten benötigt werden.

import functools, urllib.request, json

@functools.lru_cache(maxsize=32)
def get_user(user_id):
    url = f"https://api.example.com/users/{user_id}"
    with urllib.request.urlopen(url) as r:
        return json.loads(r.read())

user = get_user(42)   # network call
user = get_user(42)   # cached

Schnelltest

Welche Methode leert alle zwischengespeicherten Ergebnisse einer mit @lru_cache dekorierten Funktion?

Zusammenfassung

@lru_cache speichert Funktionsergebnisse anhand der Argumente (diese müssen hashbar sein). @cache ist ein Alias für einen unbegrenzten Cache. @cached_property speichert die Berechnung einer Property pro Instanz. Untersuchen Sie den Cache mit cache_info() und setzen Sie ihn mit cache_clear() zurück.

Häufig gestellte Fragen

Ist die Lektion „functools: lru_cache und cached_property“ kostenlos?

Ja — der vollständige Text von „functools: lru_cache und cached_property“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Python Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „functools: lru_cache und cached_property“?

Puffern Sie aufwendige Berechnungen mit lru_cache und cached_property. Du übst Python Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Python Academy zu starten?

Keine Vorkenntnisse erforderlich. Python Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „functools: lru_cache und cached_property“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Python Academy-Lektion Code schreiben und ausführen?

Ja. Jede Python Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

itertools: Unendliche und endliche Iteratoren
itertools: Kombinatorik
functools: partial und reduce
functools: lru_cache und cached_property

← Zurück zu Python Academy