Dividi la colonna della stringa del frame di dati in più colonne

Vorrei prendere i dati del modulo

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

e usa split()la colonna " type" dall'alto per ottenere qualcosa del genere:

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

Ho inventato qualcosa di incredibilmente complesso che coinvolge una qualche forma di applyciò che ha funzionato, ma da allora l'ho smarrito. Sembrava troppo complicato per essere il modo migliore. Posso usare strsplitcome di seguito, ma poi non è chiaro come riportarlo in 2 colonne nel frame di dati.

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

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

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

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

Grazie per eventuali suggerimenti. Non ho ancora sviluppato le liste R per ora.

Uso stringr::str_split_fixed

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

Un'altra opzione è quella di utilizzare il nuovo pacchetto 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 anni dopo aggiungendo la data.tablesoluzione obbligatoria

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

Potremmo anche assicurarci che le colonne risultanti abbiano tipi corretti e migliorino le prestazioni aggiungendo type.converte fixedargomenti (poiché "_and_"non è davvero una regex)

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

Ancora un altro approccio: usare rbindsu 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"

E combinare:

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

Nota che sapply con "[" può essere usato per estrarre il primo o il secondo elemento in quegli elenchi così:

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

Ed ecco un metodo gsub:

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

ecco una fodera sulla stessa linea della soluzione di aniko, ma usando il pacchetto stringr di hadley:

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

Per aggiungere alle opzioni, puoi anche usare la mia splitstackshape::cSplitfunzione in questo modo:

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

Un modo semplice è usare sapply()e la [funzione:

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

Per esempio:

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

sapply()Il risultato è una matrice e deve essere trasposto e convertito in un frame di dati. Sono quindi alcune semplici manipolazioni che producono il risultato desiderato:

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

A questo punto, afterè quello che volevi

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

L'argomento è quasi esaurito, mi piacerebbe però offrire una soluzione a una versione leggermente più generale in cui non si conosce il numero di colonne di output, a priori. Quindi per esempio hai

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

Non possiamo usare dplyr separate()perché non conosciamo il numero delle colonne dei risultati prima della divisione, quindi ho quindi creato una funzione che utilizza stringrper dividere una colonna, dato lo schema e un prefisso del nome per le colonne generate. Spero che i modelli di codifica utilizzati siano corretti.

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

Possiamo quindi utilizzare split_into_multiplein una pipe dplyr come segue:

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>

E poi possiamo usare gatherper riordinare ...

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

Ecco una linea di base R one che si sovrappone a una serie di soluzioni precedenti, ma restituisce un data.frame con i nomi propri.

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

Usa strsplitper scomporre la variabile e data.framecon do.call/ rbindper reinserire i dati in un data.frame. Il miglioramento incrementale aggiuntivo è l'uso di setNamesper aggiungere nomi di variabili a data.frame.

Questa domanda è piuttosto vecchia ma aggiungerò la soluzione che ho trovato essere la più semplice al momento.

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

Dalla versione 3.4.0 di R è possibile utilizzare strcapture()dal pacchetto utils (incluso con le installazioni di base R), associando l'output alle altre colonne.

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

Un altro approccio se si desidera attenersi strsplit()è utilizzare il unlist()comando. Ecco una soluzione in tal senso.

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

base ma probabilmente lento:

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

Ecco un'altra soluzione R di base. Possiamo usare read.tablema poiché accetta solo un separgomento a un byte e qui abbiamo un separatore a più byte che possiamo usare gsubper sostituire il separatore a più byte con qualsiasi separatore a un byte e usarlo come separgomento inread.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 questo caso, possiamo anche accorciarlo sostituendolo con separgomento predefinito in modo da non doverlo menzionare esplicitamente

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