Разделить столбец строки фрейма данных на несколько столбцов

246

Я хотел бы взять данные формы

before = data.frame(attr = c(1,30,4,6), type=c('foo_and_bar','foo_and_bar_2'))
  attr          type
1    1   foo_and_bar
2   30 foo_and_bar_2
3    4   foo_and_bar
4    6 foo_and_bar_2

и используйте split()столбец " type" сверху, чтобы получить что-то вроде этого:

  attr type_1 type_2
1    1    foo    bar
2   30    foo  bar_2
3    4    foo    bar
4    6    foo  bar_2

Я придумал что-то невероятно сложное, включающее какую-то форму, applyкоторая сработала, но с тех пор я это неуместно. Это казалось слишком сложным, чтобы быть лучшим способом. Я могу использовать, strsplitкак показано ниже, но тогда неясно, как вернуть это обратно в 2 столбца во фрейме данных.

> strsplit(as.character(before$type),'_and_')
[[1]]
[1] "foo" "bar"

[[2]]
[1] "foo"   "bar_2"

[[3]]
[1] "foo" "bar"

[[4]]
[1] "foo"   "bar_2"

Спасибо за любые указатели. Я еще не совсем прогнал R списки.

jkebinger
источник

Ответы:

280

использование stringr::str_split_fixed

library(stringr)
str_split_fixed(before$type, "_and_", 2)
Hadley
источник
2
сегодня это тоже хорошо работало для моей проблемы ... но в начале каждой строки добавлялось "c". Любая идея, почему это ??? left_right <- str_split_fixed(as.character(split_df),'\">',2)
LearneR
Я хотел бы разделить с шаблоном, который имеет "...", когда я применяю эту функцию, она ничего не возвращает. В чем может быть проблема. мой тип - что-то вроде "test ... score"
user3841581
2
@ user3841581 - ваш старый запрос, который я знаю, но он описан в документации - str_split_fixed("aaa...bbb", fixed("..."), 2)прекрасно работает с fixed()«Сопоставить фиксированную строку» в pattern=аргументе. .означает «любой символ» в регулярном выражении.
thelatemail
Спасибо, очень удобный метод, но есть одна вещь, которую можно улучшить, если в исходном столбце есть NA, после разделения она станет пустой строкой в ​​столбцах результата, что нежелательно, я хочу сохранить NA все еще NA после разделение
облачные вычисления
Хорошо работает, т.е. если разделитель отсутствует! т.е. если у меня есть вектор 'a <-c ("1N", "2N") ", который я хотел бы разделить в столбцах" 1,1, "N", "N", "я запускаю" str_split_fixed (s, " ", 2) '. Я просто не знаю, как назвать мои новые столбцы в этом подходе, «col1 <-c (1,1)» и «col2 <-c (« N »,« N »)»
майя
175

Другой вариант - использовать новый пакет tidyr.

library(dplyr)
library(tidyr)

before <- data.frame(
  attr = c(1, 30 ,4 ,6 ), 
  type = c('foo_and_bar', 'foo_and_bar_2')
)

before %>%
  separate(type, c("foo", "bar"), "_and_")

##   attr foo   bar
## 1    1 foo   bar
## 2   30 foo bar_2
## 3    4 foo   bar
## 4    6 foo bar_2
Hadley
источник
Есть ли способ ограничить количество разделений с отдельными? Допустим, я хочу разделить на '_' только один раз (или сделать это с str_split_fixedдобавлением столбцов в существующий фрейм данных)?
Елена Чуклина
67

5 лет спустя добавление обязательного data.tableрешения

library(data.table) ## v 1.9.6+ 
setDT(before)[, paste0("type", 1:2) := tstrsplit(type, "_and_")]
before
#    attr          type type1 type2
# 1:    1   foo_and_bar   foo   bar
# 2:   30 foo_and_bar_2   foo bar_2
# 3:    4   foo_and_bar   foo   bar
# 4:    6 foo_and_bar_2   foo bar_2

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

setDT(before)[, paste0("type", 1:2) := tstrsplit(type, "_and_", type.convert = TRUE, fixed = TRUE)]
Дэвид Аренбург
источник
если количество ваших '_and_'шаблонов варьируется, вы можете узнать максимальное количество совпадений (то есть будущие столбцы) сmax(lengths(strsplit(before$type, '_and_')))
andschar
Это мой любимый ответ, работает очень хорошо! Не могли бы вы объяснить, как это работает. Почему транспонировать (strsplit (…)), а не paste0 для объединения строк - не разбивать их ...
Gecko
1
@ Гекко Я не уверен, в чем вопрос. Если вы просто используете strsplitего, он создает один вектор с 2 значениями в каждом слоте, поэтому tstrsplitтранспонирует его в 2 вектора с одним значением в каждом. paste0используется только для создания имен столбцов, он не используется для значений. На LHS уравнения указаны имена столбцов, на RHS - операция разделения + транспонирования столбца. :=расшифровывается как « назначить на место », поэтому вы не видите там <-оператора присваивания.
Дэвид Аренбург
58

Еще один подход: использовать rbindна out:

before <- data.frame(attr = c(1,30,4,6), type=c('foo_and_bar','foo_and_bar_2'))  
out <- strsplit(as.character(before$type),'_and_') 
do.call(rbind, out)

     [,1]  [,2]   
[1,] "foo" "bar"  
[2,] "foo" "bar_2"
[3,] "foo" "bar"  
[4,] "foo" "bar_2"

И объединить:

data.frame(before$attr, do.call(rbind, out))
Анико
источник
4
Другая альтернатива на более новых версиях Rstrcapture("(.*)_and_(.*)", as.character(before$type), data.frame(type_1 = "", type_2 = ""))
alexis_laz
37

Обратите внимание, что sapply с «[» можно использовать для извлечения первого или второго элементов в этих списках так:

before$type_1 <- sapply(strsplit(as.character(before$type),'_and_'), "[", 1)
before$type_2 <- sapply(strsplit(as.character(before$type),'_and_'), "[", 2)
before$type <- NULL

А вот метод gsub:

before$type_1 <- gsub("_and_.+$", "", before$type)
before$type_2 <- gsub("^.+_and_", "", before$type)
before$type <- NULL
IRTFM
источник
32

Вот один вкладыш в том же ключе, что и в решении Aniko, но с использованием пакета stringl hadley:

do.call(rbind, str_split(before$type, '_and_'))
Ramnath
источник
1
Хороший улов, лучшее решение для меня. Хотя немного медленнее, чем с stringrпакетом.
Мелка
20

Чтобы добавить к опциям, вы также можете использовать мою splitstackshape::cSplitфункцию следующим образом:

library(splitstackshape)
cSplit(before, "type", "_and_")
#    attr type_1 type_2
# 1:    1    foo    bar
# 2:   30    foo  bar_2
# 3:    4    foo    bar
# 4:    6    foo  bar_2
A5C1D2H2I1M1N2O1R2T1
источник
Спустя 3 года - этот вариант лучше всего подходит для аналогичной проблемы, с которой я сталкиваюсь - однако в фрейме данных, с которым я работаю, 54 столбца, и мне нужно разделить их все на две части. Есть ли способ сделать это с помощью этого метода - если не вводить вышеупомянутую команду 54 раза? Большое спасибо, Ники.
Ники,
@Nicki, вы пробовали указывать вектор имен столбцов или позиций столбцов? Это должно сделать это ....
A5C1D2H2I1M1N2O1R2T1
Это было не просто переименование столбцов - мне нужно было буквально разделить столбцы, как показано выше, чтобы удвоить количество столбцов в моей df. Ниже было то, что я использовал в конце: df2 <- cSplit (df1, splitCols = 1:54, "/")
Ники
14

Простым способом является использование sapply()и [функции:

before <- data.frame(attr = c(1,30,4,6), type=c('foo_and_bar','foo_and_bar_2'))
out <- strsplit(as.character(before$type),'_and_')

Например:

> data.frame(t(sapply(out, `[`)))
   X1    X2
1 foo   bar
2 foo bar_2
3 foo   bar
4 foo bar_2

sapply()В результате получается матрица, которая нуждается в переносе и приведении к кадру данных. Затем некоторые простые манипуляции дают желаемый результат:

after <- with(before, data.frame(attr = attr))
after <- cbind(after, data.frame(t(sapply(out, `[`))))
names(after)[2:3] <- paste("type", 1:2, sep = "_")

На данный момент, afterэто то , что вы хотели

> after
  attr type_1 type_2
1    1    foo    bar
2   30    foo  bar_2
3    4    foo    bar
4    6    foo  bar_2
Гэвин Симпсон
источник
12

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

before = data.frame(attr = c(1,30,4,6), type=c('foo_and_bar','foo_and_bar_2', 'foo_and_bar_2_and_bar_3', 'foo_and_bar'))
  attr                    type
1    1             foo_and_bar
2   30           foo_and_bar_2
3    4 foo_and_bar_2_and_bar_3
4    6             foo_and_bar

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

split_into_multiple <- function(column, pattern = ", ", into_prefix){
  cols <- str_split_fixed(column, pattern, n = Inf)
  # Sub out the ""'s returned by filling the matrix to the right, with NAs which are useful
  cols[which(cols == "")] <- NA
  cols <- as.tibble(cols)
  # name the 'cols' tibble as 'into_prefix_1', 'into_prefix_2', ..., 'into_prefix_m' 
  # where m = # columns of 'cols'
  m <- dim(cols)[2]

  names(cols) <- paste(into_prefix, 1:m, sep = "_")
  return(cols)
}

Затем мы можем использовать split_into_multipleв трубе dplyr следующее:

after <- before %>% 
  bind_cols(split_into_multiple(.$type, "_and_", "type")) %>% 
  # selecting those that start with 'type_' will remove the original 'type' column
  select(attr, starts_with("type_"))

>after
  attr type_1 type_2 type_3
1    1    foo    bar   <NA>
2   30    foo  bar_2   <NA>
3    4    foo  bar_2  bar_3
4    6    foo    bar   <NA>

И тогда мы можем использовать, gatherчтобы привести в порядок ...

after %>% 
  gather(key, val, -attr, na.rm = T)

   attr    key   val
1     1 type_1   foo
2    30 type_1   foo
3     4 type_1   foo
4     6 type_1   foo
5     1 type_2   bar
6    30 type_2 bar_2
7     4 type_2 bar_2
8     6 type_2   bar
11    4 type_3 bar_3
Яннис П.
источник
Ура, я думаю, что это очень полезно.
Тьебо
8

Вот базовая строка R one, которая перекрывает несколько предыдущих решений, но возвращает data.frame с собственными именами.

out <- setNames(data.frame(before$attr,
                  do.call(rbind, strsplit(as.character(before$type),
                                          split="_and_"))),
                  c("attr", paste0("type_", 1:2)))
out
  attr type_1 type_2
1    1    foo    bar
2   30    foo  bar_2
3    4    foo    bar
4    6    foo  bar_2

Он использует, strsplitчтобы разбить переменную и data.frameс помощью do.call/ rbindпоместить данные обратно в data.frame. Дополнительным постепенным улучшением является использование setNamesдля добавления имен переменных в data.frame.

LMO
источник
6

Этот вопрос довольно старый, но я добавлю решение, которое мне показалось самым простым в настоящее время.

library(reshape2)
before = data.frame(attr = c(1,30,4,6), type=c('foo_and_bar','foo_and_bar_2'))
newColNames <- c("type1", "type2")
newCols <- colsplit(before$type, "_and_", newColNames)
after <- cbind(before, newCols)
after$type <- NULL
after
Swifty McSwifterton
источник
Это, безусловно, самое простое, когда дело доходит до управления векторами df
Абрикос
5

Начиная с версии 3.4.0 R, которую вы можете использовать strcapture()из пакета utils (входит в базовую установку R), связывает вывод с другими столбцами.

out <- strcapture(
    "(.*)_and_(.*)",
    as.character(before$type),
    data.frame(type_1 = character(), type_2 = character())
)

cbind(before["attr"], out)
#   attr type_1 type_2
# 1    1    foo    bar
# 2   30    foo  bar_2
# 3    4    foo    bar
# 4    6    foo  bar_2
Рич Скривен
источник
4

Другой подход, если вы хотите придерживаться, strsplit()это использовать unlist()команду. Вот решение в том же духе.

tmp <- matrix(unlist(strsplit(as.character(before$type), '_and_')), ncol=2,
   byrow=TRUE)
after <- cbind(before$attr, as.data.frame(tmp))
names(after) <- c("attr", "type_1", "type_2")
ashaw
источник
4

базовый, но, вероятно, медленный:

n <- 1
for(i in strsplit(as.character(before$type),'_and_')){
     before[n, 'type_1'] <- i[[1]]
     before[n, 'type_2'] <- i[[2]]
     n <- n + 1
}

##   attr          type type_1 type_2
## 1    1   foo_and_bar    foo    bar
## 2   30 foo_and_bar_2    foo  bar_2
## 3    4   foo_and_bar    foo    bar
## 4    6 foo_and_bar_2    foo  bar_2
jpmorris
источник
1

Вот еще одно базовое решение R. Мы можем использовать, read.tableно так как он принимает только однобайтовый sepаргумент, и здесь у нас есть многобайтовый разделитель, который мы можем использовать gsubдля замены многобайтового разделителя на любой однобайтовый разделитель и использовать его в качестве sepаргумента вread.table

cbind(before[1], read.table(text = gsub('_and_', '\t', before$type), 
                 sep = "\t", col.names = paste0("type_", 1:2)))

#  attr type_1 type_2
#1    1    foo    bar
#2   30    foo  bar_2
#3    4    foo    bar
#4    6    foo  bar_2

В этом случае мы также можем сделать его короче, заменив его sepаргументом по умолчанию, поэтому нам не нужно явно упоминать его

cbind(before[1], read.table(text = gsub('_and_', ' ', before$type), 
                 col.names = paste0("type_", 1:2)))
Ронак Шах
источник