Veri çerçevesi dizesi sütununu birden çok sütuna böl

Formun verilerini almak istiyorum

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

ve split()"type " yukarıdaki gibi bir şey elde etmek için kullanın:

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

İşe yarayanın bazı biçimlerini içeren inanılmaz derecede karmaşık bir şey applybuldum, ama o zamandan beri yanlış yerleştirdim. En iyi yol olamayacak kadar karmaşık görünüyordu. kullanabilirimstrsplitAşağıdaki gibi , ancak daha sonra veri çerçevesindeki 2 sütuna nasıl geri alabileceğinizi net değil.

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

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

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

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

İşaretçiler için teşekkürler. Henüz R listelerini tam olarak değerlendiremedim.

kullanım stringr::str_split_fixed

library(stringr)
str_split_fixed(before$type, "_and_", 2)

Başka bir seçenek de yeni tidyr paketini kullanmaktır.

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

5 yıl sonra zorunlu data.tableçözüm eklendi

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

Biz de hem çıkan kolonlar doğru türlerine sahip olacak emin olabilir ve ekleyerek performansı artırmak type.convertve fixed(çünkü argümanlar "_and_"gerçekten regex değildir)

setDT(before)[, paste0("type", 1:2) := tstrsplit(type, "_and_", type.convert = TRUE, fixed = TRUE)]

Henüz başka yaklaşım: kullanım rbindüzerine 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"

Ve birleştirmek için:

data.frame(before$attr, do.call(rbind, out))

"[" İle uygulanmış olan bu listelerdeki birinci veya ikinci öğeleri ayıklamak için kullanılabilir.

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

Ve işte bir gsub yöntemi:

before$type_1 <- gsub("_and_.+$", "", before$type)
before$type_2 <- gsub("^.+_and_", "", before$type)
before$type <- NULL

İşte aniko'nun çözümü ile aynı satırlar boyunca, ancak hadley'in stringr paketini kullanan bir astar:

do.call(rbind, str_split(before$type, '_and_'))

Seçeneklere eklemek için splitstackshape::cSplitişlevimi şu şekilde de kullanabilirsiniz :

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

Kullanmanın kolay bir yolu sapply()ve [işlevi:

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_')

Örneğin:

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

sapply()Sonuç, bir matristir ve bir veri çerçevesine aktarılması ve geri çevrilmesi gerekir. O zaman istediğiniz sonucu veren bazı basit manipülasyonlar:

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

Bu noktada, afteristediğin buydu

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

Konu neredeyse tükenmiş, biraz daha genel bir versiyona bir çıkış teklif etmek istiyorum, ancak çıkış sütunlarının sayısını bilmiyorsunuz, a priori. Yani örneğin

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

Bölünmeden separate()önce sonuç sütunlarının sayısını bilmediğimiz için dplyr'i kullanamayız , bu nedenle stringroluşturulan sütunlar için desen ve ad öneki verildiğinde bir sütunu bölmek için kullanılan bir işlev oluşturdum . Umarım kullanılan kodlama kalıpları doğrudur.

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)
}

Daha sonra split_into_multipleaşağıdaki gibi bir dplyr borusunda kullanabiliriz :

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>

Ve sonra gathertoparlamak için kullanabiliriz ...

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

Burada, bir dizi önceki çözümle çakışan, ancak uygun adlara sahip bir data.frame döndüren bir temel R bir astar bulunmaktadır.

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

O kullandığı strsplitdeğişkeni kırmaya ve data.frameile do.call/ ' rbindbir data.frame içine veri geri koymak. Ek artan iyileştirme, setNamesdata.frame öğesine değişken adları eklemek için kullanılmasıdır .

Bu soru oldukça eski ama şu anda en basit bulduğum çözümü ekleyeceğim.

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

R versiyonu 3.4.0 beri kullanabilir strcapture()gelen utils diğer kolon (ler) üzerine çıkış bağlama, (temel R yükler ile birlikte) bir paket.

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

Eğer bağlı kalmak istiyorsanız başka bir yaklaşım komutu strsplit()kullanmaktır unlist(). İşte bu çizgiler boyunca bir çözüm.

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")

temel ama muhtemelen yavaş:

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

İşte başka bir baz R çözeltisi. Kullanabiliriz, read.tableancak yalnızca bir baytlık bir separgümanı kabul ettiğinden ve burada çok baytlı ayırıcıya sahip olduğumuz için, çok gsubbaytlı ayırıcıyı herhangi bir tek baytlık ayırıcıyla değiştirmek ve bunu separgüman olarak kullanmak için kullanabiliriz .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

Bu durumda, bunu varsayılan separgümanla değiştirerek kısaltabiliriz, böylece açıkça belirtmemiz gerekmez

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