如何按多列对数据框进行排序
我想按多列对data.frame进行排序。例如，对于下面的data.frame，我想按列z（降序）排序，然后按列b排序（升序）：
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))
dd
b x y z
1 Hi A 8 1
2 Med D 3 1
3 Hi A 9 1
4 Low C 9 2
19 个答案:
答案 0 :(得分：1528)
您可以直接使用order()功能而无需使用附加工具 - 请参阅example(order)代码顶部使用技巧的更简单的答案：
R> dd[with(dd, order(-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
在2年多后编辑：只是通过列索引询问如何执行此操作。答案是简单地将所需的排序列传递给order()函数：
R> dd[order(-dd[,4], dd[,1]), ]
b x y z
4 Low C 9 2
2 Med D 3 1
1 Hi A 8 1
3 Hi A 9 1
R>
而不是使用列的名称（而with()更容易/更直接访问）。
答案 1 :(得分：427)
您的选择
-
来自
-
base来自arrange的 -
dplyr来自setorder的 -
setorderv和data.table来自arrange的 -
plyr来自sort的 -
taRifx来自orderBy的 -
doBy来自sortData的 -
Deducer
order 的大多数情况下，您应该使用dplyr或data.table解决方案，除非没有依赖关系很重要，在这种情况下使用base::order。
我最近将sort.data.frame添加到CRAN包中，使其与类兼容，如下所述： Best way to create generic/method consistency for 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函数，正如Hadley在上面的帖子中指出的那样：
library(plyr)
arrange(dd,desc(z),b)
基准测试：请注意，由于存在大量冲突，我在新的R会话中加载了每个包。特别是加载doBy包导致sort返回“以下对象被掩盖在'x（位置17）'：b，x，y，z”，并且加载Deducer包覆盖{{1来自Kevin Wright或taRifx包。
sort.data.frame平均时间：
#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
)
778
dd[with(dd, order(-z, b)), ] 788
dd[order(-dd$z, dd$b),]平均时间： 1,567
library(taRifx)
microbenchmark(sort(dd, f= ~-z+b ),times=1000)
平均时间： 862
library(plyr)
microbenchmark(arrange(dd,desc(z),b),times=1000)
平均时间： 1,694
请注意，doBy需要花费大量时间来加载包。
library(doBy)
microbenchmark(orderBy(~-z+b, data=dd),times=1000)
无法加载Deducer。需要JGR控制台。
library(Deducer)
microbenchmark(sortData(dd,c("z","b"),increasing= c(FALSE,TRUE)),times=1000)
由于连接/分离，似乎与microbenchmark不兼容。
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。它具有简单的语法，但几乎与基本的R命令一样快速，并且具有复杂的阴谋。通常辉煌的哈德利威克姆工作。我唯一的抱怨是它打破了plyr调用排序对象的标准R命名法，但我理解为什么Hadley会因为上面链接的问题中讨论的问题而这样做。
答案 2 :(得分：137)
德克的回答很棒。它还强调了用于索引data.frame和data.table s的语法的主要区别：
## 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
帮助你做到这一点。
以下是重复变量名称可能会让您遇到麻烦的一个示例：
让我们从Dirk的答案中改变背景，并说这是一个更大的项目的一部分，其中有很多对象名称，它们很长很有意义;而不是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)]
这是一个非常小的差异，但有一天它可能会挽救你的脖子。权衡此问题的不同答案时，请考虑将变量名称的重复计算为您决定的标准之一。有些答案有不少重复，有些则没有。
答案 3 :(得分：113)
这里有很多优秀的答案，但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)
对于OP的问题：
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
答案 4 :(得分：75)
R包data.table以简单的语法提供 fast 和内存效率 data.tables 的排序（一部分）其中马特非常好地突出了in his answer）。从那时起，已经有了很多改进，还有一个新功能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＆＃39;DT[order(...)]语法 ~10x 比其他方法（dplyr）中的最快速度快，同时消耗了与dplyr相同的内存量。 -
data.table＆＃39;setorder()〜14x 比其他方法中最快（dplyr）快，同时仅0.4GB额外内存。dat现在按我们要求的顺序排列（因为它通过引用更新）。
data.table功能：
<强>速度
-
data.table 的排序非常快，因为它实现了radix ordering。
-
语法
DT[order(...)]在内部进行了优化，以便使用 data.table 的快速排序。您可以继续使用熟悉的基本R语法，但可以加快进程（并使用更少的内存）。
<强>内存
-
大多数情况下，我们在重新排序后不需要原始的 data.frame 或 data.table 。也就是说，我们通常将结果分配回同一个对象，例如：
DF <- DF[order(...)]问题是这需要至少两倍（2x）原始对象的内存。为了内存效率， data.table 因此也提供了一个函数
setorder()。setorder()重新排序 data.tablesby reference（就地），无需另外制作副本。它只使用等于一列大小的额外内存。
其他功能：
-
它支持
integer，logical，numeric，character甚至bit64::integer64类型。请注意
factor，Date，POSIXct等..类下面的所有integer/numeric类型都包含其他属性，因此也受支持。 -
在基数R中，我们不能在字符向量上使用
-按降序排列该列。相反，我们必须使用-xtfrm(.)。但是，在 data.table 中，我们可以这样做，例如，
dat[order(-x)]或setorder(dat, -x)。
答案 5 :(得分：64)
在R维基的提示部分发布了this (very helpful) function by Kevin Wright，这很容易实现。
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
答案 6 :(得分：35)
或者您可以使用包doBy
library(doBy)
dd <- orderBy(~-z+b, data=dd)
答案 7 :(得分：33)
假设您有一个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。
答案 8 :(得分：26)
或者，使用Deducer包
library(Deducer)
dd<- sortData(dd,c("z","b"),increasing= c(FALSE,TRUE))
答案 9 :(得分：26)
如果SQL对您来说很自然，那么sqldf会按照Codd的意图处理ORDER BY。
答案 10 :(得分：15)
我通过以下示例了解了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),]
我认为这是值得发布的，因为这个例子对我这么长时间的困惑。如果该帖子不适合该帖子，我可以将其删除。
编辑：2014年5月13日
下面是按列排序数据框而不指定列名的通用方法。下面的代码显示了如何从左到右或从右到左排序。如果每列都是数字，则此方法有效。我没有尝试添加字符列。
我在一个或两个月之前在另一个网站的旧帖子中找到了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
答案 11 :(得分：14)
Dirk的答案很好，但是如果你需要排序来坚持下去，你会想要将排序应用到该数据框的名称上。使用示例代码：
dd <- dd[with(dd, order(-z, b)), ]
答案 12 :(得分：14)
回应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
最好使用公式，因为它还捕获环境以评估
中的表达式data.table
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
答案 13 :(得分：8)
我最喜欢dplyer中的describe（）。使用管道运算符，从最不重要的方面转到最重要的方面
dd1 <- dd %>%
arrange(z) %>%
arrange(desc(x))
答案 14 :(得分：5)
为了完整起见：您还可以使用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
答案 15 :(得分：4)
就像很久以前的机械卡分拣机一样，首先按最不重要的键排序，然后是下一个最重要的键，等等。不需要库，可以使用任意数量的键以及上升键和下降键的任意组合。
dd <- dd[order(dd$b, decreasing = FALSE),]
现在我们已准备好做最重要的关键。排序是稳定的，并且最重要的密钥中的任何联系都已经解决。
dd <- dd[order(dd$z, decreasing = TRUE),]
这可能不是最快的，但它确实简单可靠
答案 16 :(得分：3)
另一种选择，使用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
答案 17 :(得分：2)
当我想自动化n列的排序过程时，我在上述解决方案上苦苦挣扎，因为n列的列名每次都可能不同。我从psych包中发现了一个超级有用的功能，可以以一种简单的方式做到这一点：
dfOrder(myDf, columnIndices)
其中columnIndices是一列或多列的索引，按您要对其排序的顺序。这里有更多信息：
答案 18 :(得分：2)
仅出于完整性考虑，由于关于列号排序的讨论很少，因此可以肯定地说这通常是不理想的（因为列的顺序可能会改变，从而为错误铺平了道路。 ），但是在某些特定情况下（例如，您需要快速完成工作，并且没有更改列的风险），这也许是最明智的选择，尤其是在处理大量列时。
在这种情况下，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
## (...)
- 我写了这段代码，但我无法理解我的错误
- 我无法从一个代码实例的列表中删除 None 值，但我可以在另一个实例中。为什么它适用于一个细分市场而不适用于另一个细分市场？
- 是否有可能使 loadstring 不可能等于打印？卢阿
- java中的random.expovariate()
- Appscript 通过会议在 Google 日历中发送电子邮件和创建活动
- 为什么我的 Onclick 箭头功能在 React 中不起作用？
- 在此代码中是否有使用“this”的替代方法？
- 在 SQL Server 和 PostgreSQL 上查询，我如何从第一个表获得第二个表的可视化
- 每千个数字得到
- 更新了城市边界 KML 文件的来源？