Skip to content

Pandas Sort Values : Guide complet pour trier les DataFrames en Python

Soren Atelier
Name
Soren Atelier

Updated on

Les données non triées sont difficiles à analyser. Vous parcourez des milliers de lignes en essayant de trouver les ventes les plus élevées, les dates les plus récentes ou les taux d'erreur les plus bas -- et vous manquez des patterns qui seraient évidents si les données étaient ordonnées. Le tri d'une liste Python fonctionne pour les cas simples, mais les DataFrames ont plusieurs colonnes, des types mixtes et des valeurs manquantes que les listes ne peuvent pas gérer.

Pandas sort_values() trie n'importe quel DataFrame par une ou plusieurs colonnes, avec un contrôle total sur l'ordre croissant/décroissant, le placement des null et la stabilité. Ce guide couvre tous les patterns de tri que vous rencontrerez dans le travail réel avec les données.

📚

    Tri de base avec sort_values()

    Trier par une seule colonne

    import pandas as pd
 
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve'],
    'score': [85, 92, 78, 95, 88],
    'age': [25, 30, 22, 28, 35]
})
 
# Trier par score (croissant par défaut)
sorted_df = df.sort_values('score')
print(sorted_df)
#       name  score  age
# 2  Charlie     78   22
# 0    Alice     85   25
# 4      Eve     88   35
# 1      Bob     92   30
# 3    Diana     95   28

    Tri décroissant

    import pandas as pd
 
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve'],
    'score': [85, 92, 78, 95, 88],
    'age': [25, 30, 22, 28, 35]
})
 
# Scores les plus élevés en premier
sorted_df = df.sort_values('score', ascending=False)
print(sorted_df)
#       name  score  age
# 3    Diana     95   28
# 1      Bob     92   30
# 4      Eve     88   35
# 0    Alice     85   25
# 2  Charlie     78   22

    Tri en place

    import pandas as pd
 
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie'],
    'score': [85, 92, 78]
})
 
# Modifier df directement (aucune copie créée)
df.sort_values('score', inplace=True)
print(df)
#       name  score
# 2  Charlie     78
# 0    Alice     85
# 1      Bob     92

    Tri multi-colonnes

    Trier par plusieurs colonnes

    import pandas as pd
 
df = pd.DataFrame({
    'department': ['Sales', 'Engineering', 'Sales', 'Engineering', 'Sales'],
    'name': ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve'],
    'salary': [70000, 85000, 65000, 90000, 70000]
})
 
# Trier d'abord par département, puis par salaire dans chaque département
sorted_df = df.sort_values(['department', 'salary'])
print(sorted_df)
#     department     name  salary
# 1  Engineering      Bob   85000
# 3  Engineering    Diana   90000
# 2        Sales  Charlie   65000
# 0        Sales    Alice   70000
# 4        Sales      Eve   70000

    Mélange croissant/décroissant

    import pandas as pd
 
df = pd.DataFrame({
    'department': ['Sales', 'Engineering', 'Sales', 'Engineering', 'Sales'],
    'name': ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve'],
    'salary': [70000, 85000, 65000, 90000, 70000]
})
 
# Département croissant, salaire décroissant
sorted_df = df.sort_values(
    ['department', 'salary'],
    ascending=[True, False]
)
print(sorted_df)
#     department     name  salary
# 3  Engineering    Diana   90000
# 1  Engineering      Bob   85000
# 0        Sales    Alice   70000
# 4        Sales      Eve   70000
# 2        Sales  Charlie   65000

    Gestion des valeurs manquantes (NaN)

    Par défaut, les valeurs NaN sont placées à la fin quel que soit l'ordre de tri. Utilisez na_position pour contrôler cela :

    import pandas as pd
import numpy as np
 
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie', 'Diana'],
    'score': [85, np.nan, 78, np.nan]
})
 
# NaN à la fin (par défaut)
print(df.sort_values('score'))
#       name  score
# 2  Charlie   78.0
# 0    Alice   85.0
# 1      Bob    NaN
# 3    Diana    NaN
 
# NaN au début
print(df.sort_values('score', na_position='first'))
#       name  score
# 1      Bob    NaN
# 3    Diana    NaN
# 2  Charlie   78.0
# 0    Alice   85.0

    Trier par index avec sort_index()

    import pandas as pd
 
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie'],
    'score': [85, 92, 78]
}, index=[2, 0, 1])
 
# Trier par index
print(df.sort_index())
#      name  score
# 0     Bob     92
# 1  Charlie    78
# 2   Alice     85
 
# Trier par noms de colonnes (axis=1)
df2 = pd.DataFrame({
    'c': [1, 2], 'a': [3, 4], 'b': [5, 6]
})
print(df2.sort_index(axis=1))
#    a  b  c
# 0  3  5  1
# 1  4  6  2

    Réinitialiser l'index après le tri

    Après le tri, l'index original est conservé. Pour obtenir un index séquentiel propre :

    import pandas as pd
 
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie'],
    'score': [85, 92, 78]
})
 
sorted_df = df.sort_values('score').reset_index(drop=True)
print(sorted_df)
#       name  score
# 0  Charlie     78
# 1    Alice     85
# 2      Bob     92

    Utilisez drop=True pour supprimer l'ancien index. Sans ce paramètre, l'ancien index devient une colonne.

    Ordre de tri personnalisé

    Utilisation des types catégoriels

    import pandas as pd
 
df = pd.DataFrame({
    'priority': ['Medium', 'High', 'Low', 'High', 'Medium'],
    'task': ['Task A', 'Task B', 'Task C', 'Task D', 'Task E']
})
 
# Définir un ordre personnalisé
priority_order = pd.CategoricalDtype(['Low', 'Medium', 'High'], ordered=True)
df['priority'] = df['priority'].astype(priority_order)
 
sorted_df = df.sort_values('priority')
print(sorted_df)
#   priority    task
# 2      Low  Task C
# 0   Medium  Task A
# 4   Medium  Task E
# 1     High  Task B
# 3     High  Task D

    Utilisation du paramètre key

    import pandas as pd
 
df = pd.DataFrame({
    'name': ['alice', 'Bob', 'CHARLIE', 'diana'],
    'score': [85, 92, 78, 95]
})
 
# Tri insensible à la casse
sorted_df = df.sort_values('name', key=lambda x: x.str.lower())
print(sorted_df)
#       name  score
# 0    alice     85
# 1      Bob     92
# 2  CHARLIE     78
# 3    diana     95

    Comparaison des méthodes

    MéthodeObjectifModifie l'original ?Retourne
    sort_values(col)Trier par valeurs de colonneNon (sauf inplace=True)DataFrame trié
    sort_values([col1, col2])Trier par plusieurs colonnesNon (sauf inplace=True)DataFrame trié
    sort_index()Trier par index de ligneNon (sauf inplace=True)DataFrame trié
    nsmallest(n, col)Obtenir les n plus petites valeursNonSous-ensemble de DataFrame
    nlargest(n, col)Obtenir les n plus grandes valeursNonSous-ensemble de DataFrame
    rank()Attribuer des rangs aux valeursNonSeries de rangs

    Conseils de performance

    nlargest() et nsmallest() pour le Top-N

    Quand vous n'avez besoin que des N premières ou dernières lignes, nlargest() et nsmallest() sont plus rapides que le tri de l'ensemble du DataFrame :

    import pandas as pd
import numpy as np
 
# Grand DataFrame
df = pd.DataFrame({
    'id': range(1_000_000),
    'value': np.random.randn(1_000_000)
})
 
# Plus rapide : trouver seulement le top 10
top_10 = df.nlargest(10, 'value')
 
# Plus lent : trie tout, puis découpe
top_10_slow = df.sort_values('value', ascending=False).head(10)

    Tri stable vs instable

    import pandas as pd
 
df = pd.DataFrame({
    'group': ['A', 'B', 'A', 'B'],
    'value': [1, 1, 2, 2],
    'order': [1, 2, 3, 4]
})
 
# Tri stable (par défaut) conserve l'ordre original pour les égalités
stable = df.sort_values('value', kind='mergesort')  # Par défaut
 
# Tri instable (plus rapide pour les grands jeux de données)
unstable = df.sort_values('value', kind='quicksort')

    Exemples pratiques

    Trier des dates

    import pandas as pd
 
df = pd.DataFrame({
    'event': ['Launch', 'Meeting', 'Deadline', 'Review'],
    'date': pd.to_datetime(['2026-03-15', '2026-01-10', '2026-02-28', '2026-01-05'])
})
 
# Ordre chronologique
print(df.sort_values('date'))
#      event       date
# 3   Review 2026-01-05
# 1  Meeting 2026-01-10
# 2 Deadline 2026-02-28
# 0   Launch 2026-03-15

    Tri avec GroupBy

    import pandas as pd
 
df = pd.DataFrame({
    'store': ['A', 'A', 'B', 'B', 'A', 'B'],
    'product': ['X', 'Y', 'X', 'Y', 'Z', 'Z'],
    'revenue': [100, 250, 150, 300, 200, 175]
})
 
# Produit le plus rentable par magasin
top_per_store = (df.sort_values('revenue', ascending=False)
                   .groupby('store')
                   .head(1))
print(top_per_store)
#   store product  revenue
# 3     B       Y      300
# 1     A       Y      250

    Explorer visuellement les données triées

    Après avoir trié votre DataFrame pour trouver des patterns, PyGWalker (opens in a new tab) vous permet d'explorer les mêmes données via des graphiques interactifs par glisser-déposer dans Jupyter -- sans code supplémentaire :

    import pygwalker as pyg
 
walker = pyg.walk(sorted_df)

    FAQ

    Comment trier un DataFrame par colonne dans pandas ?

    Utilisez df.sort_values('column_name') pour l'ordre croissant ou df.sort_values('column_name', ascending=False) pour décroissant. Pour plusieurs colonnes, passez une liste : df.sort_values(['col1', 'col2']).

    Comment trier par plusieurs colonnes avec des ordres différents ?

    Passez une liste de booléens à ascending : df.sort_values(['col1', 'col2'], ascending=[True, False]). Cela trie col1 en croissant et col2 en décroissant.

    Où vont les valeurs NaN lors du tri ?

    Par défaut, les valeurs NaN sont placées à la fin quelle que soit la direction du tri. Utilisez na_position='first' pour les placer au début : df.sort_values('col', na_position='first').

    Quelle est la différence entre sort_values et sort_index ?

    sort_values() trie par valeurs de colonne. sort_index() trie par l'index de ligne (ou l'index de colonne avec axis=1). Utilisez sort_values pour le tri des données et sort_index quand les lignes doivent être ordonnées par leurs étiquettes d'index.

    Comment trier un DataFrame en place sans créer de copie ?

    Passez inplace=True : df.sort_values('col', inplace=True). Cela modifie le DataFrame original et retourne None. Cependant, le style pandas moderne préfère la réaffectation : df = df.sort_values('col').

    Conclusion

    sort_values() est l'outil principal pour trier les DataFrames dans pandas. Utilisez un nom de colonne unique pour les tris simples, une liste pour les tris multi-colonnes et le paramètre ascending pour contrôler la direction. Gérez les valeurs manquantes avec na_position, utilisez nlargest()/nsmallest() pour les requêtes Top-N et CategoricalDtype pour les ordres personnalisés. N'oubliez pas que le tri retourne un nouveau DataFrame par défaut -- utilisez reset_index(drop=True) si vous voulez un index séquentiel propre ensuite.

    📚