将数据帧字符串列拆分为多个列

我想取表格的数据

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

并在上面的列"type"上使用split()，得到如下内容:

  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列表。

551133 次浏览
小开

注意，带“[”的spapply可以用来提取这些列表中的第一项或第二项，如下所示:

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
小开

一个简单的方法是使用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
小开

如果你想坚持使用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")
小开

还有另一种方法:在out上使用rbind:

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))
小开

下面是一个与aniko的解决方案相同的一行，但使用hadley的stringr包:

do.call(rbind, str_split(before$type, '_and_'))
小开
最佳答案

使用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
小开

为了添加选项，你也可以像这样使用我的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
小开

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

下面是一个基于rone的行程序，它与之前的一些解决方案重叠，但返回一个具有正确名称的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。

小开

从R版本3.4.0开始，你可以使用跑龙套包中的strcapture()(包含在基本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
小开

这个问题已经很老了，但我将添加目前我发现的最简单的解决方案。

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
小开

这个主题几乎耗尽了，我想提供一个稍微更一般的版本的解决方案，在那里你不知道输出列的数量，一个先验。举个例子

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

然后我们可以在dplyr管道中使用split_into_multiple，如下所示:

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
小开

基本的，但可能很慢的:

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，但由于它只接受一个字节的sep参数，这里我们有多字节分隔符，我们可以使用gsub将多字节分隔符替换为任何一个字节分隔符，并将其作为read.table中的sep参数

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)))
小开

令人惊讶的是，另一个tidyverse解决方案仍然缺失——你也可以使用带有正则表达式的tidyr::extract。

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


## regex - getting all characters except an underscore till the first underscore,
## inspired by Akrun https://stackoverflow.com/a/49752920/7941188


extract(before, col = type, into = paste0("type", 1:2), regex = "(^[^_]*)_(.*)")
#>   attr type1     type2
#> 1    1   foo   and_bar
#> 2   30   foo and_bar_2
#> 3    4   foo   and_bar
#> 4    6   foo and_bar_2

提交答案