map(), filter() et reduce () ?
jeudi 14 novembre 2013 à 10:44map(), filter() et reduce() sont des fonctions de traitement d’itérables typiques de la programmation fonctionnelle, qui ont été marquées comme à retirer des builtins pour Python 3. Finalement, seule reduce() sera déplacée dans le module functools pour Python 3.
Les opérations que font ces fonctions sont typiquement quelque chose que l’ont peut faire sans elles, et nous allons les passer en revue pour voir dans quels cas elles sont pertinentes, dans quel cas une alternative est meilleure. L’alternative étant, dans 90% des cas, une liste en intention.
filter()
filter() prend une fonction en paramètre, souvent une lambda, comme ses deux soeurs puisqu’on est dans le paradigme fonctionnel. Elle doit renvoyer True si on garde un élément, et False sinon.
L’usage typique est celui-ci :
ages = range(30) majeurs = filter(lambda x: x > 18, ages) print(majeurs) ## [19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
Typiquement, ce code peut être remplacé par une liste en intention dans le pur style Python :
majeurs = [a for a in ages if a > 18]
Le code est plus court, et fait usage d’une des fonctionalités les plus importantes du langage. On peut en plus ajouter une transformation à a facilement si on le désire, au lieu de devoir coller un map() derrière.
filter() est vraiment la moins utile des 3, et sera une question de style, surtout pour les nostalgiques de Lisp. Je répète souvent que quand on code avec un autre langage, on doit essayer de se tenir au style du nouveau et pas faire un mix avec ses anciennes habitudes. Quand je code en Java, je fais des getter et setter, même si j’ai horreur de ça.
Mon conseil: oubliez filter().
map()
Si filter() est l’équivalent de la partie de droite d’une liste en intention, map() est l’équivalent de la partie de gauche. La fonction passée retourne un résultat qui permet de transformer la liste.
Typiquement :
memes = ["It's over 9000 !", "All your base are belong to us."] print(map(unicode.upper, memes))
Ce qui peut se traduire par :
print(s.upper() for s in memes)
map() est un peu plus utile, dans le sens où sa syntaxe peut être plus concise dans certains cas, comme le casting de types. Par exemple si je reçois une heure sous forme de string :
h, m, s = map(int, '8:19:22'.split(':'))
sera plus court et plus concis, et plus clair que :
h, m, s = (int(i) for i in '8:19:22'.split(':'))
Mais bon, la différence n’est pas non plus incroyable au point d’en faire une fonctionnalitéé clé. Je l’utilise de temps à autre par soucis de brièveté, mais vraiment c’est tout.
reduce()
reduce() est plus tordu. La fonction doit prendre deux paramètres en entrée, et retourner une valeur. Au premier appel, les deux premiers éléments de l’itérable sont passés en paramètres. Ensuite, le résultat de cet appel et l’élément suivant sont passés en paramètre, et ainsi de suite.
Vous n’avez rien pigé ? C’est normal. reduce() est parfaitement cryptique. Voici ce que ça donne en pratique :
def afficher(a, b): print("Entrée :", a, b) print("Sortie :", a + b) return a + b res = reduce(afficher, range(10)) print("Résultat final", res) ## Entrée : 0 1 ## Sortie : 1 ## Entrée : 1 2 ## Sortie : 3 ## Entrée : 3 3 ## Sortie : 6 ## Entrée : 6 4 ## Sortie : 10 ## Entrée : 10 5 ## Sortie : 15 ## Entrée : 15 6 ## Sortie : 21 ## Entrée : 21 7 ## Sortie : 28 ## Entrée : 28 8 ## Sortie : 36 ## Entrée : 36 9 ## Sortie : 45 ## Résultat final 45
Vous allez me dire, à quoi ça sert ? Et bien par exemple à appliquer des opérateurs commutatifs, ici nous l’avons fait avec +, nous avons fait la somme de tous les éléments retournés par range(10). La preuve :
print(sum(range(10))) ## 45
Il n’y a pas, en Python, de fonction équivalent à sum() pour la multiplication. Donc on ferait :
print(reduce(lambda a, b: a * b, range(1, 11))) ## 3628800
Ce qui multiplie tous les éléments entre eux. Comme l’ordre dans lequel les éléments sont multipliés n’a pas d’important (d’où le ‘commutatif’), ça fonctionne.
reduce() peut prendre un troisième paramètre, initial, qui sera la valeur passée en premier au premier appel de la fonction. Cela permet de travailler sur des calculs en cascade qui ne fonctionneraient sinon pas. Revenons à notre exemple de temps :
temps = map(int, '8:19:22'.split(':')) print(reduce(lambda a, b: a * 60 + b, temps, 0)) ## 29962
Ce qui peut se traduire par :
h, m, s = map(int, '8:19:22'.split(':')) print(h * 3600 + m * 60 + s) ## 29962
Bien sûr, cette conversion ne fonctionnerait pas si le calcul était sur un itérable plus long. Mais une version itérative est facile à faire :
res = 0 for i in map(int, '8:19:22'.split(':')): res = res * 60 + i print(res) ## 29962
Maintenant, autant les deux dernières versions sont faciles à comprendre, autant la première prend quelques secondes. Et c’est la raison pour laquelle reduce() a été retirée des builtins, pour encourager l’usage des alternatives. En effet, cette fonction donne toujours un résultat très peu lisible. Je cite et approuve Guido là dessus:
C’est en fait celle que je déteste le plus, car, à part pour quelques exemples impliquant + ou *, presque chaque fois que je vois un appel à reduce() avec une fonction non-triviale passée en argument, j’ai besoin de prendre un crayon et un papier pour faire le diagramme de ce qui est effectivement entrée dans la fonction avant que je comprenne ce qu’est supposé faire reduce(). Donc à mes yeux, l’application de reduce() est plutôt limitée à des opérateurs associatifs, et dans d’autres cas il est mieux d’écrire une boucle d’accumulation explicitement.
Graissage maison.
Bref, reduce() est dur à lire, et une boucle ne l’est pas. Écrivez 3 lignes de plus, ça ne va pas vous tuer. Relire votre one-liner dans un mois par contre…
Cette fonction a été beaucoup utilisée avec les opérateurs or et and pour savoir si tous les éléments étaient vrais au moins un élément vrai dans une liste :
tout_est_vrai = [1, 1, 1, 1] certains_sont_vrais = [1, 0, 1, 0] tout_est_faux = [0, 0, 0, 0] # Retourne True si tout est vrai print(bool(reduce(lambda a, b: a and b, tout_est_vrai))) ## True print(bool(reduce(lambda a, b: a and b, certains_sont_vrais))) ## False print(bool(reduce(lambda a, b: a and b, tout_est_faux))) ## False # Retourne True si au moins un élément est vrai print(bool(reduce(lambda a, b: a or b, tout_est_vrai))) ## True print(bool(reduce(lambda a, b: a or b, certains_sont_vrais))) ## True print(bool(reduce(lambda a, b: a or b, tout_est_faux))) ## False
Mais aujourd’hui, c’est parfaitement inutile puisque nous avons les fonctions built-in all() et any(), qui font ça en plus court et plus rapide :
# Retourne True si tout est vrai print(all(tout_est_vrai)) ## True print(all(certains_sont_vrais)) ## False print(all(tout_est_faux)) ## False # Retourne True si au moins un élément est vrai print(any(tout_est_vrai)) ## True print(any(certains_sont_vrais)) ## True print(any(tout_est_faux)) ## False
Petite astuce finale
Souvenez-vous également que les fonctions Python peuvent être déclarées n’importe où à la volée, même dans une autre fonction, une classe, une méthode, un context manager, etc. Or une fonction peut retourner un générateur grâce à yield, ce qui vous permet de déclarer des gros bouts de logique, et de les plugger dans votre process itérative a posteriori :
def traitement_complexe(iterable): for x in iterable: if x not in (1, 3, 7) and x % 2 != 0: if x + x < 13 : yield x else: yield x - 2 print("-".join(map(str, traitement_complexe(range(20))))) ## 5-7-9-11-13-15-17
