Как отсортировать фрейм данных по нескольким столбцам
1121087 просмотра
19 ответа
Я хочу отсортировать 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
Автор: Christopher DuBois
Источник
Размещён: 17.05.2019 02:34
Ответы (19)
1509 плюса
Вы можете использовать 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()
для более простого / более прямого доступа).
422 плюса
Ваш выбор
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)
, но я понимаю, почему Хэдли так поступила из-за проблем, обсуждаемых в вопросе, связанном выше.
133 плюса
Ответ Дирка великолепен. Это также подчеркивает ключевое различие в синтаксисе, используемом для индексации data.frame
s и 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
поможет вам сделать это.
Вот пример того, как повторение имен переменных может привести к неприятностям:
Давайте изменим контекст из ответа Дирка и скажем, что это часть более крупного проекта, в котором много имен объектов, и они длинные и значимые; вместо того, чтобы 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)]
Это очень маленькая разница, но она может спасти вашу шею в один прекрасный день. При взвешивании различных ответов на этот вопрос рассмотрите возможность считать повторения имен переменных одним из ваших критериев при принятии решения. Некоторые ответы имеют много повторений, другие нет.
Автор: Matt Dowle Размещён: 25.05.2012 04:25112 плюса
Здесь есть много отличных ответов, но 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
Автор: Ben
Размещён: 18.02.2014 09:29
73 плюса
Пакет 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
«sDT[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.tablesby reference
( на месте ), не делая дополнительных копий. Используется только дополнительная память, равная размеру одного столбца.
Другие преимущества:
Он поддерживает
integer
,logical
,numeric
,character
и дажеbit64::integer64
тип.Обратите внимание , что
factor
,Date
, иPOSIXct
т.д .. классы всеinteger
/numeric
типов под дополнительными атрибутами , и поэтому также поддерживаются.В базе R мы не можем использовать
-
вектор символов для сортировки по этому столбцу в порядке убывания. Вместо этого мы должны использовать-xtfrm(.)
.Однако в data.table мы можем просто сделать, например,
dat[order(-x)]
илиsetorder(dat, -x)
.
63 плюса
С помощью этой (очень полезной) функции Кевина Райта , опубликованной в разделе советов 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
Автор: Christopher DuBois
Размещён: 18.08.2009 09:37
34 плюса
или вы можете использовать пакет doBy
library(doBy)
dd <- orderBy(~-z+b, data=dd)
Автор: George Dontas
Размещён: 19.01.2010 08:44
32 плюса
Предположим, у вас есть 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
убыванию.
25 плюса
Как вариант, используя пакет Deducer
library(Deducer)
dd<- sortData(dd,c("z","b"),increasing= c(FALSE,TRUE))
Автор: Ian Fellows
Размещён: 20.08.2009 07:43
25 плюса
Если SQL приходит к вам естественным образом, sqldf обрабатывает ORDER BY так, как задумал Codd.
Автор: malecki Размещён: 08.03.2010 11:3014 плюса
Я узнал о 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
Автор: Mark Miller
Размещён: 02.09.2013 07:28
13 плюса
Ответ Дирка хорош, но если вам нужно, чтобы сортировка сохранялась, вы захотите применить сортировку обратно к имени этого фрейма данных. Используя пример кода:
dd <- dd[with(dd, order(-z, b)), ]
Автор: Andrew
Размещён: 26.05.2011 03:08
13 плюса
В ответ на комментарий, добавленный в 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
Автор: info_seekeR
Размещён: 05.02.2016 09:11
7 плюса
Аранжировка () в dplyer - мой любимый вариант. Используйте оператора трубы и переходите от наименее важного к наиболее важному аспекту
dd1 <- dd %>%
arrange(z) %>%
arrange(desc(x))
Автор: Kaden Killpack
Размещён: 29.10.2018 04:56
4 плюса
Ради полноты: вы также можете использовать 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
Автор: Lars Kotthoff
Размещён: 07.08.2015 04:03
3 плюса
Точно так же, как механические сортировщики карт давным-давно, сначала сортируют по наименее значимому ключу, затем по следующему наиболее значимому и т. Д. Библиотека не требуется, работает с любым количеством клавиш и любой комбинацией восходящих и нисходящих клавиш.
dd <- dd[order(dd$b, decreasing = FALSE),]
Теперь мы готовы сделать самый важный ключ. Сортировка стабильна, и любые связи в наиболее значимом ключе уже разрешены.
dd <- dd[order(dd$z, decreasing = TRUE),]
Это может быть не самым быстрым, но это, безусловно, просто и надежно
Автор: Rick Размещён: 15.01.2015 04:282 плюса
Еще одна альтернатива, используя 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
Автор: Stéphane Laurent
Размещён: 01.05.2018 10:18
1 плюс
Я боролся с вышеуказанными решениями, когда хотел автоматизировать процесс заказа для n столбцов, имена столбцов которых могли каждый раз отличаться. Я нашел супер полезную функцию из psych
пакета, чтобы сделать это простым способом:
dfOrder(myDf, columnIndices)
где columnIndices
указатели одного или нескольких столбцов, в том порядке, в котором вы хотите их отсортировать. Больше информации здесь:
Функция dfOrder из пакета 'psych'
Автор: AHegde Размещён: 24.10.2018 10:320 плюса
Просто для полноты, поскольку о сортировке по номерам столбцов сказано немногое ... Можно, конечно, утверждать, что это часто нежелательно (поскольку порядок столбцов может измениться, что ведет к ошибкам), но в некоторых конкретных ситуациях (например, когда вам нужно выполнить быструю работу и нет риска изменить порядок столбцов), это может быть наиболее разумно, особенно при работе с большим количеством столбцов.
В таком случае 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
## (...)
Автор: Dominic Comtois
Размещён: 11.04.2019 03:58
Вопросы из категории :
- r Как получить доступ к последнему значению в векторе?
- r Пакеты оптимизации для R
- r Есть ли у R такие операторские операции, как Perl qw ()?
- r Библиотека / инструмент для рисования тройных / треугольных графиков
- r Участки без заголовков / надписей в R
- sorting Как вы сортируете словарь по значению?
- sorting Объединить Сортировать связанный список
- sorting Natural (human alpha-numeric) sort in Microsoft SQL 2005
- sorting Как отсортировать список строк?
- sorting Как отсортировать список словарей по значению словаря?
- dataframe Разница между скобками [] и двойной скобкой [[]] для доступа к элементам списка или кадра данных
- dataframe Уровни коэффициента отбрасывания в заданном кадре данных
- dataframe Как отсортировать фрейм данных по нескольким столбцам
- dataframe Как объединить (объединить) кадры данных (внутренний, внешний, левый, правый)?
- r-faq Расчет скользящей средней
- r-faq Проверить, содержит ли вектор данный элемент
- r-faq Поиск всех позиций для нескольких элементов в векторе