데이터 프레임 문자열 열을 여러 열로 분할

양식의 데이터를 가져오고 싶습니다

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 목록을 완전히 이해하지 못했습니다.

사용하다 stringr::str_split_fixed

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

또 다른 옵션은 새로운 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

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

또 다른 접근법 : rbindon 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))

"["를 사용하여 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

다음은 aniko 솔루션과 동일한 라인을 따라 하나의 라이너이지만 hadley의 stringr 패키지를 사용합니다.

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

옵션에 추가하려면 다음 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

사용하기 쉬운 방법 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

주제가 거의 소진되었습니다. 출력 열의 수를 모르는 약간 더 일반적인 버전에 대한 솔루션을 제공하고 싶습니다. 예를 들어

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

separate()분할하기 전에 결과 열의 수를 모르기 때문에 dplyr을 사용할 수 없으므로 생성 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_multipledplyr 파이프에서 다음과 같이 사용할 수 있습니다 .

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

다음은 많은 이전 솔루션과 겹치는 기본 R 하나의 라이너이지만 올바른 이름으로 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/ rbinddata.frame에 데이터 등을 넣어. 추가적인 증분 개선은 setNamesdata.frame에 변수 이름을 추가 하는 것입니다 .

이 질문은 꽤 오래되었지만 현재 가장 간단한 해결책을 추가 할 것입니다.

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 버전 3.4.0 때문에 당신이 사용할 수있는 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

고집하고 싶은 다른 방법 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")

기본이지만 아마도 느립니다.

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

또 다른 기본 R 솔루션이 있습니다. 우리는 사용할 수 read.table있지만 1 바이트 sep인수 만 허용하므로 여기에 멀티 바이트 구분 기호가 있으므로 gsub멀티 바이트 구분 기호를 1 바이트 구분 기호로 바꾸고 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)))