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.

programmer en python, tutoriel python, graphes en python, Aymeric Duclert