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

Le tri d'une table : cours de NSI en Première

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

L'essentiel

Trier une table, c'est réordonner ses lignes selon une clé (une colonne ou une combinaison de colonnes), sans modifier le contenu des lignes.
En Python, sorted(table, key=...) renvoie une nouvelle liste triée ; table.sort(key=...) modifie la liste en place ; reverse=True inverse l'ordre.
Pour plusieurs critères, la fonction key renvoie un tuple ; le signe - inverse l'ordre d'un critère numérique.
Un tri stable garde l'ordre relatif des lignes de même clé : on peut donc enchaîner des tris successifs, le critère principal en dernier.
Les valeurs lues dans un CSV sont des chaînes : convertir avant de trier, sinon '10' passe avant '9'.
Tri par sélection ou par insertion : de l'ordre de $n^2$ comparaisons ; une table triée permet ensuite la recherche dichotomique.

Pourquoi trier une table

Le programme de NSI en Première comporte une partie consacrée au traitement des données en tables ¹. Trier une table en fait partie. Tu sais déjà charger un fichier CSV en Python : on obtient une liste de lignes, et chaque ligne associe des valeurs à des descripteurs, c'est-à-dire les noms des colonnes (nom, age, note…). Une fois la table en mémoire, une question revient vite : dans quel ordre les lignes sont-elles rangées ? Le plus souvent, dans l'ordre où elles ont été saisies ou exportées, ce qui ne répond à rien. Pour savoir qui a la meilleure note, quelles sont les villes les plus peuplées ou comment afficher une liste de classe, il faut d'abord ranger les lignes.

Dans ce cours, tu vas apprendre à choisir la clé de tri, utiliser les outils de Python, trier selon plusieurs critères, comprendre ce qu'est un tri stable, éviter les pièges classiques des fichiers CSV, puis écrire toi-même un algorithme de tri et mesurer son coût. Tu t'appuies sur ce que tu as vu avant : l'indexation d'une table et le format CSV, puis la recherche dans une table. Ce chapitre prépare la fusion de tables, qui suppose souvent des tables déjà triées.

Représenter la table et choisir la clé

Pour tout le cours, on utilise une table représentée par une liste de dictionnaires : chaque dictionnaire est une ligne, les clés du dictionnaire sont les descripteurs.

table = [
    {'nom': 'Alice', 'age': 17, 'note': 14.5},
    {'nom': 'Bruno', 'age': 16, 'note': 12},
    {'nom': 'Chloé', 'age': 17, 'note': 14.5},
    {'nom': 'David', 'age': 16, 'note': 9},
]

Avec cette représentation, table[0] est la première ligne et table[0]['note'] vaut 14.5. Une autre représentation fréquente est la liste de listes (ou de tuples) : on accède alors à une valeur par son indice de colonne, par exemple ligne[2]. Tout ce qui suit s'adapte : il suffit de remplacer ligne['note'] par ligne[2].

Une table avant et après un tri par note décroissante
Position	Avant le tri	Après le tri par note décroissante
0	Alice (14.5)	Alice (14.5)
1	Bruno (12)	Chloé (14.5)
2	Chloé (14.5)	Bruno (12)
3	David (9)	David (9)

Une table avant et après un tri par note décroissante · Le contenu des lignes ne change pas, seul leur ordre change ; Alice reste avant Chloé grâce à la stabilité.

Trier avec Python : sorted et sort

Python propose deux outils pour trier une liste. Ils prennent les mêmes paramètres, mais ne se comportent pas de la même façon.

sorted(table, key=f) renvoie une nouvelle liste triée ; la liste d'origine n'est pas modifiée.
table.sort(key=f) trie la liste en place : elle est modifiée et la méthode renvoie None.

Le paramètre key attend une fonction qui, à une ligne, associe sa clé de tri. Le paramètre reverse=True demande l'ordre décroissant.

ExempleTrier par note, du meilleur au moins bon

def note_de(ligne):
    return ligne['note']

classement = sorted(table, key=note_de, reverse=True)
for ligne in classement:
    print(ligne['nom'], ligne['note'])

Affichage obtenu :

Alice 14.5
Chloé 14.5
Bruno 12
David 9

La variable table n'a pas changé. Alice et Chloé ont la même note ; nous reviendrons sur leur ordre dans la section sur la stabilité.

Écrire une petite fonction nommée pour chaque tri est lisible, mais long. On utilise souvent une fonction anonyme : lambda ligne: ligne['note'] est équivalent à note_de. Le mot-clé lambda introduit les paramètres, le deux-points sépare la valeur renvoyée.

classement = sorted(table, key=lambda ligne: ligne['note'], reverse=True)
alphabetique = sorted(table, key=lambda ligne: ligne['nom'])

Trier selon plusieurs critères

Dans une vraie table, les égalités sont courantes : plusieurs élèves ont la même note, plusieurs villes le même département. On précise alors un critère secondaire qui départage les lignes à égalité sur le premier critère, voire un troisième critère si nécessaire.

MéthodeTrier selon plusieurs critères avec un tuple

Fais renvoyer à la fonction key un tuple qui liste les critères par ordre d'importance.

# par âge croissant, puis par nom alphabétique
sorted(table, key=lambda l: (l['age'], l['nom']))

ExempleNote décroissante, puis nom croissant

Comment demander un sens différent selon le critère ? Pour un critère numérique, on met un signe moins devant sa valeur : trier -note par ordre croissant revient à trier note par ordre décroissant.

classement = sorted(table, key=lambda l: (-l['note'], l['nom']))

Résultat : Alice (14.5), Chloé (14.5), Bruno (12), David (9). Alice et Chloé ont la même note ; le nom les départage dans l'ordre alphabétique.

Tri stable et tris successifs

MéthodeDeux critères de sens opposés

Objectif : note décroissante, et à note égale, nom croissant.

resultat = sorted(table, key=lambda l: l['nom'])               # critère secondaire
resultat = sorted(resultat, key=lambda l: l['note'], reverse=True)  # critère principal

Le deuxième tri regroupe les lignes par note décroissante. Comme il est stable, à l'intérieur d'un groupe de même note l'ordre alphabétique obtenu par le premier tri est conservé.

Démonstration · Pourquoi il faut commencer par le critère secondaire

Supposons que l'on trie d'abord par note puis par nom. Le second tri place toutes les lignes selon le nom ; les notes ne sont plus qu'un critère de départage pour deux élèves de même nom. Le résultat final est donc un classement alphabétique, et le travail du premier tri est presque entièrement écrasé. Le dernier tri effectué est toujours celui du critère principal : c'est lui qui impose l'ordre global, et les tris précédents ne servent qu'à départager les égalités.

Les pièges des données réelles

Trier des données issues d'un fichier demande de la vigilance. Les pièges ci-dessous produisent des résultats faux sans aucun message d'erreur : le programme tourne, mais le classement est absurde.

Attention, erreur fréquentePiège : trier des nombres écrits comme des chaînes

Quand on lit un fichier CSV, toutes les valeurs arrivent sous forme de chaînes de caractères, y compris les nombres. Or les chaînes se comparent caractère par caractère, comme dans un dictionnaire :

'10' < '9'    # True, car '1' est avant '9'
'100' < '25'  # True

Trier des notes lues dans un CSV sans conversion donne donc '10', '12', '9'… Il faut convertir dans la fonction key :

sorted(table, key=lambda l: float(l['note']))

Une image du réel : la table de tri des vendanges

Trier selon des critères n'est pas une idée réservée à l'informatique. Dans le monde du vin, une table de tri est un appareil qui permet de trier les raisins selon leur qualité, à la main ou automatiquement ². Ce tri peut être fait à la main dès la parcelle, par chaque vendangeur, ou bien à l'arrivée des raisins à la cave, sur une table de tri ². Les grappes sont passées sur la table et les personnes qui travaillent de part et d'autre retirent les éléments indésirables ². Garder la bonne vendange et écarter le reste, c'est une forme de tri : on applique un critère à chaque élément.

L'évolution de ces tables ressemble à celle de nos programmes. Au départ, il s'agissait de simples tables fixes sur lesquelles on faisait glisser les raisins ; on a ensuite imaginé des tables à tapis roulant et des tables vibrantes ². Puis le progrès technique a permis des tables automatisées qui prennent en compte la taille, le poids et la couleur des éléments ². Ces tables peuvent être embarquées sur une machine à vendanger ou installées dans la chaîne de réception ². Plusieurs critères sont donc combinés, exactement comme dans un tuple passé à key.

Écrire soi-même un algorithme de tri

Les fonctions de Python cachent le travail réalisé. Au programme de NSI, tu dois aussi savoir écrire et analyser des algorithmes de tri simples. Voici la sélection et l'insertion, appliquées à une table et à une colonne de clé cle. Dans les deux cas, on trie en place, par ordre croissant.

MéthodeTri par sélection

Principe : on cherche la ligne dont la clé est la plus petite parmi les lignes non encore placées, et on l'échange avec la ligne qui occupe la première place libre. On recommence pour la place suivante.

def tri_selection(table, cle):
    n = len(table)
    for i in range(n - 1):
        imin = i
        for j in range(i + 1, n):
            if table[j][cle] < table[imin][cle]:
                imin = j
        table[i], table[imin] = table[imin], table[i]

Invariant : à chaque début de tour de la boucle sur i, les i premières lignes sont à leur place définitive et sont les plus petites de la table.

MéthodeTri par insertion

Principe : on parcourt la table de gauche à droite ; la partie de gauche est toujours triée. Pour chaque nouvelle ligne, on la fait reculer jusqu'à sa bonne place en décalant vers la droite les lignes dont la clé est plus grande.

def tri_insertion(table, cle):
    for i in range(1, len(table)):
        ligne = table[i]
        j = i
        while j > 0 and table[j - 1][cle] > ligne[cle]:
            table[j] = table[j - 1]
            j = j - 1
        table[j] = ligne

Invariant : au début de chaque tour sur i, les lignes d'indices 0 à i-1 sont triées entre elles.

Choisir la placeOn se place sur la première position non encore triée.
Chercher le minimumOn parcourt les lignes restantes pour trouver la plus petite clé.
ÉchangerOn échange cette ligne avec celle de la position choisie.
RecommencerOn passe à la position suivante jusqu'à la fin de la table.

Les étapes du tri par sélection · Le tri par sélection répète ces étapes pour chaque place de la table.

Démonstration · Nombre de comparaisons du tri par sélection

Pour une table de $n$ lignes, le tour numéro $i$ (avec $i$ allant de 0 à $n-2$ ) compare la ligne imin aux $n-1-i$ lignes suivantes, soit $n-1-i$ comparaisons. Le total vaut donc $(n-1)+(n-2)+\dots+1$ . C'est la somme des entiers de 1 à $n-1$ , égale à $\frac{n(n-1)}{2}$ . Ce nombre ne dépend pas du contenu de la table : même une table déjà triée demande autant de comparaisons. Pour $n=10$ , on obtient $10\times 9/2 = 45$ comparaisons ; pour $n=100$ , on en obtient 4 950.

À quoi sert une table triée

Trier coûte du temps : pourquoi le faire ? Parce qu'une table triée rend d'autres opérations bien plus rapides. Le cas typique est la recherche dichotomique, déjà rencontrée dans la recherche dans une table. Sur une table triée selon une clé, on compare la valeur cherchée à la clé de la ligne du milieu : on sait alors dans quelle moitié continuer, et on élimine l'autre moitié. À chaque étape, la zone de recherche est divisée par deux.

ExempleRecherche dichotomique sur une clé

def chercher(table, cle, valeur):
    debut, fin = 0, len(table) - 1
    while debut <= fin:
        milieu = (debut + fin) // 2
        if table[milieu][cle] == valeur:
            return milieu
        elif table[milieu][cle] < valeur:
            debut = milieu + 1
        else:
            fin = milieu - 1
    return None

Attention : cette fonction n'est correcte que si la table est triée sur la colonne cle par ordre croissant. Sur une table non triée, elle peut répondre None alors que la valeur est bien présente.

Exercices corrigés

Exercice 1 Compter les comparaisons du tri par sélection

★☆☆Environ 8 min

Une table contient 12 lignes. On la trie par ordre croissant de la colonne note avec la fonction tri_selection du cours.

Combien de comparaisons de clés (le test table[j][cle] < table[imin][cle]) la fonction effectue-t-elle au total ?

Indice 1

Combien de comparaisons fait le premier tour de la boucle sur i ? Et le deuxième ?

Indice 2

Additionne 11 + 10 + … + 1, ou utilise la formule n(n-1)/2.

Voir la correction pas à pas

Le tour i = 0 compare la ligne d'indice 0 aux 11 suivantes : 11 comparaisons.
Le tour i = 1 en fait 10, puis 9, 8, et ainsi de suite jusqu'au dernier tour (i = 10) qui en fait 1.
Le total est la somme 11 + 10 + … + 1, c'est-à-dire n(n-1)/2 avec n = 12.
On calcule 12 × 11 / 2 = 66.

Le tri par sélection d'une table de 12 lignes effectue 66 comparaisons, quel que soit le contenu de la table, même si elle est déjà triée.

Exercice 2 Gain apporté par une table triée

★★☆Environ 10 min

Une table triée de 1000 lignes est parcourue par la fonction chercher (recherche dichotomique) du cours. À chaque tour de boucle, la zone de recherche est au mieux divisée par deux (à une ligne près).

Quel est le nombre maximal de tours de boucle nécessaires pour conclure, que la valeur soit présente ou non ? Pour répondre, utilise le fait que la taille de la zone passe de 1000 à 500, 250, 125, 62, 31, 15, 7, 3, 1 puis 0.

Indice 1

Compte le nombre de valeurs successives de la taille de la zone, en partant de 1000 et en s'arrêtant à 1.

Indice 2

Tu peux aussi utiliser la plus grande puissance de 2 inférieure ou égale à 1000, qui est 512 = 2^9.

Voir la correction pas à pas

Écris les tailles successives : 1000, 500, 250, 125, 62, 31, 15, 7, 3, 1.
Chacune de ces tailles correspond à un tour de boucle où l'on compare la valeur cherchée à la ligne du milieu : cela fait 10 tailles.
Vérification par la formule : on cherche le plus petit entier k tel que 2^k est strictement supérieur à 1000 ; comme 2^9 = 512 et 2^10 = 1024, la réponse vaut 10, soit la partie entière de log2(1000) augmentée de 1.
Avec une recherche séquentielle, il aurait fallu jusqu'à 1000 comparaisons.

Il faut au plus 10 tours de boucle pour une table triée de 1000 lignes, contre jusqu'à 1000 comparaisons sans tri. C'est ce gain qui justifie le coût du tri préalable quand on fait beaucoup de recherches.

Exercice 3 Classer des villes selon plusieurs critères

★★★Environ 15 min

Voici une table de villes fictives lue depuis un fichier CSV (donc toutes les valeurs sont des chaînes) :

villes = [
    {'ville': 'Mirande', 'region': 'Ouest', 'habitants': '9500'},
    {'ville': 'Aubrac', 'region': 'Sud', 'habitants': '12000'},
    {'ville': 'Lorient', 'region': 'Ouest', 'habitants': '9500'},
    {'ville': 'Tarnac', 'region': 'Sud', 'habitants': '800'},
    {'ville': 'Brive', 'region': 'Ouest', 'habitants': '45000'},
]

Écris le code qui produit la liste classement triée par région (ordre alphabétique), puis, dans chaque région, par nombre d'habitants décroissant, puis, à nombre d'habitants égal, par nom de ville alphabétique. Donne ensuite l'ordre des noms de villes obtenu.

Indice 1

Pense à convertir habitants en entier dans la fonction key.

Indice 2

Le signe moins permet d'inverser l'ordre d'un critère numérique dans un tuple.

Voir la correction pas à pas

Le critère sur habitants est numérique : on le convertit avec int(...), puis on met un signe moins devant pour obtenir l'ordre décroissant.
Les critères par ordre d'importance sont : la région, le nombre d'habitants (en négatif), puis le nom de la ville.
Code : classement = sorted(villes, key=lambda v: (v['region'], -int(v['habitants']), v['ville'])).
Région Ouest : Brive (45000), puis Lorient et Mirande à égalité avec 9500, départagés par ordre alphabétique : Lorient avant Mirande.
Région Sud : Aubrac (12000), puis Tarnac (800).
Ordre final des villes : Brive, Lorient, Mirande, Aubrac, Tarnac.

Un tuple dans key permet de combiner plusieurs critères, la conversion en int évite le piège des chaînes, et le signe moins inverse le sens du critère numérique. Ordre obtenu : Brive, Lorient, Mirande, Aubrac, Tarnac.

Les questions qu'on se pose

Quelle est la différence entre sorted et sort ?

sorted(table, key=f) laisse la table d'origine intacte et renvoie une nouvelle liste triée, qu'il faut stocker dans une variable. table.sort(key=f) trie la liste en place et renvoie None. Choisis sorted quand tu as besoin de conserver l'ordre initial, sort quand tu veux simplement trier la table.

Pourquoi mon tri de nombres donne-t-il 10 avant 9 ?

Parce que les valeurs sont des chaînes de caractères, probablement issues d'un fichier CSV. Les chaînes se comparent caractère par caractère : '1' précède '9', donc '10' précède '9'. Convertis dans la fonction key, par exemple key=lambda l: int(l['age']) ou float(...) pour des décimaux.

Comment trier par ordre décroissant sur une colonne texte, tout en gardant un autre critère croissant ?

Le signe moins ne s'applique pas aux chaînes. Utilise deux tris successifs en profitant de la stabilité : trie d'abord selon le critère secondaire, puis selon le critère principal avec reverse=True. Le dernier tri est toujours celui du critère principal.

À quoi sert vraiment un tri écrit à la main alors que Python en propose un ?

Écrire un tri par sélection ou par insertion permet de comprendre comment fonctionne un algorithme, de raisonner sur un invariant de boucle et de calculer un coût en nombre de comparaisons. Ce sont des compétences du programme de NSI. En pratique, on utilise l'outil de Python dès qu'on veut trier efficacement.

Faut-il toujours trier une table avant d'y chercher une valeur ?

Non. Pour une seule recherche, parcourir la table suffit et coûte moins cher qu'un tri préalable. Le tri devient rentable quand on fait beaucoup de recherches sur la même colonne, ou quand on doit fusionner des tables : on trie une fois, puis on profite de la dichotomie à chaque recherche.

Sources

NSI Première - Traitement de données en tables : opérations (académie Lyon), Académie de Lyon. Consulté le 6 novembre 2026.
Table de tri, 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

Le tri d'une table : cours de NSI en Première

L'essentiel

Pourquoi trier une table

Représenter la table et choisir la clé

Trier avec Python : sorted et sort

Trier selon plusieurs critères

Tri stable et tris successifs

Les pièges des données réelles

Une image du réel : la table de tri des vendanges

Écrire soi-même un algorithme de tri

À quoi sert une table triée

Exercices corrigés

Exercice 1 Compter les comparaisons du tri par sélection

Exercice 2 Gain apporté par une table triée

Exercice 3 Classer des villes selon plusieurs critères

Quiz

Les questions qu'on se pose

Sources

Primaire

Collège

Lycée

Supérieur