0Pricing
R Academy · Leçon

order() pour un classement flexible

Obtenez la permutation d’indices permettant de trier selon un ou plusieurs critères.

order() pour un classement flexible est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage R Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours R Academy comprend 4 leçons au total.

Ce que renvoie order()

order() ne renvoie pas les valeurs triées : elle renvoie les indices qui permettraient de trier le vecteur. Cette indirection la rend bien plus puissante que sort(), car vous pouvez appliquer ces indices à toute structure associée.

x <- c(30, 10, 50, 20, 40)
indices <- order(x)
print(indices)
# Verify: x[indices] gives sorted x
print(x[indices])

order() dans l’ordre décroissant

Comme sort(), order() accepte decreasing = TRUE pour renvoyer les indices qui produisent une séquence décroissante. Cela est utile pour trier du plus grand au plus petit.

scores <- c(78, 92, 65, 88, 71)
desc_order <- order(scores, decreasing = TRUE)
cat('Rank order (index):', desc_order, '\n')
cat('Scores high to low:', scores[desc_order], '\n')

Trier un data frame selon une colonne

L’utilisation la plus pratique de order() consiste à trier un data frame selon l’une de ses colonnes. Transmettez la colonne à order(), puis utilisez ces indices pour réordonner toutes les lignes du data frame.

df <- data.frame(
  name = c('Charlie', 'Alice', 'Bob', 'Diana'),
  age  = c(35, 28, 42, 31)
)
sorted_df <- df[order(df$age), ]
print(sorted_df)

Trier un data frame dans l’ordre décroissant

Pour trier un data frame du plus grand au plus petit selon une colonne numeric, transmettez decreasing = TRUE à order(). Les noms de lignes (indices) du résultat reflètent les positions d’origine.

products <- data.frame(
  item  = c('Pen', 'Notebook', 'Stapler', 'Tape'),
  price = c(1.5, 4.99, 7.25, 2.10)
)
products[order(products$price, decreasing = TRUE), ]

Classement selon plusieurs colonnes

Transmettez plusieurs vecteurs à order(), en les séparant par des virgules. R effectue le tri selon le premier argument, puis départage les égalités avec le deuxième, le troisième, et ainsi de suite. Ce fonctionnement correspond à celui de la clause ORDER BY de SQL.

df <- data.frame(
  dept   = c('HR', 'IT', 'HR', 'IT', 'HR'),
  salary = c(50000, 70000, 60000, 65000, 55000)
)
# Sort by dept first, then by salary within dept
df[order(df$dept, df$salary), ]

Tri multiple avec ordres croissant et décroissant

Pour trier une colonne dans l’ordre croissant et une autre dans l’ordre décroissant, annulez la colonne numeric à trier dans l’ordre décroissant avec -. Pour les colonnes character, utilisez xtfrm() afin d’obtenir une représentation entière triable, puis annulez-la.

df <- data.frame(
  dept   = c('HR', 'IT', 'HR', 'IT', 'HR'),
  salary = c(50000, 70000, 60000, 65000, 55000)
)
# dept ascending, salary descending
df[order(df$dept, -df$salary), ]

Gérer NA dans order()

order() possède également un argument na.last, comme sort(). Par défaut, na.last = NA, ce qui place les NA à la fin. Définissez na.last = TRUE ou na.last = FALSE pour contrôler explicitement leur emplacement.

vals <- c(5, NA, 2, NA, 8, 1)
# Default: NAs sorted last
order(vals)
# NAs first
order(vals, na.last = FALSE)

Préserver les noms de lignes après un tri

Lorsque vous sélectionnez un sous-ensemble d’un data frame avec des indices de lignes, R conserve les noms de lignes d’origine. Utilisez row.names(df) <- NULL ou les approches reset= pour les réinitialiser à 1, 2, 3, ... après le tri.

df <- data.frame(
  city = c('Paris', 'Tokyo', 'NYC'),
  pop  = c(2.1, 13.9, 8.3)
)
sorted <- df[order(df$pop), ]
print(sorted)
# Reset row names
row.names(sorted) <- NULL
print(sorted)

order() et sort() côte à côte

La différence essentielle est la suivante : sort(x) renvoie les valeurs triées, tandis que order(x) renvoie les positions triées. Utilisez sort() lorsque seules les valeurs vous intéressent ; utilisez order() lorsque vous devez réorganiser simultanément des structures de données associées.

x <- c(50, 20, 80, 10, 60)
cat('sort(x)  :', sort(x), '\n')
cat('order(x) :', order(x), '\n')
cat('x[order(x)]:', x[order(x)], '\n')

Trier un data frame selon une colonne de chaînes

Vous pouvez également trier selon des colonnes character. order(df$name) renvoie les indices de lignes selon l’ordre alphabétique de la colonne name ; vous pouvez ensuite les utiliser pour réordonner le data frame.

employees <- data.frame(
  name   = c('Zara', 'Ahmed', 'Maria', 'Bruno'),
  tenure = c(3, 7, 2, 5)
)
employees[order(employees$name), ]

Enchaîner order() pour des tris complexes

Un tri à trois niveaux est simple : transmettez trois vecteurs à order(). Chaque argument supplémentaire sert à départager les valeurs égales dans les arguments précédents.

df <- data.frame(
  region = c('West', 'East', 'West', 'East', 'West'),
  dept   = c('HR', 'IT', 'HR', 'IT', 'IT'),
  score  = c(85, 90, 78, 88, 92)
)
df[order(df$region, df$dept, df$score), ]

Vérification rapide

Que renvoie order(x) lorsqu’elle est appliquée à un vecteur x ?

Principaux points à retenir sur order()

Principaux points à retenir sur order() :

  • order(x) renvoie des indices, et non des valeurs : utilisez x[order(x)] pour obtenir les valeurs triées
  • Triez les data frames avec df[order(df$col), ]
  • Tri selon plusieurs colonnes : order(df$a, df$b) ; les égalités dans a sont départagées par b
  • Annulez les colonnes numeric avec - pour effectuer un tri décroissant multiple
  • Contrôlez l’emplacement des NA avec na.last = TRUE/FALSE/NA
  • Contrairement à sort(), order() vous permet de trier simultanément des structures parallèles
df <- data.frame(
  name  = c('Eve', 'Bob', 'Alice', 'Charlie'),
  score = c(88, 92, 88, 75)
)
# Sort by score descending, then name ascending for ties
df[order(-df$score, df$name), ]

Questions Fréquemment Posées

La leçon « order() pour un classement flexible » est-elle gratuite ?

Oui — le texte complet de « order() pour un classement flexible » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours R Academy, passe à CoddyKit PRO. Le cours R Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « order() pour un classement flexible » ?

Obtenez la permutation d’indices permettant de trier selon un ou plusieurs critères. Tu pratiques R Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer R Academy ?

Aucune expérience préalable n'est requise. R Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « order() pour un classement flexible » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon R Academy ?

Oui. Chaque leçon R Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Trier des vecteurs avec sort()
  2. order() pour un classement flexible
  3. Classer des valeurs avec rank()
  4. Trier des data frames par colonne
← Retour à R Academy