I'd like to take data of the form
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
and use split()
on the column "type
" from above to get something like this:
attr type_1 type_2
1 1 foo bar
2 30 foo bar_2
3 4 foo bar
4 6 foo bar_2
I came up with something unbelievably complex involving some form of apply
that worked, bu开发者_StackOverflow中文版t I've since misplaced that. It seemed far too complicated to be the best way. I can use strsplit
as below, but then unclear how to get that back into 2 columns in the data frame.
> strsplit(as.character(before$type),'_and_')
[[1]]
[1] "foo" "bar"
[[2]]
[1] "foo" "bar_2"
[[3]]
[1] "foo" "bar"
[[4]]
[1] "foo" "bar_2"
Thanks for any pointers. I've not quite groked R lists just yet.
Use stringr::str_split_fixed
library(stringr)
str_split_fixed(before$type, "_and_", 2)
Another option is to use the new tidyr package.
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 years later adding the obligatory data.table
solution
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
We could also both make sure that the resulting columns will have correct types and improve performance by adding type.convert
and fixed
arguments (since "_and_"
isn't really a regex)
setDT(before)[, paste0("type", 1:2) := tstrsplit(type, "_and_", type.convert = TRUE, fixed = TRUE)]
Yet another approach: use rbind
on 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"
And to combine:
data.frame(before$attr, do.call(rbind, out))
Notice that sapply with "[" can be used to extract either the first or second items in those lists so:
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
And here's a gsub method:
before$type_1 <- gsub("_and_.+$", "", before$type)
before$type_2 <- gsub("^.+_and_", "", before$type)
before$type <- NULL
here is a one liner along the same lines as aniko's solution, but using hadley's stringr package:
do.call(rbind, str_split(before$type, '_and_'))
To add to the options, you could also use my splitstackshape::cSplit
function like this:
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
The subject is almost exhausted, I 'd like though to offer a solution to a slightly more general version where you don't know the number of output columns, a priori. So for example you have
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
We can't use dplyr separate()
because we don't know the number of the result columns before the split, so I have then created a function that uses stringr
to split a column, given the pattern and a name prefix for the generated columns. I hope the coding patterns used, are correct.
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)
}
We can then use split_into_multiple
in a dplyr pipe as follows:
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>
And then we can use gather
to tidy up...
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
An easy way is to use sapply()
and the [
function:
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_')
For example:
> data.frame(t(sapply(out, `[`)))
X1 X2
1 foo bar
2 foo bar_2
3 foo bar
4 foo bar_2
sapply()
's result is a matrix and needs transposing and casting back to a data frame. It is then some simple manipulations that yield the result you wanted:
after <- with(before, data.frame(attr = attr))
after <- cbind(after, data.frame(t(sapply(out, `[`))))
names(after)[2:3] <- paste("type", 1:2, sep = "_")
At this point, after
is what you wanted
> after
attr type_1 type_2
1 1 foo bar
2 30 foo bar_2
3 4 foo bar
4 6 foo bar_2
Here is a base R one liner that overlaps a number of previous solutions, but returns a data.frame with the proper names.
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
It uses strsplit
to break up the variable, and data.frame
with do.call
/rbind
to put the data back into a data.frame. The additional incremental improvement is the use of setNames
to add variable names to the data.frame.
Since R version 3.4.0 you can use strcapture()
from the utils package (included with base R installs), binding the output onto the other column(s).
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
This question is pretty old but I'll add the solution I found the be the simplest at present.
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
base but probably slow:
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
Another approach if you want to stick with strsplit()
is to use the unlist()
command. Here's a solution along those lines.
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")
Here is another base R solution. We can use read.table
but since it accepts only one-byte sep
argument and here we have multi-byte separator we can use gsub
to replace the multibyte separator to any one-byte separator and use that as sep
argument in 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
In this case, we can also make it shorter by replacing it with default sep
argument so we don't have to mention it explicitly
cbind(before[1], read.table(text = gsub('_and_', ' ', before$type),
col.names = paste0("type_", 1:2)))
Surprisingly, another tidyverse solution is still missing - you can also use tidyr::extract
, with a regex.
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
精彩评论