0Pricing
Pandas & NumPy Academy · Leçon

map() et applymap() pour les opérations élément par élément

Appliquez une fonction à chaque élément d’une Series avec map() et à chaque cellule d’un DataFrame avec applymap().

map() et applymap() pour les opérations élément par élément est une leçon Pandas & NumPy Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Pandas & NumPy Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Pandas & NumPy Academy comprend 4 leçons au total.

Présentation de Series.map()

Series.map() applique une fonction, un dictionnaire ou une autre Series à chaque élément d'une Series et renvoie une nouvelle Series. Contrairement à apply(), qui peut recevoir des objets complexes, map() opère toujours sur des valeurs scalaires individuelles. C'est l'outil standard pour encoder des valeurs catégorielles, rechercher des libellés dans une table de correspondance ou appliquer une transformation simple élément par élément.

import pandas as pd

codes = pd.Series(['N', 'S', 'E', 'N', 'W'])
region_names = {'N': 'North', 'S': 'South', 'E': 'East', 'W': 'West'}

names = codes.map(region_names)
print(names)

map() avec une fonction

Transmettez une fonction, y compris une fonction lambda, à map() lorsque la transformation repose sur une logique plutôt que sur une table de correspondance. La fonction reçoit une seule valeur scalaire à la fois ; elle ne peut donc pas accéder aux autres lignes ou colonnes. Pour attribuer des libellés selon une condition simple, map() avec une fonction est plus clair qu'une boucle, mais plus lent que np.where() pour les Series volumineuses.

prices = pd.Series([5.0, 25.0, 80.0, 150.0])

category = prices.map(lambda p: 'budget' if p < 20 else 'mid' if p < 100 else 'premium')
print(category)

map() ou replace() ?

map() et replace() peuvent tous deux remplacer des valeurs à l'aide d'un dictionnaire. La différence essentielle est la suivante : map() renvoie NaN pour toute valeur absente du dictionnaire, sauf si vous utilisez ensuite fillna(), tandis que replace() laisse les valeurs non correspondantes inchangées. Utilisez replace() lorsque vous souhaitez uniquement modifier certaines valeurs et conserver toutes les autres telles quelles.

s = pd.Series(['A', 'B', 'C', 'D'])
map_dict = {'A': 'Alpha', 'B': 'Beta'}

print('map():', s.map(map_dict).tolist())      # C,D → NaN
print('replace():', s.replace(map_dict).tolist())  # C,D → unchanged

map() avec une Series (recherche de libellés)

Vous pouvez transmettre une autre Series à map() comme table de correspondance : les valeurs de la Series appelante servent de clés pour rechercher les valeurs dans l'index de la Series passée en argument. C'est une manière concise de joindre une table de correspondance sans effectuer un appel complet à merge() — cela fonctionne comme une recherche vectorisée dans un dictionnaire dont la table de correspondance est indexée par clé.

prices_lookup = pd.Series(
    [10.0, 25.0, 50.0],
    index=['SKU-001', 'SKU-002', 'SKU-003']
)

orders = pd.Series(['SKU-002', 'SKU-001', 'SKU-003', 'SKU-001'])
order_prices = orders.map(prices_lookup)
print(order_prices)

DataFrame.applymap() pour les opérations cellule par cellule

DataFrame.applymap(), appelé DataFrame.map() dans Pandas 2.1 et les versions ultérieures, applique une fonction à chaque cellule individuelle d'un DataFrame. Contrairement à apply(axis=0), qui reçoit une colonne complète, applymap() reçoit une seule valeur scalaire à la fois. Cette méthode est utile pour formater uniformément toutes les cellules — par exemple, arrondir chaque cellule numérique à 2 décimales ou convertir chaque cellule textuelle en minuscules.

df = pd.DataFrame({
    'a': [1.234, 5.678, 9.012],
    'b': [3.456, 7.890, 2.345]
})

# Round every cell to 1 decimal place
df_rounded = df.applymap(lambda x: round(x, 1))
print(df_rounded)

applymap() pour le formatage des chaînes

Appliquez un formatage cohérent à chaque cellule d'un DataFrame contenant des chaînes de types variés — par exemple, mettez toutes les valeurs en casse de titre ou convertissez None en chaîne vide. applymap(str.strip) supprime les espaces superflus de chaque cellule de l'ensemble du DataFrame en un seul appel, ce qui est bien plus concis que de parcourir les colonnes et d'appliquer .str.strip() à chacune d'elles individuellement.

df_str = pd.DataFrame({
    'name': [' Alice ', 'Bob  ', '  Carol'],
    'city': ['new york ', ' london', 'paris  ']
})

df_clean = df_str.applymap(str.strip)
print(df_clean)

applymap() pour le formatage monétaire

Lorsque vous préparez un DataFrame pour l'afficher dans un rapport, formatez les cellules numériques sous forme de chaînes monétaires avec applymap(). Cette opération convertit les nombres en chaînes prêtes à être affichées sans modifier les types de données sous-jacents — la transformation ne concerne que le résultat final. Appliquez-la en dernière étape avant d'appeler to_excel() ou to_html() pour exporter le tableau formaté.

revenue_table = pd.DataFrame({
    'North': [12300.0, 9800.0],
    'South': [7400.0, 11200.0]
}, index=['Q1', 'Q2'])

formatted = revenue_table.applymap(lambda x: f'${x:,.0f}')
print(formatted)

Pandas 2.1 : applymap renommé en map

Dans Pandas 2.1, DataFrame.applymap() a été renommé en DataFrame.map() afin d'être cohérent avec Series.map(). L'ancien applymap() fonctionne toujours, mais déclenche un avertissement de dépréciation. Dans le code de production, vérifiez votre version de Pandas et utilisez df.map(func) si vous utilisez la version 2.1 ou une version ultérieure, afin d'éviter les avertissements de dépréciation dans les prochaines versions.

import pandas as pd

print('Pandas version:', pd.__version__)

# Forward-compatible pattern:
if hasattr(pd.DataFrame, 'map'):
    df_clean = df_str.map(str.strip)  # Pandas 2.1+
else:
    df_clean = df_str.applymap(str.strip)  # Pandas < 2.1

print(df_clean)

map() pour encoder les caractéristiques catégorielles

Les modèles d'apprentissage automatique nécessitent des entrées numériques ; les colonnes catégorielles doivent donc être encodées. Utilisez map() avec un dictionnaire d'encodage entier pour convertir les catégories en nombres ordinaux avant de transmettre un DataFrame à un modèle. Pour les catégories nominales sans ordre naturel, préférez pd.get_dummies() ou OneHotEncoder de scikit-learn.

size_order = {'small': 0, 'medium': 1, 'large': 2, 'enterprise': 3}

df['size_encoded'] = df['order_size'].map(size_order)
print(df[['order_size', 'size_encoded']])

Enchaîner map() pour une recherche à plusieurs niveaux

Enchaînez deux appels à map() lorsque vous avez besoin d'une recherche à deux niveaux : convertissez d'abord un code en clé intermédiaire, puis la clé intermédiaire en libellé final. Par exemple, convertissez le SKU d'un produit en code de catégorie, puis le code de catégorie en nom de catégorie. Enchaîner deux appels à map() est plus clair qu'un dictionnaire imbriqué ou qu'une jointure suivie d'une autre jointure.

sku_to_cat_code = {'SKU-001': 'C1', 'SKU-002': 'C2', 'SKU-003': 'C1'}
cat_code_to_name = {'C1': 'Electronics', 'C2': 'Apparel'}

skus = pd.Series(['SKU-001', 'SKU-002', 'SKU-003'])
cat_names = skus.map(sku_to_cat_code).map(cat_code_to_name)
print(cat_names)

Gérer les valeurs nulles élément par élément avec map

Lorsque vous utilisez map(func), la fonction est appelée même pour les valeurs NaN, ce qui peut provoquer une TypeError si la fonction ne gère pas None. Entourez la fonction d'une vérification des valeurs nulles avec pd.isna(x) ou utilisez le paramètre na_action='ignore' dans map() pour ignorer les valeurs NaN et les conserver comme NaN dans le résultat sans appeler la fonction.

s = pd.Series([1.0, None, 3.0, None, 5.0])

# na_action='ignore' skips NaN values
result = s.map(lambda x: x * 2, na_action='ignore')
print(result)

Vérification rapide

Testez votre compréhension des concepts d'analyse de données présentés dans cette leçon.

Récapitulatif de la leçon

Dans cette leçon, vous avez appris à utiliser Series.map() pour effectuer des recherches scalaires avec des fonctions et des dictionnaires, à utiliser DataFrame.applymap()/map() pour formater chaque cellule dans toutes les colonnes, ainsi qu'à comprendre la différence entre map() et replace() pour gérer les valeurs non correspondantes. Nous allons maintenant découvrir l'enchaînement de méthodes avec pipe() pour créer des pipelines de transformation lisibles.

Questions Fréquemment Posées

La leçon « map() et applymap() pour les opérations élément par élément » est-elle gratuite ?

Oui — le texte complet de « map() et applymap() pour les opérations élément par élément » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Pandas & NumPy Academy, passe à CoddyKit PRO. Le cours Pandas & NumPy Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « map() et applymap() pour les opérations élément par élément » ?

Appliquez une fonction à chaque élément d’une Series avec map() et à chaque cellule d’un DataFrame avec applymap(). Tu pratiques Pandas & NumPy Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Pandas & NumPy Academy ?

Aucune expérience préalable n'est requise. Pandas & NumPy Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « map() et applymap() pour les opérations élément par élément » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Pandas & NumPy Academy ?

Oui. Chaque leçon Pandas & NumPy Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. apply() sur les colonnes et les lignes
  2. apply() avec GroupBy
  3. map() et applymap() pour les opérations élément par élément
  4. Chaînage de méthodes avec pipe()
← Retour à Pandas & NumPy Academy