Trier les lignes en R : order() et arrange() de dplyr

Trier un data frame selon une ou plusieurs colonnes, en ordre croissant ou décroissant — base R et dplyr

Réordonner (trier) les lignes d’un data frame en R avec order() de base R et arrange() de dplyr. Triez en ordre croissant ou décroissant, selon plusieurs colonnes à la fois, et dans un ordre personnalisé — ainsi que la différence entre order() et sort() et où atterrissent les valeurs manquantes. Les deux approches, côte à côte.

AstucePoints clés

• base R : df[order(df$x), ] trie les lignes selon la colonne x ; order(df$x, decreasing = TRUE) pour un tri décroissant.
• dplyr : arrange(df, x) trie en ordre croissant ; arrange(df, desc(x)) trie en ordre décroissant.
• Plusieurs clés : order(df$x, df$y) et arrange(df, x, y) trient selon x, en départageant les égalités avec y.
• order() renvoie les positions qui trient les données ; sort() renvoie les valeurs triées — on réordonne les lignes avec order().
• Les valeurs manquantes vont en dernier par défaut dans les deux cas ; contrôlez ce comportement avec na.last (base R) — arrange() place toujours NA en dernier.

Introduction

Vous voulez votre tableau trié — les scores les plus élevés en premier, par ordre alphabétique selon le groupe, ou du plus ancien au plus récent par date. Réordonner les lignes rend un data frame plus facile à lire, prépare une étape « garder le top N », ou range les enregistrements avant une déduplication.

Il existe deux approches, et vous rencontrerez les deux dans du vrai code :

• base R — order() renvoie les positions des lignes qui mettent une colonne en ordre ; indexez avec elles.
• dplyr — arrange() trie en un seul appel lisible, avec desc() pour le tri décroissant.

Cette leçon présente les deux approches, côte à côte, pour trier en ordre croissant, décroissant, selon plusieurs colonnes et dans un ordre personnalisé. Les deux donnent le même résultat.

Nous utilisons le jeu de données intégré mtcars. Nous garderons trois colonnes et quelques lignes pour que le tri soit facile à observer :

cars <- head(mtcars[, c("mpg", "cyl", "hp")], 6)
cars

                   mpg cyl  hp
Mazda RX4         21.0   6 110
Mazda RX4 Wag     21.0   6 110
Datsun 710        22.8   4  93
Hornet 4 Drive    21.4   6 110
Hornet Sportabout 18.7   8 175
Valiant           18.1   6 105

Les lignes commencent dans leur ordre d’origine (par nom de modèle). Réordonnons-les.

Trier selon une colonne (croissant)

base R — order()

order(df$mpg) renvoie les positions des lignes qui mettraient mpg en ordre croissant — et non les valeurs triées. Utilisez ce vecteur pour réordonner les lignes :

cars[order(cars$mpg), ]

                   mpg cyl  hp
Valiant           18.1   6 105
Hornet Sportabout 18.7   8 175
Mazda RX4         21.0   6 110
Mazda RX4 Wag     21.0   6 110
Hornet 4 Drive    21.4   6 110
Datsun 710        22.8   4  93

Lisez-le comme « donne-moi les lignes de cars, dans l’ordre qui trie mpg ». Le mpg le plus faible est maintenant en premier. La virgule compte : cars[order(cars$mpg), ] réordonne les lignes (et garde toutes les colonnes) — n’oubliez pas la virgule finale.

dplyr — arrange()

arrange() trie en ordre croissant selon la colonne nommée — pas d’indexation, pas de virgule :

library(dplyr)
arrange(cars, mpg)

                   mpg cyl  hp
Valiant           18.1   6 105
Hornet Sportabout 18.7   8 175
Mazda RX4         21.0   6 110
Mazda RX4 Wag     21.0   6 110
Hornet 4 Drive    21.4   6 110
Datsun 710        22.8   4  93

Même ordre des lignes que l’approche base R. arrange() est le raccourci lisible de df[order(df$x), ].

Trier en ordre décroissant

base R — decreasing = TRUE ou négation

Pour une colonne numérique, passez soit decreasing = TRUE, soit triez selon la colonne négativée :

cars[order(cars$mpg, decreasing = TRUE), ]

                   mpg cyl  hp
Datsun 710        22.8   4  93
Hornet 4 Drive    21.4   6 110
Mazda RX4         21.0   6 110
Mazda RX4 Wag     21.0   6 110
Hornet Sportabout 18.7   8 175
Valiant           18.1   6 105

La négation (order(-cars$mpg)) donne le même résultat pour les nombres et s’avère pratique quand vous voulez certaines clés décroissantes et d’autres croissantes (section suivante). decreasing = TRUE inverse toutes les clés d’un coup.

dplyr — desc()

Enveloppez la colonne dans desc() pour la trier du plus grand au plus petit :

library(dplyr)
arrange(cars, desc(mpg))

                   mpg cyl  hp
Datsun 710        22.8   4  93
Hornet 4 Drive    21.4   6 110
Mazda RX4         21.0   6 110
Mazda RX4 Wag     21.0   6 110
Hornet Sportabout 18.7   8 175
Valiant           18.1   6 105

Le mpg le plus élevé en premier — le même ordre que l’approche base R avec decreasing = TRUE.

Trier selon plusieurs colonnes

Pour départager les égalités, donnez plus de colonnes. La première colonne trie ; la seconde décide de l’ordre au sein des valeurs égales de la première, et ainsi de suite.

base R — plusieurs clés, direction mixte

Listez les clés dans order(). Négativez une clé numérique pour trier celle-là en ordre décroissant tandis que les autres restent croissantes — ici on trie selon cyl croissant, puis hp décroissant au sein de chaque cyl :

cars[order(cars$cyl, -cars$hp), ]

                   mpg cyl  hp
Datsun 710        22.8   4  93
Mazda RX4         21.0   6 110
Mazda RX4 Wag     21.0   6 110
Hornet 4 Drive    21.4   6 110
Valiant           18.1   6 105
Hornet Sportabout 18.7   8 175

Au sein de chaque groupe de cylindres, la voiture la plus puissante vient en premier.

dplyr — arrange(x, desc(y))

Listez les colonnes ; enveloppez dans desc() celles que vous voulez décroissantes :

library(dplyr)
arrange(cars, cyl, desc(hp))

                   mpg cyl  hp
Datsun 710        22.8   4  93
Mazda RX4         21.0   6 110
Mazda RX4 Wag     21.0   6 110
Hornet 4 Drive    21.4   6 110
Valiant           18.1   6 105
Hornet Sportabout 18.7   8 175

Même ordre : cyl croissant, hp décroissant au sein de chaque groupe. arrange() se lit presque comme la phrase qui décrit le tri.

Trier dans un ordre personnalisé

Parfois l’ordre voulu n’est ni alphabétique ni numérique — par exemple, low < medium < high. Encodez cet ordre dans un facteur, puis triez selon lui. Les levels du facteur définissent l’ordre.

sizes <- data.frame(
  item = c("box", "crate", "bag"),
  size = c("high", "low", "medium")
)

# Define the order with factor levels
sizes$size <- factor(sizes$size, levels = c("low", "medium", "high"))

sizes[order(sizes$size), ]

   item   size
2 crate    low
3   bag medium
1   box   high

Les lignes ressortent dans l’ordre low, medium, high — l’ordre des niveaux, pas l’ordre alphabétique. arrange(sizes, size) trie le même facteur de façon identique. C’est la manière standard d’imposer un ordre logique (non alphabétique) aux catégories.

Essayez en direct

Les blocs ci-dessus ont été exécutés au moment de la compilation. Modifiez celui-ci et appuyez sur Run pour réordonner les lignes par vous-même — il s’exécute dans votre navigateur via webR (sans installation).

🟢 Avec un agent IA

Collez le names() de votre data frame et demandez à Prova « trie ces lignes par date décroissante, en départageant les égalités par nom de client » — elle écrit l’appel arrange() (ou order()), et comme le runtime est juste là, vous l’exécutez pour confirmer que les lignes atterrissent dans l’ordre voulu sur vos données. Demander à Prova →

Vous travaillez en Python ? Un guide pandas sort_values arrive dans la série Python.

Problèmes courants

sort() renvoie une seule colonne, pas le data frame réordonné. sort() trie un vecteur de valeurs ; il ne peut pas réordonner un data frame. Pour trier les lignes, vous avez besoin des positions qui trient une colonne — c’est order() : df[order(df$x), ]. N’oubliez pas la virgule finale, sinon vous sélectionnerez des colonnes au lieu des lignes.

Le tri semble alphabétique alors que vous vouliez un ordre logique. Les colonnes de caractères se trient par ordre alphabétique, donc "high", "low", "medium" ressortent dans cet ordre (incorrect). Convertissez la colonne en facteur avec des levels explicites dans l’ordre voulu, puis triez selon elle.

Les valeurs manquantes finissent là où vous ne vous y attendiez pas. Par défaut, order() et arrange() poussent tous deux NA vers le bas. En base R, passez order(df$x, na.last = FALSE) pour envoyer NA en haut, ou na.last = NA pour supprimer ces lignes du résultat. arrange() trie toujours NA en dernier, quelle que soit la direction.

Questions fréquentes

NoteComment trier un data frame en R ?

Base R : df[order(df$x), ] trie les lignes selon la colonne x. dplyr : arrange(df, x). Les deux trient en ordre croissant par défaut et donnent le même ordre des lignes.

NoteComment trier en ordre décroissant en R ?

Base R : df[order(df$x, decreasing = TRUE), ], ou négativez une colonne numérique avec order(-df$x). dplyr : enveloppez la colonne dans desc() — arrange(df, desc(x)).

NoteComment trier selon plusieurs colonnes en R ?

Listez les clés : df[order(df$a, df$b), ] ou arrange(df, a, b). La première colonne trie, la seconde départage les égalités. Mélangez les directions en négativant une clé base R (order(df$a, -df$b)) ou en enveloppant une clé dplyr dans desc().

NoteQuelle est la différence entre sort() et order() en R ?

sort() renvoie les valeurs triées d’un vecteur ; order() renvoie les positions qui mettent un vecteur en ordre. On réordonne les lignes d’un data frame avec order() — df[order(df$x), ] — parce qu’on a besoin des positions pour indexer les lignes, pas seulement des valeurs.

NoteComment trier les lignes dans un ordre personnalisé (non alphabétique) ?

Faites de la colonne un facteur avec les levels dans l’ordre voulu — factor(x, levels = c("low", "medium", "high")) — puis triez selon lui avec order() ou arrange(). L’ordre des niveaux du facteur pilote le tri à la place de l’ordre alphabétique.

Testez vos connaissances

ImportantExercice : trier de deux façons

Triez le data frame ci-dessous selon cyl en ordre croissant, puis selon mpg en ordre décroissant au sein de chaque groupe de cylindres — d’abord avec order() de base R, puis avec arrange() de dplyr — et vérifiez que les deux donnent des ordres de lignes identiques.

# base R: order(cars$cyl, -cars$mpg)  -> negate mpg for descending
# dplyr:  arrange(cars, cyl, desc(mpg))

library(dplyr) cars <- head(mtcars[, c("mpg", "cyl", "hp")], 6) base_way <- cars[order(cars$cyl, -cars$mpg), ] dplyr_way <- arrange(cars, cyl, desc(mpg)) identical(base_way, dplyr_way) # TRUE

library(dplyr)

cars <- head(mtcars[, c("mpg", "cyl", "hp")], 6)

base_way  <- cars[order(cars$cyl, -cars$mpg), ]
dplyr_way <- arrange(cars, cyl, desc(mpg))

identical(base_way, dplyr_way)  # TRUE

NoteVérification rapide : laquelle trie mpg du plus grand au plus petit ?

Vous voulez trier mtcars selon mpg en ordre décroissant. Laquelle est correcte ?

A. sort(mtcars$mpg, decreasing = TRUE) B. mtcars[order(mtcars$mpg, decreasing = TRUE), ] C. arrange(mtcars, mpg)

Afficher la réponse

B. order(..., decreasing = TRUE) renvoie les positions qui trient mpg du plus grand au plus petit, et indexer avec elles réordonne tout le data frame. A ne renvoie que les valeurs mpg triées (le reste du tableau est perdu). C trie en ordre croissant — il faudrait arrange(mtcars, desc(mpg)).

Conclusion

Réordonner les lignes se résume à deux outils équivalents : df[order(df$x), ] de base R (négativez ou decreasing = TRUE pour le tri décroissant) ou arrange(df, x) de dplyr (avec desc() pour le tri décroissant). Listez plusieurs clés pour départager les égalités, encodez les levels d’un facteur pour un ordre personnalisé, et rappelez-vous que order() renvoie des positions tandis que sort() renvoie des valeurs.

Leçons connexes

• Supprimer les doublons en R — éliminer les lignes répétées (souvent après un tri). · Filtrer les lignes en R — filtrer les observations selon une condition. · Sélectionner des colonnes en R — garder ou supprimer des colonnes. · Renommer les colonnes en R — nettoyer les noms de colonnes.
• Aller plus loin : Data Wrangling — la série complète. · Computational Science & AI — le pilier.

Cette page vous a-t-elle été utile ?

Prouvez que vous savez le faire. Maîtrisez toute la série Manipulation de données en R et Python — suivez votre parcours, construisez des projets et obtenez un certificat.

Commencer gratuitement →

Passez à Pro — Prova illimité sur vos propres données et un certificat vérifiable qui atteste la compétence.

dès 15 $/mois facturé annuellement

Passer à Pro →

✓ Vous êtes Pro — continuez. The runtime is the judge.

Recevez les nouvelles leçons R & Python par e-mail

Pratique, reproductible, sans spam. Désinscription à tout moment.

Double opt-in. Nous ne partageons jamais votre e-mail.

Partager cette pageXLinkedInRedditHN

Note

Cette leçon est reproductible : chaque résultat de cette page a été produit par le code présenté — modifiez n’importe quel bloc et appuyez sur Run pour le reproduire dans votre navigateur. The runtime is the judge.