Trier des données selon différents critères

Introduction

Trier une table, c’est organiser ses lignes selon l’ordre croissant ou décroissant d’une ou plusieurs de ses colonnes. Ce traitement, fréquent dans l’analyse de données, permet de mettre en valeur les éléments importants, d’améliorer la lisibilité des résultats ou de préparer une visualisation. Dans le cadre du programme de Première NSI, cette opération correspond à la capacité « Trier une table suivant une colonne », située dans l’axe « Explorer des données en table ». Comprendre les techniques de tri, leurs usages et leurs limites permet de structurer efficacement les données, notamment lorsqu’elles sont importées depuis un fichier CSV ou issues d’un programme plus large.

Comprendre le tri d’une table

Le tri repose toujours sur un ou plusieurs critères extraits des données. Ces critères sont appelés clés de tri. Dans une table, chaque ligne est représentée en Python par un dictionnaire (ou un p-uplet nommé), et une table par une liste de ces lignes.

Exemple : trier des livres selon leur nombre de pages.

livres = [
    {"titre": "1984", "pages": 328},
    {"titre": "Le Meilleur des mondes", "pages": 311},
    {"titre": "Fahrenheit 451", "pages": 249}
]

livres_triés = sorted(livres, key=lambda livre: livre["pages"])

La fonction sorted() renvoie une nouvelle table triée selon la valeur associée à la clé « pages ». Le critère peut être inversé pour obtenir un tri décroissant.

livres_triés = sorted(livres, key=lambda livre: livre["pages"], reverse=True)

Ce mécanisme permet de trier n’importe quelle table selon une colonne numérique, textuelle ou même une transformation de la donnée.

À retenir

Le tri consiste à organiser les lignes d’une table selon la valeur d’une clé de tri. En Python, cela se fait avec sorted() et une fonction key qui précise la colonne ou le critère à utiliser.

Trier selon plusieurs critères

Dans de nombreux cas, plusieurs lignes ont la même valeur sur le critère principal. Il faut alors ajouter un second critère pour les départager. C’est ce qu’on appelle un tri lexicographique.

Exemple : trier des étudiants par note décroissante, puis par prénom croissant.

etudiants = [
    {"prenom": "Alice", "note": 15},
    {"prenom": "Bob", "note": 18},
    {"prenom": "Anna", "note": 15}
]

etudiants_triés = sorted(etudiants, key=lambda e: (-e["note"], e["prenom"]))

Ce tri combine deux critères de types différents : un entier puis une chaîne. Cela correspond à une situation réelle fréquente en analyse de données (par exemple, tri par date puis par nom).

Autre exemple avec une date puis un nom :

from datetime import datetime

réunions = [
    {"date": "2024-05-20", "nom": "Durand"},
    {"date": "2024-05-20", "nom": "Abel"},
    {"date": "2024-04-18", "nom": "Bernard"}
]

réunions_triées = sorted(
    réunions,
    key=lambda r: (datetime.strptime(r["date"], "%Y-%m-%d"), r["nom"])
)

À retenir

Le tri lexicographique permet de trier selon plusieurs colonnes : Python compare successivement les éléments d’un tuple retourné par la fonction key.

Importer et trier une table depuis un fichier CSV

Le format CSV (Comma-Separated Values) est très utilisé pour stocker des données tabulaires. Chaque ligne correspond à un enregistrement, et les colonnes sont séparées par des virgules (ou d'autres séparateurs comme le point-virgule). Il est essentiel de gérer correctement l'encodage (souvent UTF-8) et le type des données lors de l'import.

Exemple : trier des scores extraits d’un fichier scores.csv.

Contenu du fichier :

joueur;score
Léa;980
Tom;1200
Ali;980

Lecture et tri :

import csv

with open("scores.csv", newline="", encoding="utf-8") as fichier:
    lecteur = csv.DictReader(fichier, delimiter=";")
    table = list(lecteur)

for ligne in table:
    ligne["score"] = int(ligne["score"])

table_triée = sorted(table, key=lambda l: (-l["score"], l["joueur"]))

Cette approche permet de traiter des données provenant d’un outil externe (feuille de calcul, base de données, export logiciel).

À retenir

Les fichiers CSV permettent d’importer des données structurées. Après conversion des types (ex. : int), on peut trier la table comme n’importe quelle liste de dictionnaires.

Cas complexes : valeurs manquantes et types hétérogènes

Dans les données réelles, certaines valeurs peuvent être manquantes (par exemple None) ou de types différents dans une même colonne. Cela peut provoquer des erreurs lors du tri, car Python ne peut pas comparer des objets de types incompatibles.

Exemple de tri avec gestion des valeurs absentes :

notes = [
    {"nom": "Léo", "note": 15},
    {"nom": "Chloé", "note": None},
    {"nom": "Sami", "note": 18}
]

notes_triées = sorted(notes, key=lambda l: (l["note"] is None, l["note"]))

Les élèves sans note sont placés en fin de liste. On évite ainsi les erreurs de comparaison.

En présence de types mixtes (ex. : entiers et chaînes), il est souvent préférable de forcer une conversion commune avant de trier, par exemple avec str().

À retenir

En cas de valeurs manquantes ou de types hétérogènes, il faut adapter la fonction key pour éviter les erreurs de comparaison et garantir un comportement maîtrisé du tri.

Extensions : lisibilité et alternatives à lambda

Python propose d'autres outils pour rendre le tri plus lisible, notamment le module operator, qui offre la fonction itemgetter. Celle-ci permet d’extraire une ou plusieurs clés d’un dictionnaire de manière plus concise.

Exemple équivalent au tri précédent :

from operator import itemgetter

triés = sorted(etudiants, key=itemgetter("note"))

Pour un tri multi-critères :

triés = sorted(etudiants, key=itemgetter("note", "prenom"))

Cette méthode est parfois plus rapide que lambda, car elle est implémentée en langage natif, et souvent plus claire pour les tris simples.

À retenir

La fonction itemgetter du module operator permet d’écrire des tris plus concis et plus performants que des fonctions lambda dans certains cas.

Enjeux pratiques : stabilité, mémoire, complexité

Trois aspects importants méritent d’être connus lorsque l’on trie une table :

• Tri stable : un tri est dit stable lorsqu’il conserve l’ordre initial des éléments égaux. Cela permet de combiner plusieurs tris en enchaînant les critères du moins prioritaire au plus prioritaire.

Exemple :

personnes = [
    {"nom": "Alice", "ville": "Paris"},
    {"nom": "Bob", "ville": "Paris"},
    {"nom": "Charlie", "ville": "Lyon"}
]

# Tri d’abord par nom
personnes.sort(key=lambda p: p["nom"])

# Puis tri par ville
personnes.sort(key=lambda p: p["ville"])

Le second tri conserve l’ordre alphabétique des noms pour les personnes habitant la même ville.

• Consommation mémoire : sorted() crée une nouvelle table, donc nécessite de la mémoire supplémentaire. .sort() modifie la table existante, ce qui est plus économe.

• Complexité : les algorithmes de tri intégrés de Python (Timsort) ont une complexité moyenne de O(n log n), ce qui les rend très efficaces même sur de grandes quantités de données.

Tableau récapitulatif :

À retenir

Le tri intégré de Python est stable, rapide et fiable. Le choix entre sorted() et .sort() dépend des contraintes de mémoire et de conservation des données originales.

Conclusion

Le tri de données en table est une étape essentielle pour structurer, comprendre et exploiter les informations. Que ce soit sur un seul critère, sur plusieurs critères de types variés, avec des valeurs manquantes ou après importation depuis un fichier CSV, les outils offerts par Python permettent de répondre efficacement aux besoins concrets de traitement. Ces techniques constituent un socle pour aborder d’autres opérations comme la recherche, la fusion ou l’agrégation, qui prolongent l’exploration des données en profondeur.