ticks - r plot examples with legends




Как объединить(объединить) кадры данных(внутренний, внешний, левый, правый)? (9)

  1. Используя mergeфункцию, мы можем выбрать переменную левой таблицы или правой таблицы, так же, как мы все знакомы с оператором select в SQL (EX: Выберите a. * ... или Select b. * From .....)
  2. Мы должны добавить дополнительный код, который будет подмножаться из недавно объединенной таблицы.

    • SQL: - select a.* from df1 a inner join df2 b on a.CustomerId=b.CustomerId

    • Р :- merge(df1, df2, by.x = "CustomerId", by.y = "CustomerId")[,names(df1)]

Так же

  • SQL: - select b.* from df1 a inner join df2 b on a.CustomerId=b.CustomerId

  • Р :- merge(df1, df2, by.x = "CustomerId", by.y = "CustomerId")[,names(df2)]

Учитывая два кадра данных:

df1 = data.frame(CustomerId = c(1:6), Product = c(rep("Toaster", 3), rep("Radio", 3)))
df2 = data.frame(CustomerId = c(2, 4, 6), State = c(rep("Alabama", 2), rep("Ohio", 1)))

df1
#  CustomerId Product
#           1 Toaster
#           2 Toaster
#           3 Toaster
#           4   Radio
#           5   Radio
#           6   Radio

df2
#  CustomerId   State
#           2 Alabama
#           4 Alabama
#           6    Ohio

Как я могу создать стиль базы данных, т. Е. Стиль sql, присоединяется ? То есть, как я могу получить:

Дополнительный кредит:

Как я могу выполнить инструкцию выбора стиля SQL?


dplyr с 0,4 реализовал все те объединения, в том числе external_join, но стоит отметить, что для первых нескольких выпусков он использовал не предлагать external_join, и в результате было довольно много очень плохого взломанного временного кода пользователя, который довольно долго плавал ( вы все равно можете найти это в ответах SO и Kaggle с того периода).

Связанные с выпуском выпуски :

v0.5 (6/2016)

  • Обработка для типа POSIXct, часовых поясов, дубликатов, разных уровней факторов. Лучшие ошибки и предупреждения.
  • Новый аргумент суффикса для контроля того, какие суффиксные имена дублированных переменных получают (# 1296)

v0.4.0 (1/2015)

  • Внедрить правое соединение и внешнее соединение (# 96)
  • Мутирующие объединения, которые добавляют новые переменные в одну таблицу из совпадающих строк в другой. Фильтрация соединений, которые фильтруют наблюдения из одной таблицы в зависимости от того, соответствуют ли они наблюдению в другой таблице.

v0.3 ( 10/2014 )

  • Может теперь left_join различными переменными в каждой таблице: df1%>% left_join (df2, c ("var1" = "var2"))

v0.2 ( 5/2014 )

  • * _join () больше не переупорядочивает имена столбцов (# 324)

v0.1.3 (4/2014)

Обходные меры по комментариям хадли в этом выпуске:

  • right_join (x, y) совпадает с left_join (y, x) в терминах строк, только столбцы будут разными порядками. Легко работать с select (new_column_order)
  • external_join - это в основном union (left_join (x, y), right_join (x, y)) - то есть сохранить все строки в обоих кадрах данных.

Вы также можете dplyr используя потрясающий пакет dplyr Hadley Wickham.

library(dplyr)

#make sure that CustomerId cols are both type numeric
#they ARE not using the provided code in question and dplyr will complain
df1$CustomerId <- as.numeric(df1$CustomerId)
df2$CustomerId <- as.numeric(df2$CustomerId)

Мутирующие соединения: добавьте столбцы в df1, используя совпадения в df2

#inner
inner_join(df1, df2)

#left outer
left_join(df1, df2)

#right outer
right_join(df1, df2)

#alternate right outer
left_join(df2, df1)

#full join
full_join(df1, df2)

Фильтрация соединений: отфильтровать строки в df1, не изменять столбцы

semi_join(df1, df2) #keep only observations in df1 that match in df2.
anti_join(df1, df2) #drops all observations in df1 that match in df2.

Есть несколько хороших примеров этого в R Wiki . Я украду пару здесь:

Метод слияния

Поскольку ваши ключи называются одинаковыми, короткий способ сделать внутреннее соединение - merge ():

merge(df1,df2)

полное внутреннее соединение (все записи из обеих таблиц) может быть создано с помощью ключевого слова «все»:

merge(df1,df2, all=TRUE)

левое внешнее соединение df1 и df2:

merge(df1,df2, all.x=TRUE)

правое внешнее объединение df1 и df2:

merge(df1,df2, all.y=TRUE)

вы можете перевернуть их, похлопать по ним и протрите их, чтобы получить два других внешних соединения, о которых вы спрашивали :)

Метод подстроки

Левое внешнее соединение с df1 слева, используя индексный метод, будет:

df1[,"State"]<-df2[df1[ ,"Product"], "State"]

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


Новое в 2014 году:

Особенно, если вы также заинтересованы в манипулировании данными в целом (включая сортировку, фильтрацию, подмножество, подведение итогов и т. Д.), Вы должны обязательно взглянуть на dplyr , который включает в себя множество функций, предназначенных для облегчения вашей работы с данными кадры и некоторые другие типы баз данных. Он даже предлагает довольно сложный SQL-интерфейс и даже функцию для преобразования (большинства) SQL-кода непосредственно в R.

Четыре связанные с соединением функции в пакете dplyr (цитируются):

  • inner_join(x, y, by = NULL, copy = FALSE, ...) : вернуть все строки из x, где в y есть соответствующие значения, а все столбцы из x и y
  • left_join(x, y, by = NULL, copy = FALSE, ...) : вернуть все строки из x, а все столбцы из x и y
  • semi_join(x, y, by = NULL, copy = FALSE, ...) : возвращает все строки из x, где в y есть соответствующие значения, сохраняя только столбцы из x.
  • anti_join(x, y, by = NULL, copy = FALSE, ...) : вернуть все строки из x, где в y нет соответствующих значений, сохраняя только столбцы из x

Здесь все очень подробно.

Выбор столбцов можно сделать, select(df,"column") . Если для вас недостаточно SQL-иш, то есть функция sql() , в которую вы можете ввести код SQL как есть, и он будет выполнять указанную вами операцию так же, как вы писали в R все время (для получения дополнительной информации , обратитесь к виньетике dplyr / databases ). Например, если применить правильно, sql("SELECT * FROM hflights") выберет все столбцы из таблицы «hflights» dplyr («tbl»).


Обновление методов data.table для объединения наборов данных. Ниже приведены примеры для каждого типа соединения. Существует два метода: один из [.data.table при передаче второй data.table в качестве первого аргумента для подмножества, другой способ - использовать функцию merge которая отправляется на быстрый метод data.table.

Обновление от 2016-04-01 - и это не шутка в апреле!
В версии 1.9.7 версии data.table теперь могут использовать существующий индекс, который значительно сокращает время соединения. Ниже кода и эталона НЕ используются индексы data.table при объединении . Если вы ищете соединение в режиме реального времени, вы должны использовать индексы data.table.

df1 = data.frame(CustomerId = c(1:6), Product = c(rep("Toaster", 3), rep("Radio", 3)))
df2 = data.frame(CustomerId = c(2L, 4L, 7L), State = c(rep("Alabama", 2), rep("Ohio", 1))) # one value changed to show full outer join

library(data.table)

dt1 = as.data.table(df1)
dt2 = as.data.table(df2)
setkey(dt1, CustomerId)
setkey(dt2, CustomerId)
# right outer join keyed data.tables
dt1[dt2]

setkey(dt1, NULL)
setkey(dt2, NULL)
# right outer join unkeyed data.tables - use `on` argument
dt1[dt2, on = "CustomerId"]

# left outer join - swap dt1 with dt2
dt2[dt1, on = "CustomerId"]

# inner join - use `nomatch` argument
dt1[dt2, nomatch=0L, on = "CustomerId"]

# anti join - use `!` operator
dt1[!dt2, on = "CustomerId"]

# inner join
merge(dt1, dt2, by = "CustomerId")

# full outer join
merge(dt1, dt2, by = "CustomerId", all = TRUE)

# see ?merge.data.table arguments for other cases

Ниже контрольных баз тестов R, sqldf, dplyr и data.table.
Бенчмарк тестирует неблокированные / неиндексированные наборы данных. Вы можете получить еще лучшую производительность, если используете свои ключи data.tables или индексы с sqldf. Base R и dplyr не имеют индексов или ключей, поэтому я не включил этот сценарий в эталон.
Бенчмаркинг выполняется по наборам массивов 5M-1, в столбце соединения есть 5M-2 общих значения, поэтому каждый сценарий (слева, справа, полный, внутренний) может быть протестирован, а объединение все еще не является тривиальным для выполнения.

library(microbenchmark)
library(sqldf)
library(dplyr)
library(data.table)

n = 5e6
set.seed(123)
df1 = data.frame(x=sample(n,n-1L), y1=rnorm(n-1L))
df2 = data.frame(x=sample(n,n-1L), y2=rnorm(n-1L))
dt1 = as.data.table(df1)
dt2 = as.data.table(df2)

# inner join
microbenchmark(times = 10L,
               base = merge(df1, df2, by = "x"),
               sqldf = sqldf("SELECT * FROM df1 INNER JOIN df2 ON df1.x = df2.x"),
               dplyr = inner_join(df1, df2, by = "x"),
               data.table = dt1[dt2, nomatch = 0L, on = "x"])
#Unit: milliseconds
#       expr        min         lq      mean     median        uq       max neval
#       base 15546.0097 16083.4915 16687.117 16539.0148 17388.290 18513.216    10
#      sqldf 44392.6685 44709.7128 45096.401 45067.7461 45504.376 45563.472    10
#      dplyr  4124.0068  4248.7758  4281.122  4272.3619  4342.829  4411.388    10
# data.table   937.2461   946.0227  1053.411   973.0805  1214.300  1281.958    10

# left outer join
microbenchmark(times = 10L,
               base = merge(df1, df2, by = "x", all.x = TRUE),
               sqldf = sqldf("SELECT * FROM df1 LEFT OUTER JOIN df2 ON df1.x = df2.x"),
               dplyr = left_join(df1, df2, by = c("x"="x")),
               data.table = dt2[dt1, on = "x"])
#Unit: milliseconds
#       expr       min         lq       mean     median         uq       max neval
#       base 16140.791 17107.7366 17441.9538 17414.6263 17821.9035 19453.034    10
#      sqldf 43656.633 44141.9186 44777.1872 44498.7191 45288.7406 47108.900    10
#      dplyr  4062.153  4352.8021  4780.3221  4409.1186  4450.9301  8385.050    10
# data.table   823.218   823.5557   901.0383   837.9206   883.3292  1277.239    10

# right outer join
microbenchmark(times = 10L,
               base = merge(df1, df2, by = "x", all.y = TRUE),
               sqldf = sqldf("SELECT * FROM df2 LEFT OUTER JOIN df1 ON df2.x = df1.x"),
               dplyr = right_join(df1, df2, by = "x"),
               data.table = dt1[dt2, on = "x"])
#Unit: milliseconds
#       expr        min         lq       mean     median        uq       max neval
#       base 15821.3351 15954.9927 16347.3093 16044.3500 16621.887 17604.794    10
#      sqldf 43635.5308 43761.3532 43984.3682 43969.0081 44044.461 44499.891    10
#      dplyr  3936.0329  4028.1239  4102.4167  4045.0854  4219.958  4307.350    10
# data.table   820.8535   835.9101   918.5243   887.0207  1005.721  1068.919    10

# full outer join
microbenchmark(times = 10L,
               base = merge(df1, df2, by = "x", all = TRUE),
               #sqldf = sqldf("SELECT * FROM df1 FULL OUTER JOIN df2 ON df1.x = df2.x"), # not supported
               dplyr = full_join(df1, df2, by = "x"),
               data.table = merge(dt1, dt2, by = "x", all = TRUE))
#Unit: seconds
#       expr       min        lq      mean    median        uq       max neval
#       base 16.176423 16.908908 17.485457 17.364857 18.271790 18.626762    10
#      dplyr  7.610498  7.666426  7.745850  7.710638  7.832125  7.951426    10
# data.table  2.052590  2.130317  2.352626  2.208913  2.470721  2.951948    10

Существует метод data.table для внутреннего соединения, который очень эффективен для времени и памяти (и необходим для некоторых более крупных data.frames):

library(data.table)

dt1 <- data.table(df1, key = "CustomerId") 
dt2 <- data.table(df2, key = "CustomerId")

joined.dt1.dt.2 <- dt1[dt2]

merge также работает с data.tables (поскольку он является общим и вызывает merge.data.table )

merge(dt1, dt2)

data.table, документированная в :
Как выполнить операцию слияния данных.
Перевод SQL-соединений по внешним ключам в синтаксис R data.table
Эффективные альтернативы слияния для больших данных. Кадры R
Как сделать базовое левое внешнее соединение с data.table в R?

Еще одним вариантом является функция join найденная в пакете plyr

library(plyr)

join(df1, df2,
     type = "inner")

#   CustomerId Product   State
# 1          2 Toaster Alabama
# 2          4   Radio Alabama
# 3          6   Radio    Ohio

Опции для type : inner , left , right , full .

From ?join : в отличие от merge , [ join ] сохраняет порядок x независимо от того, какой тип соединения используется.


Я бы рекомендовал проверить пакет sqldf Gabor Grothendieck , который позволяет вам выражать эти операции в SQL.

library(sqldf)

## inner join
df3 <- sqldf("SELECT CustomerId, Product, State 
              FROM df1
              JOIN df2 USING(CustomerID)")

## left join (substitute 'right' for right join)
df4 <- sqldf("SELECT CustomerId, Product, State 
              FROM df1
              LEFT JOIN df2 USING(CustomerID)")

Я считаю синтаксис SQL более простым и естественным, чем его эквивалент R (но это может просто отражать смещение RDBMS).

См. Gabor's sqldf GitHub для получения дополнительной информации о объединениях.


Для внутреннего соединения во всех столбцах вы также можете использовать fintersectиз data.table -package или intersectиз dplyr -пакета в качестве альтернативы mergeбез указания byстолбцов. это даст строки, которые равны между двумя кадрами данных:

merge(df1, df2)
#   V1 V2
# 1  B  2
# 2  C  3
dplyr::intersect(df1, df2)
#   V1 V2
# 1  B  2
# 2  C  3
data.table::fintersect(setDT(df1), setDT(df2))
#    V1 V2
# 1:  B  2
# 2:  C  3

Пример данных:

df1 <- data.frame(V1 = LETTERS[1:4], V2 = 1:4)
df2 <- data.frame(V1 = LETTERS[2:3], V2 = 2:3)




r-faq