Ваш выбор

• order от base
• arrange от dplyr
• setorderи setordervизdata.table
• arrange от plyr
• sort от taRifx
• orderBy от doBy
• sortData от Deducer

Большую часть времени вы должны использовать решения dplyrили data.table, если важно не иметь никаких зависимостей, в этом случае используйте base::order.

Недавно я добавил sort.data.frame в пакет CRAN, сделав его совместимым с классом, как обсуждалось здесь: Лучший способ создать непротиворечивость родового / метода для sort.data.frame?

Поэтому, учитывая data.frame dd, вы можете отсортировать следующее:

dd <- data.frame(b = factor(c("Hi", "Med", "Hi", "Low"), 
      levels = c("Low", "Med", "Hi"), ordered = TRUE),
      x = c("A", "D", "A", "C"), y = c(8, 3, 9, 9),
      z = c(1, 1, 1, 2))
library(taRifx)
sort(dd, f= ~ -z + b )

Если вы являетесь одним из авторов этой функции, свяжитесь со мной. Дискуссия в отношении общедоступности является здесь: http://chat.stackoverflow.com/transcript/message/1094290#1094290

Вы также можете использовать arrange()функцию, plyrуказанную Хэдли в приведенной выше теме:

library(plyr)
arrange(dd,desc(z),b)

Тесты: обратите внимание, что я загрузил каждый пакет в новом сеансе R, так как было много конфликтов. В частности, загрузка пакета doBy приводит sortк возврату «Следующие объекты маскируются из« x (позиция 17) »: b, x, y, z», а загрузка пакета Deducer перезаписывается sort.data.frameиз Kevin Wright или пакета taRifx.

#Load each time
dd <- data.frame(b = factor(c("Hi", "Med", "Hi", "Low"), 
      levels = c("Low", "Med", "Hi"), ordered = TRUE),
      x = c("A", "D", "A", "C"), y = c(8, 3, 9, 9),
      z = c(1, 1, 1, 2))
library(microbenchmark)

# Reload R between benchmarks
microbenchmark(dd[with(dd, order(-z, b)), ] ,
    dd[order(-dd$z, dd$b),],
    times=1000
)

Среднее время:

dd[with(dd, order(-z, b)), ] +778

dd[order(-dd$z, dd$b),] +788

library(taRifx)
microbenchmark(sort(dd, f= ~-z+b ),times=1000)

Среднее время: 1,567

library(plyr)
microbenchmark(arrange(dd,desc(z),b),times=1000)

Среднее время: 862

library(doBy)
microbenchmark(orderBy(~-z+b, data=dd),times=1000)

Среднее время: 1694

Обратите внимание, что doBy требует много времени для загрузки пакета.

library(Deducer)
microbenchmark(sortData(dd,c("z","b"),increasing= c(FALSE,TRUE)),times=1000)

Не удалось заставить дедуцера загрузиться. Требуется консоль JGR.

esort <- function(x, sortvar, ...) {
attach(x)
x <- x[with(x,order(sortvar,...)),]
return(x)
detach(x)
}

microbenchmark(esort(dd, -z, b),times=1000)

Кажется, не совместим с микробенчмарком из-за прикрепления / отсоединения.

m <- microbenchmark(
  arrange(dd,desc(z),b),
  sort(dd, f= ~-z+b ),
  dd[with(dd, order(-z, b)), ] ,
  dd[order(-dd$z, dd$b),],
  times=1000
  )

uq <- function(x) { fivenum(x)[4]}  
lq <- function(x) { fivenum(x)[2]}

y_min <- 0 # min(by(m$time,m$expr,lq))
y_max <- max(by(m$time,m$expr,uq)) * 1.05

p <- ggplot(m,aes(x=expr,y=time)) + coord_cartesian(ylim = c( y_min , y_max )) 
p + stat_summary(fun.y=median,fun.ymin = lq, fun.ymax = uq, aes(fill=expr))

(линии простираются от нижнего квартиля до верхнего квартиля, точка - медиана)

Учитывая эти результаты и простоту взвешивания в зависимости от скорости, я должен был бы дать согласие arrangeна plyrпакет . Он имеет простой синтаксис и, тем не менее, почти такой же быстрый, как команды base R, с их запутанными махинациями. Типично блестящая работа Хэдли Уикхем. Моя единственная неприятность в том, что она нарушает стандартную номенклатуру R, в которой вызывается сортировка объектов sort(object), но я понимаю, почему Хэдли так поступила из-за проблем, обсуждаемых в вопросе, связанном выше.

Ответ Дирка великолепен. Это также подчеркивает ключевое различие в синтаксисе, используемом для индексации data.frames и data.tables:

## The data.frame way
dd[with(dd, order(-z, b)), ]

## The data.table way: (7 fewer characters, but that's not the important bit)
dd[order(-z, b)]

Разница между двумя вызовами невелика, но она может иметь важные последствия. Особенно, если вы пишете производственный код и / или обеспокоены правильностью своих исследований, лучше избегать ненужного повторения имен переменных. data.table поможет вам сделать это.

Вот пример того, как повторение имен переменных может привести к неприятностям:

Давайте изменим контекст из ответа Дирка и скажем, что это часть более крупного проекта, в котором много имен объектов, и они длинные и значимые; вместо того, чтобы ddэто называется quarterlyreport. Это становится :

quarterlyreport[with(quarterlyreport,order(-z,b)),]

Хорошо. В этом нет ничего плохого. Затем ваш начальник просит вас включить отчет за последний квартал в отчет. Вы просматриваете свой код, добавляете объект lastquarterlyreportв различные места и каким-то образом (как на земле?) Вы в конечном итоге получаете следующее:

quarterlyreport[with(lastquarterlyreport,order(-z,b)),]

Это не то, что вы имели в виду, но вы не заметили это, потому что вы сделали это быстро, и он расположен на странице с похожим кодом. Код не падает (без предупреждения и без ошибок), потому что R думает, что это то, что вы имели в виду. Вы бы надеялись, что тот, кто прочитает ваш отчет, заметит его, но, возможно, нет. Если вы много работаете с языками программирования, то эта ситуация может быть всем знакома. Это была «опечатка», скажете вы. Я исправлю "опечатку", которую вы скажете своему боссу.

В data.tableнас беспокоят мелкие детали, подобные этому. Итак, мы сделали что-то простое, чтобы не вводить имена переменных дважды. Нечто очень простое. iоценивается в рамках ddуже, автоматически. Вам не нужно with()вообще.

Вместо

dd[with(dd, order(-z, b)), ]

это просто

dd[order(-z, b)]

И вместо

quarterlyreport[with(lastquarterlyreport,order(-z,b)),]

это просто

quarterlyreport[order(-z,b)]

Это очень маленькая разница, но она может спасти вашу шею в один прекрасный день. При взвешивании различных ответов на этот вопрос рассмотрите возможность считать повторения имен переменных одним из ваших критериев при принятии решения. Некоторые ответы имеют много повторений, другие нет.

Здесь есть много отличных ответов, но dplyr дает единственный синтаксис, который я могу быстро и легко запомнить (и теперь использую очень часто):

library(dplyr)
# sort mtcars by mpg, ascending... use desc(mpg) for descending
arrange(mtcars, mpg)
# sort mtcars first by mpg, then by cyl, then by wt)
arrange(mtcars , mpg, cyl, wt)

Для проблемы ОП:

arrange(dd, desc(z),  b)

    b x y z
1 Low C 9 2
2 Med D 3 1
3  Hi A 8 1
4  Hi A 9 1

Пакет R data.tableобеспечивает как быстрое, так и эффективное использование порядка данных в data.tables с простым синтаксисом (часть, которую Мэтт очень хорошо подчеркнул в своем ответе ). С тех пор было довольно много улучшений и новой функции setorder(). С v1.9.5+, setorder()также работает с data.frames .

Сначала мы создадим достаточно большой набор данных и проведем сравнение различных методов, упомянутых в других ответах, а затем перечислим функции data.table .

Данные:

require(plyr)
require(doBy)
require(data.table)
require(dplyr)
require(taRifx)

set.seed(45L)
dat = data.frame(b = as.factor(sample(c("Hi", "Med", "Low"), 1e8, TRUE)),
                 x = sample(c("A", "D", "C"), 1e8, TRUE),
                 y = sample(100, 1e8, TRUE),
                 z = sample(5, 1e8, TRUE), 
                 stringsAsFactors = FALSE)

тесты:

Сообщается, что время выполнения system.time(...)этих функций показано ниже. Время приведено в таблице ниже (в порядке от самого медленного до самого быстрого).

orderBy( ~ -z + b, data = dat)     ## doBy
plyr::arrange(dat, desc(z), b)     ## plyr
arrange(dat, desc(z), b)           ## dplyr
sort(dat, f = ~ -z + b)            ## taRifx
dat[with(dat, order(-z, b)), ]     ## base R

# convert to data.table, by reference
setDT(dat)

dat[order(-z, b)]                  ## data.table, base R like syntax
setorder(dat, -z, b)               ## data.table, using setorder()
                                   ## setorder() now also works with data.frames 

# R-session memory usage (BEFORE) = ~2GB (size of 'dat')
# ------------------------------------------------------------
# Package      function    Time (s)  Peak memory   Memory used
# ------------------------------------------------------------
# doBy          orderBy      409.7        6.7 GB        4.7 GB
# taRifx           sort      400.8        6.7 GB        4.7 GB
# plyr          arrange      318.8        5.6 GB        3.6 GB 
# base R          order      299.0        5.6 GB        3.6 GB
# dplyr         arrange       62.7        4.2 GB        2.2 GB
# ------------------------------------------------------------
# data.table      order        6.2        4.2 GB        2.2 GB
# data.table   setorder        4.5        2.4 GB        0.4 GB
# ------------------------------------------------------------

• data.table«s DT[order(...)]синтаксис был ~ 10 раз быстрее , чем самый быстрый из других методов ( dplyr), потребляя при этом один и тот же объем памяти , как dplyr.

• data.tableЭто setorder()было в ~ 14 раз быстрее, чем самый быстрый из других методов ( dplyr), при этом потребовалось всего 0,4 ГБ дополнительной памяти . datтеперь в том порядке, в котором мы нуждаемся (так как он обновляется по ссылке).

Возможности data.table:

Скорость:

• Порядок в data.table очень быстрый, потому что он реализует радикальное упорядочение .

• Синтаксис DT[order(...)]внутренне оптимизирован для использования быстрого порядка в data.table . Вы можете продолжать использовать знакомый синтаксис base R, но ускорить процесс (и использовать меньше памяти).

Объем памяти:

• В большинстве случаев нам не требуется исходный data.frame или data.table после переупорядочения. То есть мы обычно присваиваем результат тому же объекту, например:

  DF <- DF[order(...)]
  

  Проблема в том, что для этого требуется как минимум вдвое (в 2 раза) объем памяти исходного объекта. Для того, чтобы эффективно использовать память , data.table также предоставляет функцию setorder().

  setorder()переупорядочивает data.tables by reference ( на месте ), не делая дополнительных копий. Используется только дополнительная память, равная размеру одного столбца.

Другие преимущества:

1. Он поддерживает integer, logical, numeric, characterи даже bit64::integer64тип.

   Обратите внимание , что factor, Date, и POSIXctт.д .. классы все integer/ numericтипов под дополнительными атрибутами , и поэтому также поддерживаются.

2. В базе R мы не можем использовать -вектор символов для сортировки по этому столбцу в порядке убывания. Вместо этого мы должны использовать -xtfrm(.).

   Однако в data.table мы можем просто сделать, например, dat[order(-x)]или setorder(dat, -x).

С помощью этой (очень полезной) функции Кевина Райта , опубликованной в разделе советов Riki, это легко достигается.

sort(dd,by = ~ -z + b)
#     b x y z
# 4 Low C 9 2
# 2 Med D 3 1
# 1  Hi A 8 1
# 3  Hi A 9 1

или вы можете использовать пакет doBy

library(doBy)
dd <- orderBy(~-z+b, data=dd)

Предположим, у вас есть data.frame Aи вы хотите отсортировать его, используя столбец, называемый по xубыванию. Позвоните отсортированоdata.frame newdata

newdata <- A[order(-A$x),]

Если вы хотите восходящий порядок, то замените его "-"ничем. Вы можете иметь что-то вроде

newdata <- A[order(-A$x, A$y, -A$z),]

где xи zнекоторые столбцы в data.frame A. Это означает сортировку data.frame Aпо xубыванию, yвозрастанию и zубыванию.

Как вариант, используя пакет Deducer

library(Deducer)
dd<- sortData(dd,c("z","b"),increasing= c(FALSE,TRUE))

Если SQL приходит к вам естественным образом, sqldf обрабатывает ORDER BY так, как задумал Codd.

Я узнал о orderследующем примере, который долго меня смущал:

set.seed(1234)

ID        = 1:10
Age       = round(rnorm(10, 50, 1))
diag      = c("Depression", "Bipolar")
Diagnosis = sample(diag, 10, replace=TRUE)

data = data.frame(ID, Age, Diagnosis)

databyAge = data[order(Age),]
databyAge

Единственная причина, по которой работает этот пример, заключается в том, что orderсортировка выполняется vector Ageпо столбцу, указанному Ageв data frame data.

Чтобы увидеть это, создайте идентичный фрейм данных, используя read.tableнесколько разные имена столбцов и не используя ни один из перечисленных выше векторов:

my.data <- read.table(text = '

  id age  diagnosis
   1  49 Depression
   2  50 Depression
   3  51 Depression
   4  48 Depression
   5  50 Depression
   6  51    Bipolar
   7  49    Bipolar
   8  49    Bipolar
   9  49    Bipolar
  10  49 Depression

', header = TRUE)

Вышеуказанная структура линии orderбольше не работает, потому что нет вектора с именем age:

databyage = my.data[order(age),]

Следующая строка работает, потому что orderсортирует по столбцу ageв my.data.

databyage = my.data[order(my.data$age),]

Я думал, что это стоит опубликовать, учитывая, насколько я был смущен этим примером так долго. Если это сообщение не считается подходящим для темы, я могу удалить его.

РЕДАКТИРОВАТЬ: 13 мая 2014 г.

Ниже приведен обобщенный способ сортировки фрейма данных по каждому столбцу без указания имен столбцов. Код ниже показывает, как сортировать слева направо или справа налево. Это работает, если каждый столбец числовой. Я не пробовал с добавленным столбцом символов.

Я нашел do.callкод месяц или два назад в старом посте на другом сайте, но только после тщательного и сложного поиска. Я не уверен, что мог бы переместить этот пост сейчас. Настоящая тема является первым хитом для заказа data.frameв R. Итак, я подумал, что моя расширенная версия этого исходного do.callкода может быть полезна.

set.seed(1234)

v1  <- c(0,0,0,0, 0,0,0,0, 1,1,1,1, 1,1,1,1)
v2  <- c(0,0,0,0, 1,1,1,1, 0,0,0,0, 1,1,1,1)
v3  <- c(0,0,1,1, 0,0,1,1, 0,0,1,1, 0,0,1,1)
v4  <- c(0,1,0,1, 0,1,0,1, 0,1,0,1, 0,1,0,1)

df.1 <- data.frame(v1, v2, v3, v4) 
df.1

rdf.1 <- df.1[sample(nrow(df.1), nrow(df.1), replace = FALSE),]
rdf.1

order.rdf.1 <- rdf.1[do.call(order, as.list(rdf.1)),]
order.rdf.1

order.rdf.2 <- rdf.1[do.call(order, rev(as.list(rdf.1))),]
order.rdf.2

rdf.3 <- data.frame(rdf.1$v2, rdf.1$v4, rdf.1$v3, rdf.1$v1) 
rdf.3

order.rdf.3 <- rdf.1[do.call(order, as.list(rdf.3)),]
order.rdf.3

Ответ Дирка хорош, но если вам нужно, чтобы сортировка сохранялась, вы захотите применить сортировку обратно к имени этого фрейма данных. Используя пример кода:

dd <- dd[with(dd, order(-z, b)), ] 

В ответ на комментарий, добавленный в OP для того, как сортировать программно:

Использование dplyrиdata.table

library(dplyr)
library(data.table)

dplyr

Просто используйте arrange_, которая является стандартной оценочной версией для arrange.

df1 <- tbl_df(iris)
#using strings or formula
arrange_(df1, c('Petal.Length', 'Petal.Width'))
arrange_(df1, ~Petal.Length, ~Petal.Width)
    Source: local data frame [150 x 5]

   Sepal.Length Sepal.Width Petal.Length Petal.Width Species
          (dbl)       (dbl)        (dbl)       (dbl)  (fctr)
1           4.6         3.6          1.0         0.2  setosa
2           4.3         3.0          1.1         0.1  setosa
3           5.8         4.0          1.2         0.2  setosa
4           5.0         3.2          1.2         0.2  setosa
5           4.7         3.2          1.3         0.2  setosa
6           5.4         3.9          1.3         0.4  setosa
7           5.5         3.5          1.3         0.2  setosa
8           4.4         3.0          1.3         0.2  setosa
9           5.0         3.5          1.3         0.3  setosa
10          4.5         2.3          1.3         0.3  setosa
..          ...         ...          ...         ...     ...


#Or using a variable
sortBy <- c('Petal.Length', 'Petal.Width')
arrange_(df1, .dots = sortBy)
    Source: local data frame [150 x 5]

   Sepal.Length Sepal.Width Petal.Length Petal.Width Species
          (dbl)       (dbl)        (dbl)       (dbl)  (fctr)
1           4.6         3.6          1.0         0.2  setosa
2           4.3         3.0          1.1         0.1  setosa
3           5.8         4.0          1.2         0.2  setosa
4           5.0         3.2          1.2         0.2  setosa
5           4.7         3.2          1.3         0.2  setosa
6           5.5         3.5          1.3         0.2  setosa
7           4.4         3.0          1.3         0.2  setosa
8           4.4         3.2          1.3         0.2  setosa
9           5.0         3.5          1.3         0.3  setosa
10          4.5         2.3          1.3         0.3  setosa
..          ...         ...          ...         ...     ...

#Doing the same operation except sorting Petal.Length in descending order
sortByDesc <- c('desc(Petal.Length)', 'Petal.Width')
arrange_(df1, .dots = sortByDesc)

дополнительная информация здесь: https://cran.r-project.org/web/packages/dplyr/vignettes/nse.html

Лучше использовать формулу, поскольку она также захватывает среду для оценки выражения в

Таблица данных

dt1 <- data.table(iris) #not really required, as you can work directly on your data.frame
sortBy <- c('Petal.Length', 'Petal.Width')
sortType <- c(-1, 1)
setorderv(dt1, sortBy, sortType)
dt1
     Sepal.Length Sepal.Width Petal.Length Petal.Width   Species
  1:          7.7         2.6          6.9         2.3 virginica
  2:          7.7         2.8          6.7         2.0 virginica
  3:          7.7         3.8          6.7         2.2 virginica
  4:          7.6         3.0          6.6         2.1 virginica
  5:          7.9         3.8          6.4         2.0 virginica
 ---                                                            
146:          5.4         3.9          1.3         0.4    setosa
147:          5.8         4.0          1.2         0.2    setosa
148:          5.0         3.2          1.2         0.2    setosa
149:          4.3         3.0          1.1         0.1    setosa
150:          4.6         3.6          1.0         0.2    setosa

Аранжировка () в dplyer - мой любимый вариант. Используйте оператора трубы и переходите от наименее важного к наиболее важному аспекту

dd1 <- dd %>%
    arrange(z) %>%
    arrange(desc(x))

Ради полноты: вы также можете использовать sortByCol()функцию из BBmiscпакета:

library(BBmisc)
sortByCol(dd, c("z", "b"), asc = c(FALSE, TRUE))
    b x y z
4 Low C 9 2
2 Med D 3 1
1  Hi A 8 1
3  Hi A 9 1

Сравнение производительности:

library(microbenchmark)
microbenchmark(sortByCol(dd, c("z", "b"), asc = c(FALSE, TRUE)), times = 100000)
median 202.878

library(plyr)
microbenchmark(arrange(dd,desc(z),b),times=100000)
median 148.758

microbenchmark(dd[with(dd, order(-z, b)), ], times = 100000)
median 115.872

Точно так же, как механические сортировщики карт давным-давно, сначала сортируют по наименее значимому ключу, затем по следующему наиболее значимому и т. Д. Библиотека не требуется, работает с любым количеством клавиш и любой комбинацией восходящих и нисходящих клавиш.

 dd <- dd[order(dd$b, decreasing = FALSE),]

Теперь мы готовы сделать самый важный ключ. Сортировка стабильна, и любые связи в наиболее значимом ключе уже разрешены.

dd <- dd[order(dd$z, decreasing = TRUE),]

Это может быть не самым быстрым, но это, безусловно, просто и надежно

Еще одна альтернатива, используя rgrпакет:

> library(rgr)
> gx.sort.df(dd, ~ -z+b)
    b x y z
4 Low C 9 2
2 Med D 3 1
1  Hi A 8 1
3  Hi A 9 1

Я боролся с вышеуказанными решениями, когда хотел автоматизировать процесс заказа для n столбцов, имена столбцов которых могли каждый раз отличаться. Я нашел супер полезную функцию из psychпакета, чтобы сделать это простым способом:

dfOrder(myDf, columnIndices)

где columnIndicesуказатели одного или нескольких столбцов, в том порядке, в котором вы хотите их отсортировать. Больше информации здесь:

Функция dfOrder из пакета 'psych'

Просто для полноты, поскольку о сортировке по номерам столбцов сказано немногое ... Можно, конечно, утверждать, что это часто нежелательно (поскольку порядок столбцов может измениться, что ведет к ошибкам), но в некоторых конкретных ситуациях (например, когда вам нужно выполнить быструю работу и нет риска изменить порядок столбцов), это может быть наиболее разумно, особенно при работе с большим количеством столбцов.

В таком случае do.call()на помощь приходит:

ind <- do.call(what = "order", args = iris[,c(5,1,2,3)])
iris[ind, ]

##        Sepal.Length Sepal.Width Petal.Length Petal.Width    Species
##    14           4.3         3.0          1.1         0.1     setosa
##    9            4.4         2.9          1.4         0.2     setosa
##    39           4.4         3.0          1.3         0.2     setosa
##    43           4.4         3.2          1.3         0.2     setosa
##    42           4.5         2.3          1.3         0.3     setosa
##    4            4.6         3.1          1.5         0.2     setosa
##    48           4.6         3.2          1.4         0.2     setosa
##    7            4.6         3.4          1.4         0.3     setosa
##    (...)