Trier des listes

Trier une liste est l'une des opérations les plus courantes en Python. Python vous offre deux outils intégrés pour cela : la fonction sorted(), qui retourne une nouvelle liste triée sans modifier l'originale, et la méthode list.sort(), qui réordonne la liste sur place. Les deux acceptent un indicateur reverse pour l'ordre décroissant et un paramètre key pour une logique de tri personnalisée.

Ce chapitre couvre :

• sorted() — trier n'importe quel itérable dans une nouvelle liste
• list.sort() — trier une liste sur place
• Trier par ordre croissant et décroissant
• Le paramètre key — trier par longueur, champ ou tout critère personnalisé
• Le tri insensible à la casse
• Trier des listes de dictionnaires et d'objets personnalisés
• Le tri multi-critères
• operator.itemgetter comme alternative efficace aux lambdas

Pour un rappel sur les fondamentaux des listes, consultez les chapitres Listes Python et Méthodes de liste.

La fonction sorted()

sorted() prend n'importe quel itérable (liste, tuple, string, …) et retourne une nouvelle liste triée. L'itérable original reste inchangé.

Syntaxe :

sorted(iterable, *, key=None, reverse=False)

• iterable — la séquence à trier
• key — une fonction optionnelle à un argument appliquée à chaque élément avant la comparaison (par défaut : comparer les éléments directement)
• reverse — définir à True pour trier par ordre décroissant (par défaut : False)

Trier une liste de strings

Trier une liste de nombres

Les listes numériques sont triées par magnitude, et non par représentation sous forme de string (ainsi 10 ne se trie pas avant 9).

nums = [3, 1, 4, 1, 5, 9, 2, 6]
print(sorted(nums))
# [1, 1, 2, 3, 4, 5, 6, 9]

Trier par ordre décroissant avec reverse=True

Passez reverse=True pour obtenir les valeurs les plus grandes en premier.

nums = [3, 1, 4, 1, 5, 9, 2, 6]
print(sorted(nums, reverse=True))
# [9, 6, 5, 4, 3, 2, 1, 1]

La méthode list.sort()

list.sort() réordonne la liste sur place et retourne toujours None. Utilisez-la lorsque vous n'avez plus besoin de l'ordre original et que vous souhaitez éviter la surcharge mémoire d'une seconde liste.

Syntaxe :

list.sort(*, key=None, reverse=False)

Les paramètres sont identiques à ceux de sorted().

Trier une liste sur place

Trier par ordre décroissant

sort() retourne None — un piège courant

Une erreur fréquente consiste à assigner le résultat de sort() à une variable :

fruits = ['banana', 'apple', 'cherry']
result = fruits.sort()   # sort() modifies fruits, returns None
print(result)            # None  ← not the sorted list!
print(fruits)            # ['apple', 'banana', 'cherry']  ← fruits was modified

Si vous avez besoin à la fois du résultat trié et de l'ordre original, utilisez sorted() à la place.

sorted() vs list.sort() — Quand utiliser lequel

Utilisez sorted() lorsque vous avez besoin que l'original reste inchangé, ou lorsque vous triez un tuple ou un autre itérable.

Utilisez list.sort() lorsque vous avez une liste, que vous souhaitez la trier sur place, et que l'efficacité mémoire compte.

Trier avec le paramètre key

Le paramètre key accepte un callable à un argument. Python l'appelle une fois sur chaque élément et utilise la valeur retournée pour les comparaisons. Cela évite de dupliquer les données et rend le tri flexible.

Trier par longueur de string

words = ['banana', 'apple', 'cherry', 'kiwi']
print(sorted(words, key=len))
# ['kiwi', 'apple', 'banana', 'cherry']

len est passé directement — aucun lambda n'est nécessaire lorsqu'on utilise une fonction intégrée qui prend un argument.

Trier une liste de tuples par un champ spécifique

Le lambda lambda x: x[1] extrait le second élément (le nombre) de chaque tuple, permettant à Python de comparer des nombres plutôt que des tuples entiers.

Trier une liste de dictionnaires

students = [
    {'name': 'Charlie', 'grade': 85},
    {'name': 'Alice',   'grade': 92},
    {'name': 'Bob',     'grade': 78},
]

by_grade = sorted(students, key=lambda s: s['grade'])
for s in by_grade:
    print(s['name'], s['grade'])
# Bob 78
# Charlie 85
# Alice 92

Pour trier par ordre décroissant (note la plus élevée en premier), ajoutez reverse=True :

by_grade_desc = sorted(students, key=lambda s: s['grade'], reverse=True)
for s in by_grade_desc:
    print(s['name'], s['grade'])
# Alice 92
# Charlie 85
# Bob 78

Tri insensible à la casse

Par défaut, le tri de Python est sensible à la casse : toutes les lettres majuscules viennent avant les minuscules car elles ont des points de code Unicode plus faibles. Utilisez key=str.lower pour trier sans tenir compte de la casse.

words = ['Banana', 'apple', 'Cherry', 'date']
print(sorted(words))             # case-sensitive (uppercase first)
# ['Banana', 'Cherry', 'apple', 'date']

print(sorted(words, key=str.lower))  # case-insensitive
# ['apple', 'Banana', 'Cherry', 'date']

Utiliser operator.itemgetter et operator.attrgetter

Le module operator fournit des alternatives plus rapides aux lambdas pour les patterns de clés courants.

operator.itemgetter — pour les séquences et les dicts

import operator

fruits = [('apple', 10), ('banana', 5), ('cherry', 20)]
print(sorted(fruits, key=operator.itemgetter(1)))
# [('banana', 5), ('apple', 10), ('cherry', 20)]

operator.itemgetter(1) est équivalent à lambda x: x[1] mais est implémenté en C et s'exécute plus rapidement sur les grandes listes.

operator.attrgetter — pour les objets

import operator

class Student:
    def __init__(self, name, grade):
        self.name = name
        self.grade = grade
    def __repr__(self):
        return f'Student({self.name!r}, {self.grade})'

students = [Student('Charlie', 85), Student('Alice', 92), Student('Bob', 78)]
print(sorted(students, key=operator.attrgetter('grade')))
# [Student('Bob', 78), Student('Charlie', 85), Student('Alice', 92)]

Tri multi-critères

Retournez un tuple depuis la fonction key pour trier selon plusieurs critères. Python compare les tuples élément par élément, de sorte que les égalités sur le premier critère se reportent sur le second.

# Sort by grade ascending, then by name alphabetically when grades tie
data = [('Alice', 85), ('Bob', 92), ('Charlie', 85), ('Dave', 78)]
result = sorted(data, key=lambda x: (x[1], x[0]))
print(result)
# [('Dave', 78), ('Alice', 85), ('Charlie', 85), ('Bob', 92)]

Alice et Charlie ont tous les deux la note 85, ils sont donc triés par ordre alphabétique — Alice avant Charlie.

Stabilité du tri

Le tri de Python est stable : les éléments dont la comparaison est égale conservent leur ordre relatif d'origine. Cela signifie que vous pouvez trier une liste selon un critère, puis trier le résultat selon un autre critère, et l'ordre du premier tri est préservé en cas d'égalité sur le second critère.

# Sort by grade, then (stably) by name — same result as the tuple key above
data = [('Alice', 85), ('Bob', 92), ('Charlie', 85), ('Dave', 78)]
step1 = sorted(data, key=lambda x: x[0])   # sort by name first
step2 = sorted(step1, key=lambda x: x[1])  # then sort by grade
print(step2)
# [('Dave', 78), ('Alice', 85), ('Charlie', 85), ('Bob', 92)]

Cette technique — appelée transformation de Schwartzian — est parfois plus lisible qu'une clé composite.

Conclusion

Les fonctions sorted() et list.sort() de Python vous offrent un tri de listes rapide et flexible avec un minimum de code. Utilisez sorted() lorsque vous avez besoin d'une nouvelle liste ou que vous triez un itérable non-liste ; utilisez list.sort() lorsque vous souhaitez modifier une liste sur place. Le paramètre key gère presque n'importe quel critère de tri — du tri par longueur ou champ de dict aux comparaisons insensibles à la casse. Pour les grands ensembles de données, préférez operator.itemgetter ou operator.attrgetter aux lambdas pour de meilleures performances.

Lectures associées :

• Listes Python — création, indexation et découpage de listes
• Méthodes de liste — référence complète des méthodes de liste
• Compréhension de liste — construction concise de listes
• Itérer sur des listes — itération sur les listes

Exercices pratiques