Aller au contenu

Numérique et sciences informatiques (spécialité) · Première

Fusion de tables : exercices corrigés de NSI en Première

Publié le 6 novembre 2026 · Mis à jour le 6 novembre 2026 · Signaler une erreur

L'essentiel

  • Fusionner deux tables, c'est relier deux lignes qui partagent la même valeur de clé : un numéro dans une table renvoie à l'identifiant d'une autre.1
  • Avant de coder, repère la colonne-clé de chaque table : elles n'ont pas forcément le même nom.
  • Une jointure interne ne garde que les clés présentes des deux côtés ; une jointure à gauche garde toutes les lignes de la table de gauche.
  • Quand deux tables ont des colonnes de même nom, il y a un conflit à résoudre avant ou pendant la fusion.1
  • Après chaque fusion, contrôle le nombre de lignes et de colonnes obtenu, par exemple avec un aperçu des premières lignes.1

Comment utiliser ces exercices

Ces exercices s'adressent à toi si tu sais déjà lire un fichier CSV, chercher une valeur dans une table et trier ses lignes. Ici, tu apprends à croiser deux tables pour retrouver, à partir d'un numéro, l'information qui se trouve dans une autre table.

Tu peux chercher chaque énoncé sur papier, puis vérifier avec Python. Pour les exercices de calcul, la réponse attendue est un nombre : fais-le toi-même avant d'ouvrir la correction. Les indices sont là pour te débloquer sans te donner la solution.

Les exercices

Exercice 1 Prévoir le nombre de lignes d'une jointure

★☆☆Environ 5 min

On dispose de deux tables.

Table pays (colonne capitale = numéro de la ville) :

nom capitale
France 1
Italie 2
Espagne 3
Chili 9

Table villes (colonne id = numéro de la ville) :

id nom
1 Paris
2 Rome
3 Madrid
4 Lyon
5 Milan

On fusionne pays et villes en reliant capitale à id, en ne gardant que les lignes qui ont une correspondance des deux côtés.

Combien de lignes contient la table obtenue ?

Indice 1

Pour chaque pays, regarde si son numéro de capitale existe dans la colonne id de villes.

Indice 2

Une ville qui n'est la capitale d'aucun pays ne produit aucune ligne dans une jointure interne.

Voir la correction pas à pas
  1. On repère la clé : capitale à gauche, id à droite.

  2. On teste chaque pays : la France (1), l'Italie (2) et l'Espagne (3) ont une ville correspondante.

  3. Le Chili a pour capitale le numéro 9, qui n'existe pas dans villes : cette ligne disparaît d'une jointure interne.

  4. Lyon (4) et Milan (5) ne sont la capitale d'aucun pays : elles ne produisent rien non plus.

  5. La table obtenue contient donc 3 lignes.

Une jointure interne ne conserve que les clés présentes dans les deux tables. Les lignes sans correspondance, d'un côté comme de l'autre, disparaissent.

Exercice 2 Compter les colonnes après fusion

★☆☆Environ 5 min

La table pays possède 3 colonnes : nom, capitale, continent. La table villes possède 4 colonnes : id, nom, latitude, longitude.

On les fusionne avec :

res = pays.merge(villes, left_on='capitale', right_on='id')

Les deux colonnes nom sont conservées, chacune avec un suffixe (nom_x et nom_y), et les colonnes de jointure capitale et id sont toutes les deux gardées.

  1. Pourquoi les deux colonnes nom entrent-elles en conflit ?
  2. Combien de colonnes contient res ?
Indice 1

Le conflit vient de deux colonnes de même nom qui n'ont pas le même sens.

Indice 2

Aucune colonne n'est supprimée : additionne simplement les colonnes des deux tables.

Voir la correction pas à pas
  1. Le conflit : nom désigne le pays dans la première table et la ville dans la seconde. Deux champs de même nom ne peuvent pas coexister sous le même intitulé, donc ils sont renommés avec des suffixes.1

  2. On ne supprime aucune colonne : capitale et id restent présentes, et les deux nom aussi (sous deux noms différents).

  3. Le nombre de colonnes est la somme : 3 + 4 = 7.

Le nombre de colonnes d'une fusion est la somme des colonnes des deux tables, quand aucune n'est supprimée. Le renommage évite de perdre l'une des deux colonnes nom.

Exercice 3 Une jointure écrite à la main en Python

★★☆Environ 10 min

Sans bibliothèque, les tables sont des listes de dictionnaires.

villes = [
    {'id': 1, 'nom': 'Paris',  'pop': 2100},
    {'id': 2, 'nom': 'Rome',   'pop': 2800},
    {'id': 3, 'nom': 'Madrid', 'pop': 3300},
    {'id': 4, 'nom': 'Lyon',   'pop': 500},
]
pays = [
    {'nom': 'France',  'capitale': 1},
    {'nom': 'Italie',  'capitale': 2},
    {'nom': 'Espagne', 'capitale': 3},
]

total = 0
for p in pays:
    for v in villes:
        if v['id'] == p['capitale']:
            total = total + v['pop']

La population pop est exprimée en milliers d'habitants.

  1. Que représente la double boucle ?
  2. Quelle est la valeur de total à la fin ?
Indice 1

Pour chaque pays, la boucle interne parcourt toute la table des villes et cherche l'égalité des clés.

Indice 2

Lyon n'est la capitale d'aucun des trois pays.

Voir la correction pas à pas
  1. La boucle externe parcourt chaque pays ; la boucle interne parcourt chaque ville. Le test v['id'] == p['capitale'] est exactement la condition de jointure.

  2. France : la capitale est 1, donc Paris ajoute 2100.

  3. Italie : la capitale est 2, donc Rome ajoute 2800.

  4. Espagne : la capitale est 3, donc Madrid ajoute 3300.

  5. Lyon (id 4) ne correspond à aucun pays : elle n'est jamais ajoutée.

  6. Total : 2100 + 2800 + 3300 = 8200 milliers d'habitants.

Cette double boucle est la jointure la plus simple. Elle compare chaque ligne de gauche à chaque ligne de droite, ce qui devient lent sur de grosses tables : c'est l'une des raisons d'utiliser une bibliothèque.

Exercice 4 Clés répétées et lignes sans correspondance

★★☆Environ 10 min

Une boutique possède une table clients et une table commandes.

Table clients : les identifiants 1, 2 et 3.

Table commandes : une ligne par commande, avec le client concerné.

num_commande client
101 1
102 1
103 2
104 2
105 2
106 7

On fusionne en conservant toutes les lignes de clients, même celles qui n'ont aucune commande (les informations manquantes sont alors vides).

Combien de lignes contient la table obtenue ?

Indice 1

Un client qui a plusieurs commandes donne plusieurs lignes.

Indice 2

La commande 106 concerne un client absent de la table clients : que devient-elle quand on part de clients ?

Voir la correction pas à pas
  1. Le client 1 a deux commandes (101 et 102) : il donne 2 lignes.

  2. Le client 2 a trois commandes (103, 104, 105) : il donne 3 lignes.

  3. Le client 3 n'a aucune commande, mais on conserve toutes les lignes de clients : il donne 1 ligne, avec une valeur manquante pour la commande.

  4. La commande 106 (client 7) n'a pas de correspondance dans clients et on part de clients : elle n'apparaît pas.

  5. Total : 2 + 3 + 1 = 6 lignes.

Une fusion peut multiplier les lignes (une clé répétée à droite) et peut aussi faire apparaître des valeurs manquantes (clé sans correspondance). Le nombre de lignes obtenu n'est donc pas celui de la table de départ.

Exercice 5 Écrire la fusion avec pandas

★★☆Environ 10 min

Deux fichiers CSV ont été lus avec pandas :

import pandas
pays = pandas.read_csv('pays.csv')     # colonnes : nom, capitale, continent
villes = pandas.read_csv('villes.csv') # colonnes : id, nom, latitude, longitude

Les tables lues dans un CSV sont stockées sous forme de dataframes, que l'on peut voir comme des tableaux.1

On veut une table qui contient, pour chaque pays, le nom du pays et le nom de sa capitale, et rien d'autre.

  1. Écris la ligne qui fusionne les deux tables.
  2. Écris les instructions qui ne gardent que les deux noms, en les renommant pays et capitale.
  3. Quelle instruction permet de vérifier le résultat sur les premières lignes ?
Indice 1

Avant la fusion, renomme la colonne nom de chaque table avec un nom explicite : le conflit disparaît.1

Indice 2

La méthode head() affiche les premières entrées d'une table.1

Voir la correction pas à pas
  1. On commence par lever le conflit : p = pays.rename(columns={'nom': 'pays'}) puis v = villes.rename(columns={'nom': 'capitale_nom'}).

  2. On fusionne en reliant le numéro de capitale à l'identifiant : res = p.merge(v, left_on='capitale', right_on='id').

  3. On ne garde que les deux colonnes utiles : res = res[['pays', 'capitale_nom']].

  4. On renomme si on le souhaite : res = res.rename(columns={'capitale_nom': 'capitale'}).

  5. On vérifie avec res.head(), qui affiche les premières lignes de la table.1

Renommer les colonnes avant la fusion est la manière la plus claire de gérer un conflit de noms : le résultat se lit sans ambiguïté.

Exercice 6 Moyenne sur les lignes qui correspondent

★★★Environ 15 min

On reprend les tables pays et villes.

Table villes :

id nom latitude
1 Paris 48.9
2 Rome 41.9
3 Madrid 40.4
4 Berlin 52.5
5 Lyon 45.8
6 Milan 45.5

Table pays : France (capitale 1), Italie (capitale 2), Espagne (capitale 3), Allemagne (capitale 4).

On fusionne les deux tables, puis on calcule la moyenne de la colonne latitude de la table obtenue.

  1. Quelles villes restent dans la table fusionnée ?
  2. Quelle est la moyenne des latitudes (en degrés) ?
  3. Pourquoi cette moyenne diffère-t-elle de celle des six villes de villes ?
Indice 1

Seules les villes qui sont la capitale d'un pays survivent à la jointure interne.

Indice 2

Additionne les quatre latitudes puis divise par 4.

Voir la correction pas à pas
  1. Les capitales sont les villes de numéros 1, 2, 3 et 4 : Paris, Rome, Madrid, Berlin.

  2. Lyon et Milan ne correspondent à aucun pays : elles sont écartées.

  3. Somme des latitudes : 48,9 + 41,9 + 40,4 + 52,5 = 183,7.

  4. Moyenne : 183,7 / 4 = 45,925 degrés.

  5. Avec les six villes, la somme serait 183,7 + 45,8 + 45,5 = 275 et la moyenne 275 / 6, soit environ 45,83 : elle diffère parce que la fusion a changé l'ensemble de lignes sur lequel on calcule.

Une fusion filtre les lignes. Toute statistique calculée après une jointure interne porte sur les seules lignes qui ont une correspondance : il faut en être conscient avant d'interpréter un résultat.

Exercice 7 Trouver pourquoi la fusion est vide

★★★Environ 15 min

Léa écrit :

res = pays.merge(villes, on='nom')
print(len(res))

et obtient 0, alors que la table pays contient une centaine de lignes. Les colonnes de pays sont nom (le pays), capitale (un numéro) et continent. Celles de villes sont id, nom (la ville), latitude, longitude.

  1. Explique pourquoi le résultat est vide.
  2. Corrige le code pour obtenir le nom de la capitale de chaque pays.
  3. Quelle vérification simple aurait permis de repérer l'erreur avant de fusionner ?
Indice 1

Compare ce que représente nom dans chaque table.

Indice 2

Le lien entre les tables passe par un numéro, pas par un nom.1

Voir la correction pas à pas
  1. Le paramètre on='nom' relie les lignes dont le nom est identique. Or nom vaut « France » d'un côté et « Paris » de l'autre : les valeurs ne coïncident jamais, d'où 0 ligne.

  2. Le vrai lien est la colonne capitale de pays, qui contient le numéro correspondant au champ id de villes.1

  3. On corrige : res = pays.merge(villes, left_on='capitale', right_on='id', suffixes=('_pays', '_ville')).

  4. Les suffixes distinguent les deux colonnes nom : nom_pays et nom_ville.1

  5. Pour repérer l'erreur plus tôt, on aurait affiché quelques lignes de chaque table avec head() ou sample(7), et constaté que nom ne désigne pas la même chose.1

Avant de fusionner, regarde les données : une colonne se choisit par son sens. Un nom de colonne identique ne garantit jamais que deux champs sont comparables.

Les questions qu'on se pose

Comment savoir quelle colonne utiliser comme clé ?

Cherche, dans une table, une colonne qui contient des numéros ou des codes et, dans l'autre, la colonne dont les valeurs sont ces mêmes numéros. Dans l'exemple des pays et des villes, chaque pays stocke un entier pour désigner sa capitale, et on retrouve cet entier dans la colonne id de la table des villes.1 Affiche quelques lignes de chaque table pour vérifier que les valeurs se ressemblent vraiment.

Pourquoi mon résultat contient-il plus de lignes que mes tables de départ, ou moins ?

Il y en a plus quand une clé apparaît plusieurs fois dans l'une des tables : chaque correspondance produit une ligne. Il y en a moins quand tu fais une jointure interne et que certaines clés n'existent que d'un seul côté. Pour garder toutes les lignes d'une table, utilise une jointure qui conserve cette table entière, et accepte des valeurs manquantes pour les lignes sans correspondance.

Sources

  1. RA_Lycee_G_NSI_trtd_pandas — Manipulation de tables avec pandas (fusion), Éduscol. Consulté le 6 novembre 2026.
  2. Fusion nucléaire, Wikipédia. Consulté le 6 novembre 2026.
  3. Tableau périodique des éléments, Wikipédia. Consulté le 6 novembre 2026.

Les numéros dans le texte renvoient à ces sources. Une source qui ne dit pas ce qu'on lui fait dire ? Signale-le.

Signaler une erreur sur cette page

Je suis en…

Primaire

  • CP Bientôt
  • CE1 Bientôt
  • CE2 Bientôt
  • CM1 Bientôt
  • CM2 Bientôt

Collège

Lycée

Supérieur

  • BTS Bientôt
  • BUT Bientôt
  • Licence Bientôt
  • Prépas Bientôt

Sur cette page