Mis a jour le 2025-04-14, 12:10

module functools

reduce : appelle de manière cumulée une fonction sur une séquence (comme une somme cumulée : functools.reduce(f, [1, 2, 4, 7]) est équivalent à f(f(f(1, 2), 4), 7).
lru_cache :
  • decorator qui cache le résultat de l'appel d'une fonction pour des paramètres donnés (au prochain appel avec les mêmes paramètres, donne le résultat sans réexecuter la fonction
  • @functools.lru_cache(maxsize = 128)
    def f(x):
        print('called')
        return x ** 2
        
  • maxsize est le nombre de paramètres pour lesquels cacher le résultat (défaut est de 128). Le cache s'applique aux paramètres les plus récents (lru = least recently used)
partial :
  • fonction qui prend une fonction et le début de ses arguments et renvoie ue fonction qui prend la fin des arguments de la fonction initiale
  • def f(x, y, z):
        return y * (z - x)
    
    g = functools.partial(f, 2, 3)
        
    la fonction renvoyée g ne prend plus qu'un seul argument z et renvoie le résultat de f(2, 3, z)
wraps : permet d'éviter le problème des meta data avec les decorators :
  • def myDeco(g):
        @functools.wraps(g)
        def h(x, y):
            """doc from from h"""
            return g(x, 2 * y)
    
        return h
    
    @myDeco
    def f(x, y):
        """doc from f."""
        return x + y
        
  • sans le wraps, quand on fait f.__name__ ou f.__doc__, on obtient comme nom h et la doc de h. L'appel à wraps permet d'avoir comme nom f et comme doc, celle de f.

Copyright python-simple.com
programmer en python, tutoriel python, graphes en python, Aymeric Duclert