Fusion de tables : cours de Première NSI

Dans le chapitre sur les tables, tu as appris à lire un fichier CSV, à rechercher une valeur et à trier des lignes. Tu travaillais alors sur une seule table à la fois. Or, dans la vie réelle, les données sont rarement rangées dans un seul tableau géant. On les répartit dans plusieurs tables, et on les relie quand on en a besoin.

Ce cours répond à une question simple : comment obtenir, en un seul tableau, des informations qui se trouvent dans deux tables différentes ?

Prenons le cas décrit dans le document d'Éduscol sur pandas. On dispose d'une table des villes et d'une table des pays. Côté pays, on ne lit pas le nom de la capitale : on y trouve seulement un code chiffré, qui reprend une valeur de la colonne id des villes ¹. Pour afficher le nom de chaque capitale, il faut donc aller le chercher dans l'autre table. C'est exactement ce que fait une fusion de tables, appelée aussi jointure ¹.

Pourquoi ne pas tout mettre dans une seule table dès le départ ? Imagine que tu écrives le nom complet de la capitale, sa population et ses coordonnées dans chaque ligne de la table des pays. Si la population change, tu devrais corriger plusieurs endroits. En stockant une seule fois chaque ville et en la désignant par un numéro, on évite les répétitions et les incohérences. La fusion permet ensuite de reconstituer le grand tableau quand on en a besoin.

Dans l'exemple du document d'Éduscol, la clé n'a pas le même nom dans les deux tables : c'est la colonne « capitale » côté pays et la colonne id côté villes ¹. Ce n'est pas un problème : ce qui compte, c'est que les valeurs se correspondent, pas que les noms soient identiques.

Voici un petit jeu de données fictif, aux populations arrondies, que nous utiliserons dans tout le cours.

Observe que la colonne capitale de la table des pays contient 10, 11 et 12. Ces nombres sont les valeurs de la colonne id de la table des villes. Lyon, de numéro 13, n'est la capitale d'aucun pays de notre table.

En NSI, tu as vu qu'une table peut être représentée par une liste de dictionnaires : chaque dictionnaire est une ligne, les clés du dictionnaire sont les noms des colonnes. Écrivons nos deux tables ainsi.

pays = [
    {"id": 1, "nom": "France", "capitale": 10},
    {"id": 2, "nom": "Italie", "capitale": 11},
    {"id": 3, "nom": "Espagne", "capitale": 12},
]
villes = [
    {"id": 10, "nom": "Paris", "population": 2.1},
    {"id": 11, "nom": "Rome", "population": 2.8},
    {"id": 12, "nom": "Madrid", "population": 3.3},
    {"id": 13, "nom": "Lyon", "population": 0.5},
]

Voici le code correspondant. Remarque le traitement des noms de champs : si un champ existe déjà dans la ligne de gauche, on ajoute _2 au champ de droite. Sans cela, le second dictionnaire écraserait silencieusement le premier.

def jointure(t1, t2, cle1, cle2):
    resultat = []
    for l1 in t1:
        for l2 in t2:
            if l1[cle1] == l2[cle2]:
                ligne = dict(l1)
                for champ, valeur in l2.items():
                    nom = champ if champ not in l1 else champ + "_2"
                    ligne[nom] = valeur
                resultat.append(ligne)
    return resultat

L'appel jointure(pays, villes, "capitale", "id") renvoie trois dictionnaires. Le premier est {"id": 1, "nom": "France", "capitale": 10, "id_2": 10, "nom_2": "Paris", "population": 2.1}.

Le coût de cet algorithme se compte facilement. Pour chaque ligne de la table de gauche, on parcourt toute la table de droite. Si la première table a $n$ lignes et la seconde $m$ lignes, on effectue $n \times m$ comparaisons de clés. Dans notre exemple, $3 \times 4 = 12$ comparaisons. Sur de grosses tables, ce nombre devient vite très grand, ce qui explique l'intérêt des bibliothèques optimisées.

Les tables lues dans des fichiers CSV sont stockées par pandas sous forme de dataframes, que l'on peut voir comme un tableau ¹. Pour jeter un œil à une table, on dispose de head(), qui affiche les premières lignes, et de sample(n), qui affiche n enregistrements pris au hasard ¹. Ces deux méthodes sont utiles pour vérifier le contenu d'une table avant et après une fusion.

Pour fusionner deux dataframes, on utilise une méthode de jointure à laquelle on indique la colonne-clé de chaque table. Avec nos tables, que l'on suppose chargées dans les variables pays et villes :

resultat = pays.merge(villes, left_on="capitale", right_on="id")

Le paramètre left_on désigne la clé de la table de gauche, right_on celle de la table de droite. Si les deux colonnes portaient le même nom, un seul paramètre on suffirait.

Une autre idée du même document consiste à préparer la table à fusionner avant de la joindre, puis à ne garder qu'une partie des colonnes de l'autre table ¹. C'est une bonne habitude : si tu n'as besoin que du nom de la capitale, sélectionne d'abord les colonnes id_ville et nom_ville, puis fusionne. Le résultat est plus lisible et plus léger.

Que se passe-t-il quand une valeur de clé n'existe que d'un côté ? Cela dépend du type de jointure. Reprenons l'exemple de Lyon : son numéro, 13, n'apparaît dans aucune capitale.

Il reste un cas qui surprend souvent : celui des doublons de clé. Imagine une table des villes contenant plusieurs villes pour un même pays, et une table des pays contenant ce pays une seule fois. Chaque ville trouvera sa correspondance, et le pays sera recopié autant de fois qu'il y a de villes. Le résultat peut donc avoir plus de lignes que chacune des deux tables.

Règle de calcul : si une valeur de clé apparaît $a$ fois à gauche et $b$ fois à droite, elle produit $a \times b$ lignes dans une jointure interne.

Une fois la table fusionnée, tu peux enchaîner avec les opérations des chapitres précédents. Tu peux trier par population décroissante pour trouver la capitale la plus peuplée, ou rechercher les pays dont la capitale dépasse 3 millions d'habitants. La fusion est souvent une étape intermédiaire, pas un but en soi.