0Pricing
R Academy · Leçon

Trier des data frames par colonne

Triez des data frames entiers avec order() et arrange() de dplyr.

Trier des data frames par colonne est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Trier un cadre de données selon une colonne

La méthode standard en R de base pour trier un cadre de données consiste à utiliser order() sur la colonne souhaitée, puis à utiliser les indices obtenus pour réordonner les lignes. La virgule après les indices sélectionne toutes les colonnes.

df <- data.frame(
  name = c('Charlie', 'Alice', 'Bob', 'Diana'),
  age  = c(35, 28, 42, 31),
  salary = c(55000, 48000, 72000, 61000)
)
df[order(df$age), ]

Tri décroissant par annulation

Pour les colonnes numériques, annulez la colonne à l'intérieur de order() afin d'inverser le sens du tri. Le signe moins inverse toutes les valeurs : le maximum devient ainsi le minimum pour le classement.

df <- data.frame(
  name   = c('Charlie', 'Alice', 'Bob', 'Diana'),
  salary = c(55000, 48000, 72000, 61000)
)
# Highest salary first
df[order(-df$salary), ]

Tri selon plusieurs colonnes

Transmettez plusieurs colonnes à order() pour trier d'abord selon un critère principal, puis selon un critère secondaire. Le deuxième argument départage les ex æquo du premier. Cela correspond à ORDER BY col1, col2 en SQL.

df <- data.frame(
  dept   = c('Eng', 'HR', 'Eng', 'HR', 'Eng'),
  name   = c('Zara', 'Bob', 'Alice', 'Eve', 'Mike'),
  salary = c(90000, 55000, 85000, 58000, 78000)
)
# Sort by dept, then by salary descending within dept
df[order(df$dept, -df$salary), ]

Trier des colonnes de caractères

Le tri selon une colonne de caractères fonctionne de la même manière : order() gère l'ordre lexicographique. Pour un ordre alphabétique inversé, utilisez decreasing = TRUE plutôt que l'annulation (l'annulation ne fonctionne qu'avec les valeurs numériques).

df <- data.frame(
  city    = c('Paris', 'Athens', 'Berlin', 'London'),
  pop_mil = c(2.1, 0.6, 3.6, 9.0)
)
# Alphabetical by city
df[order(df$city), ]
# Reverse alphabetical
df[order(df$city, decreasing = TRUE), ]

Réinitialiser les numéros de lignes après un tri

Après un tri, les noms de lignes reflètent les positions d'origine (par exemple, 3, 1, 4, 2). Pour les réinitialiser en entiers consécutifs commençant à 1, définissez row.names(df) <- NULL ou placez le résultat dans data.frame().

df <- data.frame(
  x = c(30, 10, 20),
  y = c('c', 'a', 'b')
)
sorted <- df[order(df$x), ]
cat('Before reset:\n'); print(sorted)
row.names(sorted) <- NULL
cat('After reset:\n');  print(sorted)

Trier avec des valeurs NA

Lorsqu'une colonne de tri contient NA, order() les place à la fin par défaut. Utilisez na.last = FALSE pour déplacer les lignes NA au début, ou filtrez-les d'abord.

df <- data.frame(
  name  = c('Alice', 'Bob', 'Carol', 'Dave'),
  score = c(85, NA, 92, NA)
)
cat('NAs last (default):\n')
print(df[order(df$score), ])
cat('NAs first:\n')
print(df[order(df$score, na.last = FALSE), ])

dplyr::arrange() : une alternative moderne

Le paquet dplyr fournit arrange() comme alternative plus claire. Même si dplyr ne fait pas partie de R de base, connaître sa syntaxe vous aide à lire du code R moderne. Remarque : isRunnable vaut true ici uniquement pour montrer la syntaxe ; dplyr doit être installé pour exécuter ce code.

# dplyr::arrange() syntax (requires dplyr installed)
# library(dplyr)
# df |> arrange(salary)           # ascending
# df |> arrange(desc(salary))     # descending
# df |> arrange(dept, desc(salary)) # multi-column

# Equivalent base R:
df <- data.frame(dept=c('A','B','A'), salary=c(50,70,60))
df[order(df$dept, -df$salary), ]

Trier des facteurs selon l'ordre de leurs niveaux

Les colonnes de facteurs sont triées selon leur ordre de niveaux, et non par ordre alphabétique. Vous pouvez ainsi définir un ordre de tri personnalisé en fixant explicitement les niveaux du facteur avant le tri.

df <- data.frame(
  priority = factor(c('Low', 'High', 'Medium', 'High', 'Low'),
                    levels = c('Low', 'Medium', 'High')),
  task = c('T1', 'T2', 'T3', 'T4', 'T5')
)
# Sorts by factor level (Low < Medium < High)
df[order(df$priority), ]

Trier et sélectionner les premières lignes

Un modèle courant consiste à trier un cadre de données, puis à prendre les N premières lignes avec head(), ou les N dernières avec tail(). C'est l'équivalent en R de base de ORDER BY ... LIMIT N en SQL.

df <- data.frame(
  product = c('A', 'B', 'C', 'D', 'E'),
  revenue = c(1200, 4500, 890, 3100, 2750)
)
# Top 3 by revenue
top3 <- head(df[order(-df$revenue), ], 3)
row.names(top3) <- NULL
print(top3)

Tri sur place ou tri affecté

Le tri ne modifie pas le cadre de données d'origine : il en renvoie un nouveau. Affectez toujours le résultat à une variable, qu'il s'agisse d'une nouvelle variable ou de la variable d'origine. Remplacer l'original convient lorsque vous n'avez plus besoin de la version non triée.

df <- data.frame(
  x = c(3, 1, 4, 1, 5, 9),
  y = c('c', 'a', 'd', 'b', 'e', 'i')
)
# Safe: assign to new variable
df_sorted <- df[order(df$x), ]
# Or overwrite original:
df <- df[order(df$x), ]
row.names(df) <- NULL
print(df)

Flux de travail complet pour le tri

Voici un flux de travail complet et réaliste pour trier un cadre de données : trier les employés par nom de service croissant, puis par salaire décroissant, réinitialiser les indices de lignes et afficher proprement le résultat.

employees <- data.frame(
  name   = c('Alice', 'Bob', 'Carol', 'Dave', 'Eve'),
  dept   = c('IT', 'HR', 'IT', 'HR', 'IT'),
  salary = c(85000, 58000, 92000, 63000, 78000)
)
result <- employees[order(employees$dept, -employees$salary), ]
row.names(result) <- NULL
print(result)

Vérification rapide

Comment trieriez-vous un cadre de données df selon une colonne numérique df$salary dans l'ordre décroissant avec R de base ?

Tri des cadres de données : points essentiels

Points essentiels pour trier des cadres de données :

  • Idiome de R de base : df[order(df$col), ]
  • Numérique décroissant : annulez avec - dans order(-df$col)
  • Caractères en ordre décroissant : utilisez l'argument decreasing = TRUE
  • Plusieurs colonnes : order(df$a, df$b) — le tri secondaire départage les ex æquo
  • Les facteurs sont triés selon l'ordre de niveaux défini, et non par ordre alphabétique
  • Réinitialisez les noms de lignes avec row.names(df) <- NULL après le tri
  • Alternative moderne : dplyr::arrange() avec desc() pour l'ordre décroissant
df <- data.frame(
  name = c('Zara', 'Ana', 'Bob', 'Ana'),
  score = c(90, 85, 92, 88)
)
# Sort by name asc, score desc
result <- df[order(df$name, -df$score), ]
row.names(result) <- NULL
print(result)

Questions Fréquemment Posées

La leçon « Trier des data frames par colonne » est-elle gratuite ?

Oui — le texte complet de « Trier des data frames par colonne » 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 « Trier des data frames par colonne » ?

Triez des data frames entiers avec order() et arrange() de dplyr. 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 4 sur 4.

Combien de temps prend la leçon « Trier des data frames par colonne » ?

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