Python Language
Module Functools

partiel

La fonction partial crée une application de fonction partielle à partir d'une autre fonction. Il est utilisé pour lier des valeurs à certains des arguments de la fonction (ou des arguments de mots-clés) et produire un appelable sans les arguments déjà définis.

>>> from functools import partial
>>> unhex = partial(int, base=16)
>>> unhex.__doc__ = 'Convert base16 string to int'
>>> unhex('ca11ab1e')
3390155550

partial() , comme son nom l'indique, permet une évaluation partielle d'une fonction. Regardons l'exemple suivant:

In [2]: from functools import partial

In [3]: def f(a, b, c, x):
   ...:     return 1000*a + 100*b + 10*c + x
   ...: 

In [4]: g = partial(f, 1, 1, 1)

In [5]: print g(2)
1112

Lorsque g est créé, f , qui prend quatre arguments ( a, b, c, x ), est aussi partiellement évalué pour les trois premiers arguments, a, b, c, L'évaluation de f est terminée lorsque g est appelé, g(2) , qui passe le quatrième argument à f .

Une manière de penser à partial est un registre à décalage; en poussant un argument à la fois dans une fonction. partial est utile pour les cas où les données entrent en flux et que nous ne pouvons pas passer plus d'un argument.

total_ordering

Lorsque nous voulons créer une classe ordonnable, nous devons normalement définir les méthodes __eq()__ , __lt__() , __le__() , __gt__() et __ge__() .

Le décorateur total_ordering , appliqué à une classe, autorise la définition de __eq__() et une seule entre __lt__() , __le__() , __gt__() et __ge__() , tout en autorisant toutes les opérations de classement sur la classe.

@total_ordering
class Employee:

    ...

    def __eq__(self, other):
        return ((self.surname, self.name) == (other.surname, other.name))

    def __lt__(self, other):
        return ((self.surname, self.name) < (other.surname, other.name))

Le décorateur utilise une composition des méthodes fournies et des opérations algébriques pour dériver les autres méthodes de comparaison. Par exemple, si nous avons défini __lt__() et __eq()__ et que nous voulons dériver __gt__() , nous pouvons simplement vérifier not __lt__() and not __eq()__ .

Remarque : La fonction total_ordering est uniquement disponible depuis Python 2.7.

réduire

Dans Python 3.x, la fonction de reduce déjà expliquée ici a été supprimée des éléments intégrés et doit maintenant être importée à partir de functools .

from functools import reduce
def factorial(n):
    return reduce(lambda a, b: (a*b), range(1, n+1))

lru_cache

Le décorateur @lru_cache peut être utilisé pour @lru_cache une fonction coûteuse et intensive en calcul avec un cache moins utilisé récemment . Cela permet de mémoriser les appels de fonctions, de sorte que les futurs appels avec les mêmes paramètres puissent revenir instantanément au lieu de devoir être recalculés.

@lru_cache(maxsize=None)  # Boundless cache
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

>>> fibonacci(15)

Dans l'exemple ci-dessus, la valeur de fibonacci(3) n'est calculée qu'une seule fois, alors que si fibonacci n'avait pas de cache LRU, fibonacci(3) aurait été calculé plus de 230 fois. Par conséquent, @lru_cache est particulièrement @lru_cache aux fonctions récursives ou à la programmation dynamique, où une fonction coûteuse peut être appelée plusieurs fois avec les mêmes paramètres exacts.

@lru_cache a deux arguments

• maxsize : nombre d'appels à enregistrer. Lorsque le nombre d'appels uniques dépasse la maxsize , le cache LRU supprime les appels les moins récemment utilisés.
• typed (ajouté en 3.3): Indicateur permettant de déterminer si des arguments équivalents de différents types appartiennent à des enregistrements de cache différents (par exemple, si les arguments 3.0 et 3 sont différents)

Nous pouvons également voir les statistiques du cache:

>>> fib.cache_info()
CacheInfo(hits=13, misses=16, maxsize=None, currsize=16)

REMARQUE : Comme @lru_cache utilise des dictionnaires pour mettre en cache les résultats, tous les paramètres de la fonction doivent être gérables pour que le cache fonctionne.

@lru_cache Python officiels pour @lru_cache . @lru_cache été ajouté en 3.2.

cmp_to_key

Python a changé ses méthodes de tri pour accepter une fonction clé. Ces fonctions prennent une valeur et renvoient une clé utilisée pour trier les tableaux.

Les anciennes fonctions de comparaison utilisaient deux valeurs et renvoyaient -1, 0 ou +1 si le premier argument était petit, égal ou supérieur au second argument, respectivement. Ceci est incompatible avec la nouvelle fonction clé.

C'est là functools.cmp_to_key :

>>> import functools
>>> import locale
>>> sorted(["A", "S", "F", "D"], key=functools.cmp_to_key(locale.strcoll))
['A', 'D', 'F', 'S']

Exemple pris et adapté de la documentation Python Standard Library .