OUJOOD.COM
Trier une collection de données est l'une des opérations les plus courantes en programmation. Python propose deux outils pour ça : la méthode list.sort() qui trie la liste sur place, et la fonction sorted() qui retourne une nouvelle liste triée sans toucher à l'originale. Les deux acceptent les mêmes paramètres et sont très efficaces — Python utilise l'algorithme Timsort, conçu pour performer aussi bien sur des données déjà partiellement triées.
sort() vs sorted() : la différence fondamentale
nombres = [5, 2, 8, 1, 9, 3] # sort() : modifie la liste en place, retourne None nombres.sort() print(nombres) # Résultat : [1, 2, 3, 5, 8, 9] # sorted() : retourne une nouvelle liste, l'originale est intacte original = [5, 2, 8, 1, 9, 3] trie = sorted(original) print(trie) # Résultat : [1, 2, 3, 5, 8, 9] print(original) # Résultat : [5, 2, 8, 1, 9, 3] — inchangé
Règle simple : utilisez sort() quand vous n'avez plus besoin de l'ordre original. Utilisez sorted() quand vous voulez conserver la liste d'origine intacte, ou trier un itérable qui n'est pas une liste (tuple, chaîne, générateur).
Tri en ordre décroissant
Le paramètre reverse=True inverse l'ordre du tri.
notes = [14, 8, 17, 12, 19, 11] # Ordre décroissant avec sorted() print(sorted(notes, reverse=True)) # Résultat : [19, 17, 14, 12, 11, 8] # Ordre décroissant avec sort() notes.sort(reverse=True) print(notes) # Résultat : [19, 17, 14, 12, 11, 8] # Trier une liste de chaînes par ordre alphabétique inverse fruits = ["pomme", "abricot", "cerise", "banane"] print(sorted(fruits, reverse=True)) # Résultat : ['pomme', 'cerise', 'banane', 'abricot']
Tri avec une clé personnalisée : key=
Le paramètre key= accepte une fonction qui sera appliquée à chaque élément avant la comparaison. Le tri se fait sur la valeur retournée par cette fonction, pas sur l'élément lui-même.
mots = ["Banane", "abricot", "Cerise", "pomme"] # Tri alphabétique par défaut (majuscules avant minuscules) print(sorted(mots)) # Résultat : ['Banane', 'Cerise', 'abricot', 'pomme'] # Tri insensible à la casse avec key=str.lower print(sorted(mots, key=str.lower)) # Résultat : ['abricot', 'Banane', 'Cerise', 'pomme'] # Tri par longueur de mot print(sorted(mots, key=len)) # Résultat : ['pomme', 'Banane', 'abricot', 'Cerise']
Tri avec une fonction lambda
Quand la clé de tri nécessite une logique personnalisée, on utilise une fonction lambda — une fonction anonyme d'une seule expression.
# Trier des nombres par leur valeur absolue nombres = [-5, 3, -1, 8, -4, 2] print(sorted(nombres, key=lambda x: abs(x))) # Résultat : [-1, 2, 3, -4, -5, 8] # Trier des tuples par le deuxième élément scores = [("Alice", 88), ("Bob", 72), ("Claire", 95), ("David", 61)] print(sorted(scores, key=lambda x: x[1])) # Résultat : [('David', 61), ('Bob', 72), ('Alice', 88), ('Claire', 95)] # Tri décroissant sur le deuxième élément print(sorted(scores, key=lambda x: x[1], reverse=True)) # Résultat : [('Claire', 95), ('Alice', 88), ('Bob', 72), ('David', 61)]
Trier une liste de dictionnaires
C'est un cas très courant : trier des enregistrements issus d'une API ou d'une base de données par un champ précis.
from operator import itemgetter
eleves = [
{"nom": "Alice", "note": 17, "age": 20},
{"nom": "Bob", "note": 12, "age": 22},
{"nom": "Claire","note": 15, "age": 19},
{"nom": "David", "note": 17, "age": 21},
]
# Trier par note (lambda)
par_note = sorted(eleves, key=lambda e: e["note"], reverse=True)
for e in par_note:
print(f"{e['nom']} : {e['note']}")
# Résultat : Alice 17, David 17, Claire 15, Bob 12
# Avec operator.itemgetter (plus rapide que lambda pour ce cas)
par_nom = sorted(eleves, key=itemgetter("nom"))
print([e["nom"] for e in par_nom])
# Résultat : ['Alice', 'Bob', 'Claire', 'David']
Tri sur plusieurs critères
Pour trier sur plusieurs champs (d'abord par note décroissante, ensuite par nom alphabétique en cas d'égalité), retournez un tuple depuis la fonction key=.
eleves = [
{"nom": "Alice", "note": 17},
{"nom": "David", "note": 17},
{"nom": "Claire","note": 15},
{"nom": "Bob", "note": 12},
]
# Note décroissante, puis nom alphabétique en cas d'égalité
# -e["note"] pour inverser le tri de la note sans reverse=True
trie = sorted(eleves, key=lambda e: (-e["note"], e["nom"]))
for e in trie:
print(f"{e['nom']} : {e['note']}")
# Résultat :
# Alice : 17 (même note que David, mais A avant D)
# David : 17
# Claire : 15
# Bob : 12
sorted() fonctionne sur tout itérable
Contrairement à sort() qui n'existe que sur les listes, sorted() accepte n'importe quel itérable : tuple, chaîne, dictionnaire, ensemble.
# Trier un tuple → retourne une liste print(sorted((5, 2, 8, 1))) # Résultat : [1, 2, 5, 8] # Trier les caractères d'une chaîne print(sorted("python")) # Résultat : ['h', 'n', 'o', 'p', 't', 'y'] # Trier les clés d'un dictionnaire scores = {"Bob": 72, "Alice": 88, "Claire": 95} print(sorted(scores)) # Résultat : ['Alice', 'Bob', 'Claire']
Par carabde | Mis à jour le 21 avril 2026