Python Academy · Les

functools: lru_cache en cached_property

Cache dure berekeningen met lru_cache en cached_property.

Les 4 van 413 stappen

functools: lru_cache en cached_property is een gratis Python Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Python Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Python Academy bevat in totaal 4 lessen.

Wat is memoization

Memoization slaat het resultaat van een functieaanroep op in een cache, gekoppeld aan de argumenten. Herhaalde aanroepen met dezelfde argumenten geven het gecachte resultaat direct terug.

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) cachet maximaal maxsize recente resultaten. Stel maxsize=None in voor een cache zonder limiet.

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 is een verkorte schrijfwijze voor lru_cache(maxsize=None) — een cache zonder limiet met een duidelijkere naam.

import functools

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

print(factorial(10))  # 3628800

Cache-informatie en wissen

Gecachte functies bieden .cache_info() (treffers, missers en grootte) en .cache_clear().

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()

Verwijderingsbeleid van LRU

LRU (minst recent gebruikt) verwijdert het element dat het minst recent is geopend wanneer de cache vol is.

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)

Alleen hashbare argumenten

lru_cache vereist dat alle argumenten hashbaar zijn. Lijsten en woordenboeken zijn niet hashbaar; gebruik in plaats daarvan tuples.

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 berekent een eigenschap één keer en cachet het resultaat op de instantie, waarbij de descriptor door de waarde wordt vervangen.

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 versus property

@property berekent de waarde bij elke toegang opnieuw. @cached_property berekent de waarde één keer en slaat het resultaat op 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))

Threadveiligheid van cached_property

cached_property is niet threadveilig. Als meerdere threads er tegelijk toegang toe hebben, kan de berekening meer dan één keer worden uitgevoerd. Gebruik zo nodig een vergrendeling.

import functools, threading

class SafeCache:
    _lock = threading.Lock()

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

cached_property ongeldig maken

Verwijder het instantieattribuut om de cache ongeldig te maken en de berekening bij de volgende toegang af te dwingen.

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 gebruiken

Cache API-antwoorden gedurende een sessie om overbodige netwerkaanroepen te voorkomen. Wis de cache wanneer je actuele gegevens nodig hebt.

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

Korte controle

Welke methode wist alle gecachte resultaten van een functie die met @lru_cache is gedecoreerd?

Beantwoord dit in de interactieve les

Samenvatting

@lru_cache cachet functieresultaten op basis van argumenten, die hashbaar moeten zijn. @cache is een alias zonder limiet. @cached_property cachet de berekening van een eigenschap per instantie. Bekijk de cache met cache_info() en wis deze met cache_clear().

Gratis beginnen

Leer Python met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 76
Lessen: 320

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “functools: lru_cache en cached_property” gratis?

Ja — de volledige tekst van “functools: lru_cache en cached_property” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Python Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Python Academy bevat in totaal 4 lessen.

Wat leer ik in “functools: lru_cache en cached_property”?

Cache dure berekeningen met lru_cache en cached_property. Je oefent met Python Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Python Academy te beginnen?

Ervaring vooraf is niet nodig. Python Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “functools: lru_cache en cached_property”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Python Academy?

Ja. Elke les over Python Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

itertools: oneindige en eindige iterators
itertools: combinatoriek
functools: partial en reduce
functools: lru_cache en cached_property

← Terug naar Python Academy