어떻게 정렬 데이터 프레임으로 여러 칼럼(s)
https://stackoverflow.com/questions/1296646
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian문제
내가 원하는 정렬하는 데이터입니다.프레임으로 여러 개의 열이 있습니다.예를 들어,을 통해 데이터를 제공합니다.프레임은 아래 나는 열을 기준으로 정렬 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
해결책
당신은 사용할 수 있습니다 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() 더 쉽고 직접 액세스 할 수 있도록).
다른 팁
당신의 선택
order~에서basearrange~에서dplyrsetorder그리고setorderv~에서data.tablearrange~에서plyrsort~에서taRifxorderBy~에서doBysortData~에서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 Hadley가 위의 스레드에서 지적했듯이 :
library(plyr)
arrange(dd,desc(z),b)
벤치 마크 : 많은 충돌이 있었기 때문에 새 R 세션에 각 패키지를로드했습니다. 특히 Doby 패키지를로드합니다 sort "다음 객체 (들)가 'x (위치 17)에서 마스킹되어있다 : b, x, y, z"에서 마스킹하고, 추론자 패키지를 덮어 쓰기 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)
중간 시간 : 1,694
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)
첨부/분리로 인해 MicroBenchmark와 호환되는 것처럼 보이지 않습니다.
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 패키지. 간단한 구문을 가지고 있지만 기본 R이 복잡한 기계로 명령하는 것만 큼 빠릅니다. 일반적으로 훌륭한 Hadley Wickham 작업. 내 유일한 그립은 분류 객체가 호출되는 표준 r 명명법을 깨뜨린다는 것입니다. sort(object), 그러나 나는 Hadley가 위에서 연결된 질문에서 논의 된 문제로 인해 왜 그렇게했는지 이해합니다.
Dirk의 대답은 훌륭합니다. 또한 인덱싱에 사용되는 구문의 주요 차이점을 강조합니다. data.frame모래 data.table에스:
## 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)]
매우 작은 차이이지만 언젠가는 목을 구할 수 있습니다. 이 질문에 대한 다른 답변을 평가할 때 변수 이름의 반복을 결정의 기준 중 하나로 계산하는 것을 고려하십시오. 일부 답변에는 상당히 반복이 있고 다른 답변에는 아무것도 없습니다.
여기에는 훌륭한 답변이 많이 있지만 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
R 패키지 data.table 둘 다를 제공합니다 빠른 그리고 메모리 효율성 주문 데이터 간단한 구문 (Matt의 일부가 아주 잘 강조한 부분 그의 대답으로). 많은 개선 사항과 새로운 기능이있었습니다. setorder() 그때부터. 에서 v1.9.5+, setorder() 또한 함께 작동합니다 데이터. 프레임.
먼저, 우리는 충분히 큰 데이터 세트를 만들고 다른 답변에서 언급 된 다른 방법을 벤치마킹 한 다음의 기능을 나열합니다. 데이터.
데이터:
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'에스DT[order(...)]구문이었다 ~ 10x 다른 방법 중 가장 빠른 것보다 더 빠릅니다 (dplyr), 동일한 양의 메모리를 소비하면서dplyr.data.table'에스setorder()~였다 ~ 14x 다른 방법 중 가장 빠른 것보다 더 빠릅니다 (dplyr), 복용하는 동안 0.4GB 추가 메모리.dat이제 필요한 순서입니다 (참조별로 업데이트 됨).
데이터 기능 :
속도:
데이터주문은 구현되기 때문에 매우 빠릅니다 radix 주문.
구문
DT[order(...)]내부적으로 사용하도록 최적화됩니다 데이터빠른 주문. 친숙한 Base R 구문을 계속 사용할 수 있지만 프로세스 속도를 높이고 메모리를 덜 사용 할 수 있습니다.
메모리:
대부분의 경우, 우리는 원본을 요구하지 않습니다. 데이터. 프레임 또는 데이터 재정렬 후. 즉, 우리는 일반적으로 결과를 동일한 객체에 다시 할당합니다.
DF <- DF[order(...)]문제는 원래 객체의 메모리를 적어도 두 번 (2x) 필요하다는 것입니다. 되려고 메모리 효율성, 데이터 따라서 기능도 제공합니다
setorder().setorder()재주 데이터by reference(현장), 추가 사본을 만들지 않고. 하나의 열 크기와 동일한 여분의 메모리 만 사용합니다.
다른 특징들:
지원합니다
integer,logical,numeric,character그리고 심지어bit64::integer64유형.주목하십시오
factor,Date,POSIXct등 .. 수업은 모두입니다integer/numeric추가 속성이있는 유형이므로 지원됩니다.기본 R에서는 사용할 수 없습니다
-캐릭터 벡터에서 해당 열로 순서가 줄어 듭니다. 대신 우리는 사용해야합니다-xtfrm(.).그러나, 데이터, 예를 들어, 우리는 그냥 할 수 있습니다.
dat[order(-x)]또는setorder(dat, -x).
와 함께 Kevin Wright 의이 (매우 유용한) 기능, R Wiki의 팁 섹션에 게시되면 쉽게 달성 할 수 있습니다.
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)
당신이 a 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 내림차순.
또는 패키지 추론자를 사용합니다
library(Deducer)
dd<- sortData(dd,c("z","b"),increasing= c(FALSE,TRUE))
SQL이 자연스럽게 오면 SQLDF는 Codd의 의도 한대로 주문을 처리합니다.
Dirk의 대답은 좋지만 정렬이 필요하다면 정렬을 해당 데이터 프레임의 이름에 다시 적용하고 싶습니다. 예제 코드 사용 :
dd <- dd[with(dd, order(-z, b)), ]
에 대해 배웠 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 더 이상 작동이 없기 때문에 라는 vector age:
databyage = my.data[order(age),]
다음과 같은 라인 때문에 작동 order 종류에 열 age 에 my.data.
databyage = my.data[order(my.data$age),]
나는 생각이 가치가 있었다시 주어진 방법이 혼란 나이에 대한 예입니다.이 게시물로 간주되지 않습에 적합한 스레드를 제거할 수 있습니다.
편집:May13,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
프로그래밍 방식으로 정렬하는 방법에 대한 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의 jatrange ()는 내가 가장 좋아하는 옵션입니다. 파이프 연산자를 사용하고 가장 중요한 부분에서 가장 중요한 측면으로 이동하십시오.
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 정렬하려는 순서대로 하나 이상의 열의 지수입니다. 자세한 내용 :
완전성을 위해서는 열 숫자로 정렬에 대해별로 말하지 않았기 때문에 ... 열 순서가 바뀔 수 있기 때문에 종종 바람직하지 않다고 주장 할 수 있습니다. 일부 특정 상황에서 (예 : 빠른 작업이 필요하고 열이 순서를 변경할 위험이없는 경우), 특히 많은 수의 열을 다룰 때 가장 합리적 일 수 있습니다.
이 경우 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
## (...)
