Fonction map() Python : Transformer des Itérables avec des Exemples

Name

Soren Atelier

Updated on 10/02/2026

Transformer chaque élément d'une liste est l'une des opérations les plus courantes en programmation Python. Vous avez une liste de chaînes à convertir en entiers. Une colonne de prix à arrondir. Un ensemble de noms de fichiers à mettre en minuscules. L'instinct est d'écrire une boucle for, créer une liste vide, ajouter chaque résultat et retourner la liste. Ça fonctionne, mais c'est verbeux, sujet aux erreurs, et enfouit la logique de transformation dans du code standard.

La fonction intégrée map() de Python élimine ce code standard. Elle prend une fonction et un ou plusieurs itérables, applique la fonction à chaque élément et retourne un itérateur de résultats. Une ligne remplace cinq. Le code se lit comme une description de ce que vous voulez, pas comment le faire.

Ce guide couvre chaque aspect pratique de la fonction map de Python : la syntaxe de base, la combinaison de map avec lambda et les fonctions intégrées, le travail avec plusieurs itérables, les comparaisons de performance avec les list comprehensions, et les modèles de traitement de données du monde réel que vous utiliserez en code de production.

Syntaxe de Base de map()

La signature de la fonction map() est simple :

map(function, iterable, *iterables)

• function -- un callable qui accepte un argument (ou plus, si vous passez plusieurs itérables).
• iterable -- la séquence dont les éléments seront passés à function.
• *iterables -- itérables supplémentaires optionnels. Quand fournis, function doit accepter autant d'arguments.

map() retourne un objet map, qui est un itérateur paresseux. Il ne calcule pas tous les résultats immédiatement. Au lieu de cela, il produit les valeurs une à la fois au fur et à mesure que vous les consommez.

Voici l'exemple le plus simple possible :

numbers = [1, 2, 3, 4, 5]
squared = map(lambda x: x ** 2, numbers)
 
print(squared)
# <map object at 0x...>
 
print(list(squared))
# [1, 4, 9, 16, 25]

L'objet map n'affiche pas les résultats directement. Vous le convertissez en liste, tuple ou autre collection, ou vous itérez dessus dans une boucle.

map() avec les Fonctions Intégrées

L'une des utilisations les plus propres de map() est de le combiner avec les fonctions intégrées de Python. Pas besoin de lambda -- passez simplement le nom de la fonction directement.

Conversion de Types avec int, float, str

# Convertir des chaînes en entiers
string_numbers = ["10", "20", "30", "40"]
integers = list(map(int, string_numbers))
print(integers)
# [10, 20, 30, 40]
 
# Convertir des entiers en flottants
values = [1, 2, 3, 4]
floats = list(map(float, values))
print(floats)
# [1.0, 2.0, 3.0, 4.0]
 
# Convertir des nombres en chaînes
ids = [101, 102, 103]
string_ids = list(map(str, ids))
print(string_ids)
# ['101', '102', '103']

Obtenir les Longueurs avec len

words = ["Python", "map", "function", "tutorial"]
lengths = list(map(len, words))
print(lengths)
# [6, 3, 8, 8]

Supprimer les Espaces avec str.strip

raw_inputs = ["  hello  ", "  world ", " python  "]
cleaned = list(map(str.strip, raw_inputs))
print(cleaned)
# ['hello', 'world', 'python']

Autres Combinaisons Utiles avec les Fonctions Intégrées

# abs() pour les valeurs absolues
numbers = [-5, 3, -1, 7, -2]
absolutes = list(map(abs, numbers))
print(absolutes)
# [5, 3, 1, 7, 2]
 
# round() pour arrondir (forme à un argument)
prices = [19.995, 4.123, 99.876]
rounded = list(map(round, prices))
print(rounded)
# [20, 4, 100]
 
# bool() pour la véracité
values = [0, 1, "", "hello", None, [], [1]]
truthy = list(map(bool, values))
print(truthy)
# [False, True, False, True, False, False, True]

Quand une fonction intégrée fait déjà ce dont vous avez besoin, passez-la directement à map(). Il n'y a aucune raison de l'envelopper dans un lambda.

map() avec les Fonctions Lambda

Les fonctions lambda débloquent toute la puissance de map(). Elles vous permettent de définir des transformations en ligne sans créer une fonction nommée.

# Élever au carré chaque nombre
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x ** 2, numbers))
print(squared)
# [1, 4, 9, 16, 25]
 
# Celsius en Fahrenheit
celsius = [0, 20, 37, 100]
fahrenheit = list(map(lambda c: round(c * 9/5 + 32, 1), celsius))
print(fahrenheit)
# [32.0, 68.0, 98.6, 212.0]
 
# Extraire le domaine des adresses e-mail
emails = ["alice@gmail.com", "bob@company.org", "carol@university.edu"]
domains = list(map(lambda e: e.split("@")[1], emails))
print(domains)
# ['gmail.com', 'company.org', 'university.edu']
 
# Formater les noms
names = ["alice smith", "bob jones", "carol white"]
formatted = list(map(lambda n: n.title(), names))
print(formatted)
# ['Alice Smith', 'Bob Jones', 'Carol White']

Le modèle est cohérent : map(lambda x: transform(x), iterable). Gardez le corps du lambda comme une expression unique et claire. Si la transformation nécessite plusieurs étapes, utilisez plutôt une fonction nommée.

map() avec Plusieurs Itérables

Quand vous passez plusieurs itérables, map() appelle la fonction avec un élément de chaque itérable en parallèle. La fonction doit accepter autant d'arguments qu'il y a d'itérables. L'itération s'arrête quand le plus court itérable est épuisé.

# Additionner les éléments correspondants de deux listes
list_a = [1, 2, 3, 4]
list_b = [10, 20, 30, 40]
sums = list(map(lambda a, b: a + b, list_a, list_b))
print(sums)
# [11, 22, 33, 44]
 
# Calculer les scores pondérés
scores = [85, 92, 78, 95]
weights = [0.3, 0.3, 0.2, 0.2]
weighted = list(map(lambda s, w: round(s * w, 1), scores, weights))
print(weighted)
# [25.5, 27.6, 15.6, 19.0]
 
# Combiner prénoms et noms de famille
first_names = ["Ada", "Grace", "Alan"]
last_names = ["Lovelace", "Hopper", "Turing"]
full_names = list(map(lambda f, l: f"{f} {l}", first_names, last_names))
print(full_names)
# ['Ada Lovelace', 'Grace Hopper', 'Alan Turing']

Trois Itérables ou Plus

# Calculer le volume à partir de trois listes de dimensions
lengths = [2, 3, 4]
widths = [5, 6, 7]
heights = [8, 9, 10]
 
volumes = list(map(lambda l, w, h: l * w * h, lengths, widths, heights))
print(volumes)
# [80, 162, 280]

Gestion des Longueurs Inégales

map() s'arrête au plus court itérable. Pas d'erreur, pas de remplissage -- il s'arrête simplement :

a = [1, 2, 3, 4, 5]
b = [10, 20, 30]
result = list(map(lambda x, y: x + y, a, b))
print(result)
# [11, 22, 33]
# Les éléments 4 et 5 de 'a' sont silencieusement ignorés

Si vous devez gérer les longueurs inégales explicitement, utilisez itertools.zip_longest :

from itertools import zip_longest
 
a = [1, 2, 3, 4, 5]
b = [10, 20, 30]
result = list(map(lambda pair: pair[0] + (pair[1] or 0), zip_longest(a, b, fillvalue=0)))
print(result)
# [11, 22, 33, 4, 5]

map() vs List Comprehension

C'est la comparaison la plus importante. Tant map() que les list comprehensions transforment des séquences, mais elles ont des forces différentes.

Benchmark de Performance

import timeit
 
data = list(range(100_000))
 
# map avec fonction intégrée
time_map_builtin = timeit.timeit(
    'list(map(str, data))',
    globals={'data': data},
    number=100
)
 
# List comprehension avec fonction intégrée
time_comp_builtin = timeit.timeit(
    '[str(x) for x in data]',
    globals={'data': data},
    number=100
)
 
# map avec lambda
time_map_lambda = timeit.timeit(
    'list(map(lambda x: x * 2, data))',
    globals={'data': data},
    number=100
)
 
# List comprehension équivalente
time_comp_expr = timeit.timeit(
    '[x * 2 for x in data]',
    globals={'data': data},
    number=100
)
 
print(f"map + intégrée :    {time_map_builtin:.4f}s")
print(f"comprehension :     {time_comp_builtin:.4f}s")
print(f"map + lambda :      {time_map_lambda:.4f}s")
print(f"comprehension :     {time_comp_expr:.4f}s")
# Résultats typiques :
# map + intégrée :    ~0.85s (plus rapide)
# comprehension :     ~1.05s
# map + lambda :      ~0.95s
# comprehension :     ~0.80s (plus rapide)

L'idée clé : map() avec une fonction intégrée (comme int, str, float) est plus rapide car il évite de créer un appel de fonction niveau Python à chaque itération. Mais map() avec un lambda est à peu près la même vitesse que -- ou légèrement plus lent que -- une list comprehension, car les deux impliquent un appel de fonction niveau Python par élément.

map() vs Expression Génératrice

Si vous n'avez pas besoin de la liste complète de résultats en mémoire, tant map() que les expressions génératrices fournissent une évaluation paresseuse :

# Objet map - paresseux
mapped = map(lambda x: x ** 2, range(1_000_000))
 
# Expression génératrice - paresseuse
generated = (x ** 2 for x in range(1_000_000))
 
# Les deux ne consomment de la mémoire que lors de l'itération
for value in mapped:
    if value > 100:
        break

La différence est stylistique. Les expressions génératrices se lisent plus naturellement pour la plupart des développeurs Python et supportent le filtrage avec des clauses if. Utilisez map() quand vous avez déjà une fonction nommée à appliquer ; utilisez une expression génératrice sinon.

# map est propre quand vous avez une fonction nommée
import math
roots = map(math.sqrt, range(10))
 
# Le générateur est propre pour les expressions
roots = (x ** 0.5 for x in range(10))

Convertir des Objets map en list, tuple et set

L'objet map est un itérateur. Pour matérialiser les résultats, convertissez-le explicitement :

numbers = [1, 2, 3, 2, 4, 3, 5]
 
# En liste (préserve l'ordre, autorise les doublons)
as_list = list(map(lambda x: x * 10, numbers))
print(as_list)
# [10, 20, 30, 20, 40, 30, 50]
 
# En tuple (séquence immuable)
as_tuple = tuple(map(lambda x: x * 10, numbers))
print(as_tuple)
# (10, 20, 30, 20, 40, 30, 50)
 
# En set (supprime les doublons, non ordonné)
as_set = set(map(lambda x: x * 10, numbers))
print(as_set)
# {10, 20, 30, 40, 50}

Important : Un objet map ne peut être consommé qu'une seule fois. Après l'avoir converti en liste, itérer à nouveau ne donne rien :

mapped = map(str, [1, 2, 3])
first = list(mapped)
second = list(mapped)
print(first)   # ['1', '2', '3']
print(second)  # [] -- déjà épuisé

map() avec des Fonctions Personnalisées

Pour les transformations trop complexes pour un lambda, définissez une fonction régulière et passez-la à map() :

def parse_temperature(reading):
    """Convertit une chaîne de lecture de température en un dict standardisé."""
    value, unit = float(reading[:-1]), reading[-1]
    if unit == 'F':
        celsius = round((value - 32) * 5 / 9, 1)
    elif unit == 'C':
        celsius = value
    elif unit == 'K':
        celsius = round(value - 273.15, 1)
    else:
        raise ValueError(f"Unité inconnue : {unit}")
    return {"original": reading, "celsius": celsius}
 
readings = ["98.6F", "37.0C", "310.0K", "72.0F"]
parsed = list(map(parse_temperature, readings))
 
for entry in parsed:
    print(f"{entry['original']} -> {entry['celsius']}°C")
# 98.6F -> 37.0°C
# 37.0C -> 37.0°C
# 310.0K -> 36.9°C
# 72.0F -> 22.2°C

Ce modèle garde les appels à map() propres tout en déplaçant la logique complexe dans des fonctions testables et documentées.

def normalize_record(record):
    """Standardise un enregistrement utilisateur pour l'insertion en base de données."""
    return {
        "name": record["name"].strip().title(),
        "email": record["email"].strip().lower(),
        "age": int(record["age"]),
        "active": record.get("active", True),
    }
 
raw_records = [
    {"name": "  alice smith ", "email": "ALICE@Email.COM", "age": "30"},
    {"name": "bob jones", "email": "Bob@Work.ORG  ", "age": "25"},
]
 
clean_records = list(map(normalize_record, raw_records))
for r in clean_records:
    print(r)
# {'name': 'Alice Smith', 'email': 'alice@email.com', 'age': 30, 'active': True}
# {'name': 'Bob Jones', 'email': 'bob@work.org', 'age': 25, 'active': True}

Chaîner les Appels à map()

Comme map() retourne un itérateur, vous pouvez chaîner plusieurs appels à map() pour construire des pipelines de transformation. Chaque étape traite un élément à la fois sans créer de listes intermédiaires :

raw_data = ["  42  ", " 17 ", "  89  ", " 3  "]
 
# Chaîne : supprimer les espaces -> convertir en int -> doubler la valeur
result = map(str.strip, raw_data)
result = map(int, result)
result = map(lambda x: x * 2, result)
 
print(list(result))
# [84, 34, 178, 6]

Pour une meilleure lisibilité, vous pouvez imbriquer les appels (lire de l'intérieur vers l'extérieur) :

raw_data = ["  42  ", " 17 ", "  89  ", " 3  "]
 
result = list(map(lambda x: x * 2, map(int, map(str.strip, raw_data))))
print(result)
# [84, 34, 178, 6]

La version imbriquée est compacte mais plus difficile à lire. La version séquentielle est plus claire pour les pipelines à plusieurs étapes. Aucune ne crée de listes intermédiaires -- les trois objets map sont évalués paresseusement.

map() dans les Pipelines de Traitement de Données

Le traitement de données du monde réel implique souvent la lecture, le nettoyage, la transformation et l'agrégation de données. map() s'intègre naturellement dans ce modèle.

Traitement des Entrées de Log

log_lines = [
    "2026-02-10 INFO User logged in",
    "2026-02-10 ERROR Database timeout",
    "2026-02-10 WARNING Disk space low",
    "2026-02-10 INFO File uploaded",
]
 
def parse_log(line):
    parts = line.split(" ", 2)
    return {"date": parts[0], "level": parts[1], "message": parts[2]}
 
parsed = list(map(parse_log, log_lines))
errors = list(filter(lambda entry: entry["level"] == "ERROR", parsed))
print(errors)
# [{'date': '2026-02-10', 'level': 'ERROR', 'message': 'Database timeout'}]

Logique de Renommage de Fichiers par Lots

import os
 
filenames = ["Report Q1.PDF", "data export.CSV", "NOTES 2026.TXT"]
 
def sanitize_filename(name):
    base, ext = os.path.splitext(name)
    return base.strip().lower().replace(" ", "_") + ext.lower()
 
cleaned = list(map(sanitize_filename, filenames))
print(cleaned)
# ['report_q1.pdf', 'data_export.csv', 'notes_2026.txt']

Pipeline de Données Numériques

import math
 
raw_measurements = ["3.14159", "2.71828", "1.41421", "1.73205"]
 
# Pipeline : parser -> élever au carré -> logarithme -> arrondir à 3 décimales
pipeline = map(lambda x: round(x, 3),
           map(math.log,
           map(lambda x: x ** 2,
           map(float, raw_measurements))))
 
print(list(pipeline))
# [2.292, 2.003, 0.693, 1.099]

Quand Utiliser map() vs List Comprehension : Guide de Décision

Utilisez cette référence rapide pour décider quel outil convient à votre situation :

Utilisez map() quand :

• Vous appliquez une seule fonction intégrée : map(int, strings), map(str.strip, lines)
• Vous avez déjà une fonction nommée qui fait la transformation
• Vous voulez une évaluation paresseuse et n'avez pas besoin de la liste complète en mémoire
• Vous passez plusieurs itérables pour des opérations élément par élément

Utilisez une list comprehension quand :

• La transformation est une expression simple : [x * 2 for x in numbers]
• Vous avez besoin de filtrer dans la même étape : [x for x in items if x > 0]
• La logique implique plusieurs conditions ou des opérations imbriquées
• Vous voulez le résultat comme liste immédiatement
• La lisibilité compte plus que la micro-optimisation

Utilisez une expression génératrice quand :

• Vous avez besoin d'une évaluation paresseuse mais voulez la lisibilité de la syntaxe comprehension
• Le résultat ne sera consommé qu'une fois (passé à sum(), max(), join(), etc.)

# map -- le plus propre pour la conversion de types
integers = list(map(int, ["1", "2", "3"]))
 
# List comprehension -- le plus propre pour transformation + filtre
even_squares = [x ** 2 for x in range(20) if x % 2 == 0]
 
# Expression génératrice -- le plus propre pour consommation unique
total = sum(x ** 2 for x in range(1000))

Expérimenter avec map() dans RunCell

Quand vous construisez des pipelines de transformation de données avec map(), tester chaque étape interactivement est essentiel. Vous devez voir les résultats intermédiaires, vérifier les cas limites et confirmer que les maps chaînés produisent la sortie attendue.

RunCell (opens in a new tab) est un agent IA qui fonctionne directement dans les notebooks Jupyter. Il comprend le contexte de votre notebook -- les variables, DataFrames et imports déjà en mémoire -- et vous aide à construire et déboguer des pipelines map() étape par étape :

• Visualiser les résultats intermédiaires. Demandez à RunCell de montrer ce que chaque étape d'un map() chaîné produit, sans casser votre pipeline.
• Suggérer des alternatives vectorisées. Si vous utilisez map() sur des Series pandas, RunCell peut recommander des opérations pandas natives 10-100x plus rapides.
• Convertir entre map et comprehension. Décrivez la transformation et RunCell génère les deux versions pour que vous choisissiez la plus lisible.
• Déboguer les cas limites. Injectez des entrées inattendues (valeurs None, chaînes vides, types mixtes) dans votre pipeline map et voyez exactement où il casse.

FAQ

Que fait la fonction map() en Python ?

La fonction map() applique une fonction donnée à chaque élément dans un ou plusieurs itérables (comme des listes, tuples ou chaînes) et retourne un itérateur des résultats. C'est une fonction intégrée qui permet la transformation de données de style fonctionnel sans écrire de boucles explicites. La syntaxe est map(function, iterable), et l'objet map retourné est paresseux -- il calcule les résultats à la demande plutôt que tous en même temps.

Est-ce que map() est plus rapide qu'une boucle for en Python ?

Oui, map() est généralement plus rapide qu'une boucle for équivalente qui construit une liste avec append(). L'avantage de vitesse vient du fait que map() est implémenté en C au niveau de l'interpréteur, ce qui évite le surcoût de l'itération de boucle et des appels de méthodes au niveau Python. En utilisant map() avec une fonction intégrée comme int ou str, le gain de performance est le plus significatif -- typiquement 20-40% plus rapide. Avec un lambda, la différence se réduit car le lambda lui-même introduit un appel de fonction niveau Python.

Comment convertir un objet map en liste ?

Enveloppez l'appel map() avec list() : result = list(map(int, strings)). Vous pouvez aussi convertir vers d'autres collections : tuple(map(...)) pour les tuples, set(map(...)) pour les sets. N'oubliez pas qu'un objet map est un itérateur à usage unique. Une fois consommé (en le convertissant en liste ou en itérant dessus), il est épuisé et ne peut pas être réutilisé.

Est-ce que map() peut travailler avec plusieurs listes ?

Oui. Passez plusieurs itérables après la fonction : map(func, list1, list2, list3). La fonction doit accepter autant d'arguments qu'il y a d'itérables. Par exemple, list(map(lambda a, b: a + b, [1, 2], [10, 20])) retourne [11, 22]. L'itération s'arrête au plus court itérable, donc les listes de longueurs inégales ne génèrent pas d'erreurs -- les éléments supplémentaires sont silencieusement ignorés.

Devrais-je utiliser map() ou une list comprehension ?

Utilisez map() quand vous appliquez une seule fonction existante (intégrée ou nommée) à un itérable, surtout pour les conversions de type comme map(int, strings). Utilisez une list comprehension quand la transformation implique une expression, quand vous avez besoin de filtrer avec une clause if, ou quand la lisibilité est la priorité. En Python moderne, les list comprehensions sont le choix par défaut pour la plupart des développeurs, mais map() avec les fonctions intégrées reste plus rapide et plus concis pour les transformations simples à une fonction.

Conclusion

La fonction map() de Python est un outil précis pour un travail spécifique : appliquer une seule fonction à chaque élément d'un itérable sans écrire de boucle. Elle excelle combinée avec les fonctions intégrées comme int, str, float et len, où elle produit le code le plus lisible et le plus rapide. Avec les fonctions lambda, elle gère les transformations en ligne proprement. Avec plusieurs itérables, elle traite les opérations élément par élément qui nécessiteraient sinon zip() et une boucle.

Voici les règles pour utiliser map() efficacement :

• Passez les fonctions intégrées directement : map(int, strings) pas map(lambda x: int(x), strings).
• Utilisez lambda uniquement pour les transformations simples à expression unique.
• Passez à une fonction nommée quand la transformation nécessite la gestion d'erreurs, plusieurs étapes ou de la documentation.
• Préférez les list comprehensions quand vous avez besoin de filtrer ou quand l'expression est plus claire en ligne.
• N'oubliez pas que map() retourne un itérateur paresseux à usage unique -- convertissez en list() quand vous avez besoin de réutiliser ou inspecter les résultats.
• Chaînez les appels map() pour des pipelines à plusieurs étapes sans créer de listes intermédiaires.

map() n'est pas un remplacement des list comprehensions, et les list comprehensions ne sont pas un remplacement de map(). Ils se chevauchent mais servent des forces différentes. Le meilleur code Python utilise chacun là où il s'intègre naturellement : map() pour appliquer des fonctions existantes, les list comprehensions pour les expressions et le filtrage, et les expressions génératrices pour la consommation paresseuse à passage unique.