functools

Des outils pour travailler avec les fonctions : mémorisation des résultats (lru_cache), appels partiels (partial) et réduction de collections (reduce).

Sur cette page

Exemple

#
Python
from functools import lru_cache

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

print(fib(10))
print(fib(80))
print(fib.cache_info())
Résultatrésultat enregistré, vous pouvez le vérifier
55
23416728348467685
CacheInfo(hits=79, misses=81, maxsize=None, currsize=81)

Sans @lru_cache, le calcul de fib(80) exigerait plusieurs dizaines de millions de milliards d’appels de fonction, soit des dizaines d’années de travail même pour un ordinateur rapide. Avec le cache, chaque valeur n’est calculée qu’une seule fois.

Définition et utilisation

#

Le module functools contient des outils pour travailler avec les fonctions : ceux qui prennent des fonctions en arguments, les enveloppent ou en créent de nouvelles. On en utilise le plus souvent le décorateur @lru_cache, les fonctions partial() et reduce() et le décorateur @wraps, indispensable pour écrire ses propres décorateurs.

@lru_cache mémorise les résultats d’une fonction pour les arguments déjà utilisés. À l’appel suivant avec les mêmes arguments, le résultat est renvoyé tout de suite, sans nouveau calcul, ce qui donne une accélération énorme pour les calculs coûteux et la récursion. Les arguments doivent être hachables (nombres, chaînes, tuples), et le résultat ne doit dépendre que d’eux. Les statistiques de succès sont affichées par la méthode cache_info().

partial() crée une nouvelle fonction dont une partie des arguments est fixée, par exemple partial(int, base=2) crée une fonction qui convertit en nombres des chaînes écrites en binaire. reduce() réduit une collection à une seule valeur : elle appelle une fonction à deux arguments d’abord sur les deux premiers éléments, puis sur le résultat et le troisième élément, et ainsi de suite. Pour les sommes et les maximums, sum() et max() sont toutefois plus simples.

Syntaxe

#
Syntaxe
from functools import cache, lru_cache, partial, reduce, wraps

@lru_cache(maxsize=128)
def fonction(arguments):
    ...

nouvelle = partial(fonction, *args, **kwargs)
resultat = reduce(fonction, iterable, initial)

Les fonctions les plus importantes

#
  • @lru_cache

    décorateur

    Mémorise les résultats des arguments utilisés le plus récemment. Le paramètre maxsize (128 par défaut) indique combien de résultats retenir, et None supprime la limite.
  • @cache

    décorateur

    Un équivalent plus simple de lru_cache(maxsize=None) : retient tous les résultats.
  • partial()

    fonction

    Renvoie une nouvelle fonction dont une partie des arguments est fixée : partial(func, *args, **kwargs).
  • reduce()

    fonction

    Réduit une collection à une seule valeur : reduce(func, iterable, initial). Sans initial, une collection vide lève TypeError.
  • @wraps

    décorateur

    Utilisé dans vos propres décorateurs : copie le nom et la docstring de la fonction enveloppée dans le wrapper.
  • @total_ordering

    décorateur de classe

    Complète les comparaisons manquantes à partir de __eq__ et de l’une des méthodes __lt__, __le__, __gt__ ou __ge__.
  • @cached_property

    décorateur de méthode

    Transforme une méthode en attribut calculé une seule fois, à la première lecture.

Plus d’exemples

#
partial() : une fonction aux arguments fixés
Python
from functools import partial

def award(exp, name, reason="exercice"):
    return f"{name} : +{exp} EXP ({reason})"

small = partial(award, 5)
streak = partial(award, 20, reason="série de 7 jours")

print(small("Léa"))
print(streak("Jean"))

from_binary = partial(int, base=2)
print(from_binary("1010"))
Résultatrésultat enregistré, vous pouvez le vérifier
Léa : +5 EXP (exercice)
Jean : +20 EXP (série de 7 jours)
10
reduce() : réduire une collection à une seule valeur
Python
from functools import reduce

scores = [72, 95, 64, 88]
print(reduce(lambda total, s: total + s, scores))
print(reduce(lambda best, s: s if s > best else best, scores))

updates = [{"level": 2}, {"points": 250}, {"level": 3}]
profile = reduce(lambda acc, change: {**acc, **change}, updates, {"name": "Léa"})
print(profile)
print(reduce(lambda a, b: a * b, [], 1))
Résultatrésultat enregistré, vous pouvez le vérifier
319
95
{'name': 'Léa', 'level': 3, 'points': 250}
1
total_ordering : un jeu complet de comparaisons
Python
from functools import total_ordering

@total_ordering
class Level:
    def __init__(self, number):
        self.number = number

    def __eq__(self, other):
        return self.number == other.number

    def __lt__(self, other):
        return self.number < other.number

print(Level(3) >= Level(2), Level(1) <= Level(1), Level(5) > Level(7))
Résultatrésultat enregistré, vous pouvez le vérifier
True True False

Bonnes pratiques

#
  • N’utilisez pas @lru_cache pour des fonctions à effets de bord, par exemple l’écriture dans un fichier, le tirage aléatoire ou la lecture de l’heure. Pour des arguments mémorisés, la fonction ne s’exécutera pas du tout.
  • Les arguments d’une fonction avec cache doivent être hachables. Convertissez les listes en tuples avant l’appel.
  • Au lieu de reduce() pour une somme, un produit ou un maximum, utilisez sum(), math.prod() et max(). Ils sont plus lisibles et plus rapides.

Entrées associées

#

Pratiquer dans les leçons

#

Vous voyez une erreur ou il manque un exemple ? Écrivez-nous.