Ordenar un marco de datos en R: función order() con ejemplo

Por: evelyn clarke evelyn clarke
Hours Actualizado

⚡ Resumen inteligente

Para ordenar un marco de datos en R, se utiliza la función `order()`, que devuelve las posiciones de las filas en lugar de los valores. Al pasar esas posiciones entre corchetes, las filas se reorganizan por una columna, por varias columnas o en orden descendente.

  • 🔢 Conceptos básicos de order(): La función order() devuelve los índices de fila que colocan una columna en secuencia ascendente, no los valores ordenados en sí mismos.
  • 📌 Columna única: df[order(df$c1), ] reorganiza cada fila del marco según los valores almacenados en c1.
  • 🧮 Varias columnas: Los argumentos adicionales actúan como criterios de desempate, por lo que order(df$c3, df$c4) ordena por c3 y luego por c4.
  • 🔻 Orden descendiente: Anteponga un signo menos a una columna numérica o pase decreasing = TRUE a sort().
  • 🧩 Ruta de tidyverse: arrange() y desc() expresan exactamente los mismos tipos que los verbos dplyr legibles.
  • ⚠️ Valores faltantes: La función order() coloca los valores NA al final por defecto, mientras que sort() elimina los valores faltantes a menos que se establezca na.last.
Descubre más

R Ordenar un marco de datos usando Order()

Ordenar datos en R

En el análisis de datos puedes sort sus datos de acuerdo con una determinada variable en el conjunto de datos. En R, podemos utilizar la ayuda de la función orden(). En R, podemos ordenar fácilmente un vector de variable continua o variable factorial. Organizar los datos puede ser de ascendente or descendiendo orden.

Sintaxis:

sort(x, decreasing = FALSE, na.last = NA)

Argumento:

  • x: Un vector que contiene una variable continua o factorial.
  • decreciente: Controla la dirección de la ordenación. Por defecto, la ordenación descendente está configurada en FALSE, lo que da como resultado un orden ascendente.
  • na.últimoIndica si los valores NA deben colocarse al final o no. sort() usa NA por defecto, lo que descarta los valores faltantes; order() usa TRUE, lo que los conserva y los coloca al final.

sort() vs order() vs rank() en R

La sintaxis anterior pertenece a `sort()`, pero todos los ejemplos de esta página llaman a `order()`. Ambas funciones responden a preguntas diferentes, y confundirlas es la razón más común por la que una ordenación parece fallar. `rank()` completa el trío.

Función Returns Úselo cuando Manejo predeterminado de NA
ordenar() Los valores mismos, en orden Solo necesitas un vector ordenado. na.last = NA, por lo que se elimina NA
orden() Las posiciones de fila que producen el orden ordenado Necesitas reordenar todo un marco de datos. na.last = TRUE, por lo que NA va al final.
rango() El rango de cada elemento en su posición original. Necesitas una columna de clasificación, no una tabla reordenada. na.last = VERDADERO

Debido a que order() devuelve posiciones, es la única de las tres que puede controlar el subconjunto entre corchetes utilizado en toda esta página. Documentación base de R para order() Enumera todos los argumentos, incluido el argumento del método que selecciona el algoritmo de ordenación.

Ejemplo 1: Ordenar un marco de datos por una columna.

Por ejemplo, podemos crear un marco de datos tibble y ordenar una o varias variables. Un marco de datos tibble es una versión moderna del marco de datosMejora la sintaxis del marco de datos y evita el formato de tipos de datos complicado, especialmente la conversión de caracteres a factores. También es una forma práctica de crear un marco de datos manualmente, que es nuestro objetivo aquí. Para obtener más información sobre tibble, consulte el siguiente documento: https://tibble.tidyverse.org/articles/tibble.html

El código a continuación crea una tabla de 50 filas con cinco columnas aleatorias y luego ordena cada fila por los valores en c1. set.seed(1234) fija la selección aleatoria, de modo que aparecen los mismos números en cualquier máquina.

library(dplyr)
set.seed(1234)
data_frame <- tibble(  
	c1 = rnorm(50, 5, 1.5),   
	c2 = rnorm(50, 5, 1.5),  
	c3 = rnorm(50, 5, 1.5),
	c4 = rnorm(50, 5, 1.5), 	
	c5 = rnorm(50, 5, 1.5)
)
# Sort by c1
df <-data_frame[order(data_frame$c1),]
head(df)

Salida:

# A tibble: 6 x 5
##       c1       c2       c3       c4       c5
##     <dbl>    <dbl>    <dbl>    <dbl>    <dbl>
## 1 1.481453 3.477557 4.246283 3.686611 6.0511003
## 2 1.729941 5.824996 4.525823 6.753663 0.1502718
## 3 2.556360 6.275348 2.524849 6.368483 5.4787404
## 4 2.827693 4.769902 5.120089 3.743626 4.0103449
## 5 2.988510 4.395902 2.077631 4.236894 4.6176880
## 6 3.122021 6.317305 5.413840 3.551145 5.6067027

La coma antes del corchete de cierre importa: df[order(…), ] reordena las filas, mientras que df[, order(…)] reordenaría las columnas en su lugar.

Ejemplo 2: Ordenar por varias columnas

Cada argumento adicional que se pasa a order() actúa como criterio de desempate para el argumento anterior. En este caso, el marco se ordena por c3, y las filas que comparten el mismo valor de c3 se ordenan luego por c4.

# Sort by c3 and c4
df <-data_frame[order(data_frame$c3, data_frame$c4),]
head(df)

Salida:

# A tibble: 6 x 5
##        c1       c2       c3       c4       c5
##    <dbl>    <dbl>    <dbl>    <dbl>    <dbl>
## 1 2.988510 4.395902 2.077631 4.236894 4.617688
## 2 2.556360 6.275348 2.524849 6.368483 5.478740
## 3 3.464516 3.914627 2.730068 9.565649 6.016123
## 4 4.233486 3.292088 3.133568 7.517309 4.772395
## 5 3.935840 2.941547 3.242078 6.464048 3.599745
## 6 3.835619 4.947859 3.335349 4.378370 7.240240

ARTÍCULOS RELACIONADOS

Ejemplo 3: Ordenar una columna de forma descendente y otra de forma ascendente.

Cada columna puede tener su propia dirección. Anteponer un signo menos a una columna numérica invierte únicamente esa columna, por lo que la ordenación que se muestra a continuación se realiza de forma descendente en c3 y ascendente en c4.

# Sort by c3(descending) and c4(ascending)
df <-data_frame[order(-data_frame$c3, data_frame$c4),]
head(df)

Salida:

# A tibble: 6 x 5
##         c1       c2       c3        c4       c5
##      <dbl>    <dbl>    <dbl>     <dbl>    <dbl>
## 1 4.339178 4.450214 8.087243 4.5010140 8.410225
## 2 3.959420 8.105406 7.736312 7.1168936 5.431565
## 3 3.339023 3.298088 7.494285 5.9303153 7.035912
## 4 3.397036 5.382794 7.092722 0.7163620 5.620098
## 5 6.653446 4.733315 6.520536 0.9016707 4.513410
## 6 4.558559 4.712609 6.380086 6.0562703 5.044277

El truco del signo menos solo funciona en columnas numéricas. Para columnas de caracteres o factores, use order(xtfrm(df$col), decreasing = TRUE) o cambie al método dplyr que se muestra a continuación.

Ordenar un Data Frame con dplyr arrange()

El modismo de corchetes se vuelve difícil de leer una vez que intervienen varias columnas y direcciones, porque el nombre del marco se repite dentro de cada argumento. dplyr El verbo arrange() elimina esa repetición: las columnas se nombran una sola vez y desc() marca las que van hacia atrás.

library(dplyr)
# The same three sorts written with arrange()
data_frame %>% arrange(c1)            # Example 1
data_frame %>% arrange(c3, c4)        # Example 2
data_frame %>% arrange(desc(c3), c4)  # Example 3

Hay tres diferencias prácticas que conviene conocer:

  • Legibilidad: arrange(desc(c3), c4) indica la intención directamente, mientras que order(-data_frame$c3, data_frame$c4) la oculta tras un signo menos.
  • Tipos de columna: desc() funciona tanto en columnas de caracteres y factores como en columnas numéricas, por lo que no se necesita ninguna solución alternativa con xtfrm().
  • Valores faltantes: arrange() siempre coloca NA al final, sea cual sea la dirección, mientras que order() permite moverlos con na.last.

La función arrange() devuelve un nuevo marco de datos y deja el original intacto, al igual que la versión con corchetes, por lo que el resultado aún debe asignarse a un nombre para conservarlo. Los marcos agrupados se ordenan dentro de cada grupo solo cuando se especifica .by_group = TRUE.

Ordenación de caracteres, factores y valores faltantes en R

Las columnas numéricas se ordenan de forma predecible. El texto, las categorías y los espacios en blanco no, y cada uno de los tres requiere una decisión diferente.

Valores faltantes. Las funciones sort() y order() no se ponen de acuerdo sobre qué hacer con los valores NA, por lo que la misma columna puede producir dos recuentos de filas diferentes:

x <- c(3, NA, 1, 2)
sort(x)                    # missing values dropped
sort(x, na.last = TRUE)    # missing values pushed to the end
order(x)                   # NA indexed last by default
order(x, na.last = FALSE)  # NA indexed first

Factores A factor Se ordena por nivel, no alfabéticamente. Eso es precisamente lo que se desea para categorías ordenadas como baja, media y alta, y precisamente lo que no se desea si los niveles se crearon en el orden en que aparecieron los valores:

grades <- factor(c("low", "high", "medium"),
                 levels = c("low", "medium", "high"))
sort(grades)                # follows the level order
sort(as.character(grades))  # plain alphabetical order

Columnas de caracteres. El texto plano se ordena según la intercalación regional, por lo que las mayúsculas y los acentos pueden cambiar el resultado entre máquinas. Dos prácticas evitan sorpresas: comprobar class(df$col) antes de ordenar y convertir los dígitos almacenados como texto con as.numeric() para que el “10” no aparezca antes que el “2”.

Preguntas Frecuentes

Utilice df[order(rownames(df)), ]. Los nombres de las filas son caracteres, por lo que la ordenación sigue la intercalación de texto y "10" aparece antes que "2". Envuelva los nombres de las filas en as.numeric() cuando sean numéricos. Los tibbles omiten por completo los nombres de las filas, así que añada una columna de ID explícita en su lugar.

Pasa method = “radix” a order(), la opción más rápida para enteros y cadenas cortas. Para millones de filas, data.table::setorder() ordena in situ sin copiar la tabla, y el verbo dplyr arrange() ya utiliza internamente una ordenación por radix.

Índice con secuencia invertida: df[nrow(df):1, ]. Esto invierte el orden actual en lugar de ordenarlo, lo cual es importante cuando el marco se ha mezclado o agrupado. Restablezca las etiquetas posteriormente con rownames(df) <- NULL si resultan confusas.

La columna se almacena como carácter o factor, por lo que R la compara como texto y coloca "10" antes de "2". Verifique con class(df$col), luego convierta usando as.numeric(as.character(df$col)) antes de ordenar.

No. `order()` devuelve un vector de índices y `df[order(…), ]` crea un nuevo marco, por lo que el original permanece intacto hasta que se le asigna el resultado. Los nombres de las filas conservan sus valores anteriores, lo que indica que el marco se ha reordenado.

Los asistentes de IA pueden detectar una columna almacenada como texto cuando una ordenación numérica parece incorrecta, traducir una llamada a `order()` de R base a una secuencia de comandos de dplyr y sugerir una columna de desempate estable. Siempre ejecute el código e inspeccione `head()` antes de confiar en el resultado.

Sí. Copiloto de GitHub Funciona en RStudio Desktop 2023.09.0 y versiones posteriores, y completa las llamadas a order() y arrange() a partir de un comentario simple. Posit advierte que las sugerencias no son deterministas, por lo que se recomienda revisar cada línea antes de ejecutarlo.

Reordena el índice de columna en lugar del índice de fila. `df[, order(names(df))]` ordena las columnas alfabéticamente, y `df[, c(“c3”, “c1”)]` elige un orden explícito. Los usuarios de dplyr pueden llamar a `select(df, c3, c1)`, que reordena y crea subconjuntos en un solo paso.

Resumir este post con: