0Pricing
Python Academy · Leçon

functools : lru_cache et cached_property

Mettez en cache les calculs coûteux avec lru_cache et cached_property.

functools : lru_cache et cached_property est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Python Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Python Academy comprend 4 leçons au total.

Qu’est-ce que la mémorisation ?

La mémorisation met en cache le résultat d’un appel de fonction en l’associant à ses arguments. Les appels répétés avec les mêmes arguments renvoient instantanément le résultat mis en cache.

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) met en cache jusqu’à maxsize résultats récents. Définissez maxsize=None pour obtenir un cache sans limite.

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 est un raccourci pour lru_cache(maxsize=None) : un cache sans limite dont le nom est plus simple.

import functools

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

print(factorial(10))  # 3628800

Informations du cache et suppression

Les fonctions mises en cache exposent .cache_info() (accès réussis, échecs et taille) et .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()

Politique d’éviction LRU

LRU (moins récemment utilisé) évince l’élément auquel on a accédé le moins récemment lorsque le cache est plein.

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)

Uniquement des arguments hachables

lru_cache exige que tous les arguments soient hachables. Les listes et les dictionnaires ne le sont pas ; utilisez plutôt des 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 calcule une propriété une fois et met le résultat en cache sur l’instance, en remplaçant le descripteur par la valeur.

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

@property recalcule la valeur à chaque accès. @cached_property effectue le calcul une fois et stocke le résultat dans 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))

Sécurité des fils d’exécution avec cached_property

cached_property n’est pas sécurisé pour les fils d’exécution. Si plusieurs fils d’exécution y accèdent simultanément, le calcul peut être effectué plusieurs fois. Utilisez un lock si nécessaire.

import functools, threading

class SafeCache:
    _lock = threading.Lock()

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

Invalider cached_property

Supprimez l’attribut de l’instance pour invalider le cache et forcer un nouveau calcul lors de l’accès suivant.

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

Utiliser lru_cache comme cache d’API

Mettez en cache les réponses d’API pendant une session afin d’éviter les appels réseau redondants. Videz le cache lorsque vous avez besoin de données à jour.

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

Vérification rapide

Quelle méthode vide tous les résultats mis en cache d’une fonction décorée avec @lru_cache ?

Récapitulatif

@lru_cache met en cache les résultats d’une fonction en fonction de ses arguments, qui doivent être hachables. @cache est un alias sans limite. @cached_property met en cache le calcul d’une propriété pour chaque instance. Inspectez le cache avec cache_info() et réinitialisez-le avec cache_clear().

Questions Fréquemment Posées

La leçon « functools : lru_cache et cached_property » est-elle gratuite ?

Oui — le texte complet de « functools : lru_cache et cached_property » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Python Academy, passe à CoddyKit PRO. Le cours Python Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « functools : lru_cache et cached_property » ?

Mettez en cache les calculs coûteux avec lru_cache et cached_property. Tu pratiques Python Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Python Academy ?

Aucune expérience préalable n'est requise. Python Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « functools : lru_cache et cached_property » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Python Academy ?

Oui. Chaque leçon Python Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. itertools : itérateurs infinis et finis
  2. itertools : combinatoire
  3. functools : partial et reduce
  4. functools : lru_cache et cached_property
← Retour à Python Academy