Pandas & NumPy Academy · Leçon

Effectuer une jointure sur l’index

Utilisez DataFrame.join() et définissez left_index/right_index=True dans merge() pour combiner des DataFrames alignés sur leur index.

Leçon 4 sur 413 étapes

Effectuer une jointure sur l’index est une leçon Pandas & NumPy Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Join basés sur l’index

Jusqu’à présent, vous avez fusionné des DataFrames en faisant correspondre des valeurs dans des colonnes ordinaires. Mais il arrive que les informations sur lesquelles vous souhaitez effectuer la correspondance soient stockées dans l’index du DataFrame plutôt que dans une colonne. Pandas prend en charge les join basés sur l’index avec DataFrame.join() ainsi qu’avec pd.merge() et les paramètres left_index=True ou right_index=True.

Méthode DataFrame.join()

DataFrame.join(other) est une méthode pratique qui effectue par défaut un join sur l’index des deux DataFrames. Elle équivaut à un appel à pd.merge() avec left_index=True, right_index=True. Le type de join par défaut est 'left', contrairement à pd.merge(), dont la valeur par défaut est 'inner'. Les deux DataFrames doivent partager des libellés d’index pertinents pour que le join produise des résultats corrects.

import pandas as pd

profiles = pd.DataFrame(
    {'age': [25, 30, 22]},
    index=['alice', 'bob', 'carol']
)

scores = pd.DataFrame(
    {'score': [88, 95, 70]},
    index=['alice', 'carol', 'dave']
)

# join: left join on index (default)
result = profiles.join(scores)
print(result)
#        age  score
# alice   25   88.0
# bob     30    NaN   <- bob has no score
# carol   22   95.0

Contrôler le type de join dans join()

Transmettez le paramètre how à join() pour contrôler les lignes conservées, comme avec pd.merge(). Les options sont 'left' (par défaut), 'right', 'inner' et 'outer'. Par exemple, how='inner' ne conserve que les index présents dans les deux DataFrames et supprime la ligne d’alice si elle ne possède aucun index correspondant dans la table de droite.

# Inner join on index: only rows present in BOTH indices
print(profiles.join(scores, how='inner'))
#        age  score
# alice   25     88
# carol   22     70

# Outer join: all indices from both
print(profiles.join(scores, how='outer'))
#        age  score
# alice  25.0   88.0
# bob    30.0    NaN
# carol  22.0   70.0
# dave    NaN   95.0

Joindre plusieurs DataFrames en une seule fois

L’un des principaux avantages de join() par rapport à pd.merge() est qu’il accepte une liste de DataFrames et les joint tous au DataFrame appelant en un seul appel. Tous les DataFrames doivent être alignés sur leur index. C’est très pratique lorsque vous disposez de nombreuses tables de caractéristiques indexées par la même clé, telle qu’un identifiant utilisateur ou une date, et que vous souhaitez les réunir dans un DataFrame large.

emails = pd.DataFrame({'email': ['a@x.com', 'b@x.com', 'c@x.com']},
                      index=['alice', 'bob', 'carol'])
city  = pd.DataFrame({'city': ['NY', 'LA', 'SF']},
                     index=['alice', 'bob', 'carol'])

# Join multiple DataFrames at once
result = profiles.join([emails, city])
print(result)
#        age    email city
# alice   25  a@x.com   NY
# bob     30  b@x.com   LA
# carol   22  c@x.com   SF

Joindre sur une colonne d’une table et l’index d’une autre

pd.merge() vous permet de combiner une correspondance fondée sur une colonne et une correspondance fondée sur un index avec left_on/right_index ou left_index/right_on. C’est utile lorsqu’un DataFrame stocke la clé dans une colonne tandis que l’autre l’utilise comme index. Vous ne pouvez pas obtenir ce résultat avec join() seul.

# orders has customer_id as a column; customers is indexed by customer_id
customers_indexed = pd.DataFrame(
    {'name': ['Alice', 'Bob', 'Carol']},
    index=[101, 102, 103]
)
orders = pd.DataFrame({
    'order_id': [1, 2, 3],
    'customer_id': [101, 102, 101]
})

result = pd.merge(orders, customers_indexed,
                  left_on='customer_id', right_index=True)
print(result)
#    order_id  customer_id   name
# 0         1          101  Alice
# 2         3          101  Alice
# 1         2          102    Bob

Utiliser left_index et right_index dans merge()

Lorsque les deux DataFrames utilisent la clé comme index, employez pd.merge(left, right, left_index=True, right_index=True). Cela équivaut à join(), mais avec le type de jointure 'inner' par défaut et des paramètres plus explicites. Vous bénéficiez également de tous les autres paramètres de pd.merge(), comme suffixes et indicator.

# Both DataFrames indexed by user_id
demog = pd.DataFrame({'age': [25, 30]}, index=[1, 2])
behav = pd.DataFrame({'clicks': [10, 5]}, index=[1, 2])

# Equivalent joins
result1 = demog.join(behav)  # left join
result2 = pd.merge(demog, behav, left_index=True, right_index=True)  # inner join

print(result1)
print(result2)

Pourquoi utiliser des jointures fondées sur l’index ?

Les jointures fondées sur l’index sont à privilégier lorsque vos DataFrames sont naturellement identifiés par un identifiant pertinent, tel qu’un identifiant utilisateur, un SKU de produit ou une date. Utiliser l’index pour les jointures évite d’encombrer votre DataFrame avec des colonnes de clés redondantes et peut accélérer les opérations, car Pandas conserve des structures d’index triées pour effectuer des recherches en O(log n). Elles sont particulièrement courantes dans les données de séries temporelles, où le DatetimeIndex constitue la clé de jointure naturelle.

# Time series example: join temperature and humidity by date index
import numpy as np
dates = pd.date_range('2024-01-01', periods=5)
temp = pd.DataFrame({'temp_c': [10, 12, 9, 11, 13]}, index=dates)
humid = pd.DataFrame({'humidity': [65, 70, 60, 75, 68]}, index=dates)

weather = temp.join(humid)
print(weather.head())

Gérer les noms de colonnes en conflit

Lorsque les deux DataFrames possèdent des colonnes portant le même nom (à l’exception de la clé), join() lève une ValueError par défaut, sauf si vous fournissez les paramètres lsuffix et rsuffix. Ces paramètres fonctionnent comme suffixes dans pd.merge() : ils ajoutent une chaîne aux noms des colonnes communes des DataFrames de gauche et de droite, respectivement.

df_a = pd.DataFrame({'value': [1, 2]}, index=['x', 'y'])
df_b = pd.DataFrame({'value': [10, 20]}, index=['x', 'y'])

# Without suffixes: raises ValueError
# result = df_a.join(df_b)

# With suffixes: disambiguate column names
result = df_a.join(df_b, lsuffix='_left', rsuffix='_right')
print(result)
#    value_left  value_right
# x           1           10
# y           2           20

set_index avant la jointure

Une méthode courante consiste à définir une colonne comme index avant la jointure afin de pouvoir utiliser la syntaxe de join(). Après la jointure, reset_index() rétablit la clé sous forme de colonne ordinaire. Ce schéma est intuitif : promouvoir la clé au rang d’index, effectuer la jointure, puis faire redevenir la clé une colonne, ce qui rend l’intention claire pour les personnes qui reliront votre code.

orders_col = pd.DataFrame({'order_id': [1,2,3], 'customer_id': [10,20,10], 'amount': [100,200,150]})
cust_col = pd.DataFrame({'customer_id': [10,20], 'name': ['Alice','Bob']})

result = (
    orders_col.set_index('customer_id')
    .join(cust_col.set_index('customer_id'), how='left')
    .reset_index()
)
print(result)

Aligner une Series sur l’index d’un DataFrame

Une Series possède également un index, et vous pouvez l’ajouter comme nouvelle colonne à un DataFrame par affectation : Pandas aligne automatiquement les valeurs de la Series sur les libellés d’index correspondants. Il s’agit d’une forme légère de jointure fondée sur l’index, utile lorsque vous souhaitez ajouter une seule colonne provenant d’une Series sans appeler merge() ni join().

df = pd.DataFrame({'sales': [100, 200, 150]}, index=['A', 'B', 'C'])
tax_rate = pd.Series({'A': 0.1, 'B': 0.2, 'C': 0.15})

# Index alignment: Series aligns to DataFrame index automatically
df['tax'] = df['sales'] * tax_rate
print(df)
#    sales   tax
# A    100  10.0
# B    200  40.0
# C    150  22.5

Performances des jointures sur index

Effectuer une jointure sur un index trié est plus rapide que sur une colonne ordinaire, car Pandas utilise une recherche binaire dans l’index trié. Si vous effectuez régulièrement des jointures sur la même clé, définissez cette clé comme index dès le début de votre pipeline. C’est particulièrement important dans les traitements de séries temporelles, lorsque vous effectuez des milliers de jointures sur un DatetimeIndex réparti dans de nombreux fichiers.

# Sort index before repeated joins for speed
left = left.sort_index()
right = right.sort_index()

# Both sorted -> Pandas uses merge path with binary search
result = left.join(right, how='inner')

# Check if index is sorted
print('Left sorted:', left.index.is_monotonic_increasing)
print('Right sorted:', right.index.is_monotonic_increasing)

Vérification rapide

Vérifiez votre compréhension des jointures fondées sur l’index présentées dans cette leçon.

Récapitulatif de la leçon

Dans cette leçon, vous avez appris que DataFrame.join() effectue par défaut une jointure à gauche sur l’index ; que pd.merge() avec left_index=True/right_index=True offre davantage de contrôle ; que vous pouvez joindre plusieurs DataFrames en une seule fois en transmettant une liste à join() ; et qu’un index trié améliore les performances des jointures. Nous allons maintenant étudier la restructuration des DataFrames avec pivot_table.

Gratuit pour commencer

Apprends Python avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours
30
Leçons
120

Questions Fréquemment Posées

La leçon « Effectuer une jointure sur l’index » est-elle gratuite ?

Oui — le texte complet de « Effectuer une jointure sur l’index » 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 « Effectuer une jointure sur l’index » ?

Utilisez DataFrame.join() et définissez left_index/right_index=True dans merge() pour combiner des DataFrames alignés sur leur index. 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 4 sur 4.

Combien de temps prend la leçon « Effectuer une jointure sur l’index » ?

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. pd.concat pour empiler des DataFrames
  2. pd.merge : jointures internes et externes
  3. Jointures gauche et droite
  4. Effectuer une jointure sur l’index
← Retour à Pandas & NumPy Academy