map() vs list comprehension
map() appelle une fonction pour chaque élément et renvoie un itérateur paresseux ; une liste en compréhension construit la liste immédiatement et peut filtrer avec if.
Comparaison point par point
#Ce qu’elle renvoie
- map()
- Un itérateur (paresseux)
- Wyrażenia listowe
- Une liste (immédiatement, en mémoire)
Nécessite une fonction
- map()
- Oui, une fonction ou une lambda existante
- Wyrażenia listowe
- Non, vous écrivez l’expression directement
Filtrage des éléments
- map()
- Nécessite un
filter()séparé - Wyrażenia listowe
ifintégré à la fin
Le résultat ne peut être parcouru qu’une fois
- map()
- Oui
- Wyrażenia listowe
- Non, c’est une liste ordinaire
Lisibilité pour des transformations simples
- map()
- Plus faible, une fonction ou une lambda supplémentaire est nécessaire
- Wyrażenia listowe
- Plus élevée, une seule ligne
Usage typique
- map()
- Fonction déjà prête, traitement paresseux
- Wyrażenia listowe
- Transformations courtes, transformations avec condition
Exemple
#values = ["12", "7", "30"]
doubled_map = list(map(lambda v: int(v) * 2, values))
doubled_comprehension = [int(v) * 2 for v in values]
print(doubled_map)
print(doubled_comprehension)
print(doubled_map == doubled_comprehension)Définition et utilisation
#Les deux transforment une collection élément par élément, donnant une nouvelle séquence de valeurs de même longueur, tant que vous ne filtrez pas. Dans les deux cas, la collection d’origine ne change pas.
Elles diffèrent par leur syntaxe et par le moment où les résultats apparaissent. map(function, collection) a besoin d’une fonction ou d’une lambda déjà existante et renvoie un itérateur : les valeurs sont produites paresseusement, seulement quand vous les demandez, par ex. dans list() ou une boucle for, et on ne peut le parcourir qu’une seule fois. Une liste en compréhension ([expression for x in collection]) crée immédiatement toute la liste en mémoire, et une condition if optionnelle à la fin filtre les éléments sans appel supplémentaire à filter().
Quand vous avez déjà une fonction nommée et besoin d’un itérateur paresseux, par ex. pour le combiner avec d’autres itérateurs, map() peut être pratique. Dans la plupart du code, une liste en compréhension est plus lisible, surtout quand la transformation est courte ou qu’il faut ajouter une condition. La version avec des parenthèses, c’est-à-dire une expression génératrice, offre la même paresse que map().
Syntaxe
#map(function, iterable)
[expression for element in iterable if condition]Plus d’exemples
#numbers = [1, 2, 3]
result = map(lambda n: n * n, numbers)
print(type(result).__name__)
print(list(result))
print(list(result))L’itérateur s’épuise après un premier parcours. La seconde tentative de conversion en liste donne déjà une liste vide.
scores = [45, 82, 67, 91, 30]
passed_comprehension = [s for s in scores if s >= 60]
passed_map_filter = list(filter(lambda s: s >= 60, map(lambda s: s, scores)))
print(passed_comprehension)
print(passed_comprehension == passed_map_filter)Bonnes pratiques
#- Vous avez seulement besoin d’une transformation sans condition ? Les deux options fonctionnent, mais une liste en compréhension se lit généralement plus facilement en Python.
- Quand il faut filtrer et transformer en même temps, une liste en compréhension avec
ifest plus courte que la combinaison demap()etfilter(). - Si les données sont très volumineuses et que vous voulez les traiter paresseusement sans créer de liste, utilisez
map()ou une expression génératrice(expression for x in collection).
Entrées associées
#Vous voyez une erreur ou il manque un exemple ? Écrivez-nous.