Fractionner la colonne de chaîne du bloc de données en plusieurs colonnes

J'aimerais prendre des données du formulaire

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

et utilisez split()la colonne " type" ci-dessus pour obtenir quelque chose comme ceci:

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

J'ai trouvé quelque chose d'incroyablement complexe impliquant une certaine forme de applycela qui a fonctionné, mais je l'ai depuis égaré. Cela semblait beaucoup trop compliqué pour être le meilleur moyen. Je peux utiliser strsplitcomme ci-dessous, mais je ne sais pas comment récupérer cela en 2 colonnes dans le bloc de données.

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

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

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

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

Merci pour tout pointeur. Je n'ai pas encore tout à fait grillé les listes R.

Utilisation stringr::str_split_fixed

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

Une autre option consiste à utiliser le nouveau package 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 ans après l'ajout de la data.tablesolution obligatoire

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

Nous pourrions également à la fois nous assurer que les colonnes résultantes auront des types corrects et améliorer les performances en ajoutant type.convertet des fixedarguments (car ce "_and_"n'est pas vraiment une expression régulière)

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

Encore une autre approche: utiliser rbindsur 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"

Et pour combiner:

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

Notez que sapply avec "[" peut être utilisé pour extraire le premier ou le deuxième élément de ces listes afin:

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

Et voici une méthode gsub:

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

voici une doublure dans le même sens que la solution d'aniko, mais en utilisant le package stringr de hadley:

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

Pour ajouter aux options, vous pouvez également utiliser ma splitstackshape::cSplitfonction comme ceci:

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 moyen simple est d'utiliser sapply()et la [fonction:

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

Par exemple:

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

sapply()Le résultat est une matrice et doit être transposé et converti en une trame de données. Ce sont alors quelques manipulations simples qui donnent le résultat souhaité:

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

À ce stade, afterc'est ce que vous vouliez

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

Le sujet est presque épuisé, j'aimerais cependant proposer une solution à une version un peu plus générale où l'on ne connaît pas a priori le nombre de colonnes de sortie. Ainsi, par exemple, vous avez

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

Nous ne pouvons pas utiliser dplyr separate()parce que nous ne connaissons pas le nombre de colonnes de résultat avant le fractionnement, j'ai donc créé une fonction qui utilise stringrpour fractionner une colonne, étant donné le modèle et un préfixe de nom pour les colonnes générées. J'espère que les modèles de codage utilisés sont corrects.

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

On peut ensuite utiliser split_into_multipledans une pipe dplyr comme suit:

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>

Et puis nous pouvons utiliser gatherpour ranger ...

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

Voici une doublure de base R one qui chevauche un certain nombre de solutions précédentes, mais renvoie un data.frame avec les noms propres.

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

Il utilise strsplitpour décomposer la variable, et data.frameavec do.call/ rbindpour remettre les données dans un data.frame. L'amélioration incrémentielle supplémentaire est l'utilisation de setNamespour ajouter des noms de variables au data.frame.

Cette question est assez ancienne mais j'ajouterai la solution que j'ai trouvée la plus simple actuellement.

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

Depuis R version 3.4.0, vous pouvez utiliser à strcapture()partir du package utils (inclus avec les installations de base R), en liant la sortie sur les autres colonnes.

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

Une autre approche si vous voulez continuer strsplit()est d'utiliser la unlist()commande. Voici une solution dans ce sens.

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 mais probablement lente:

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

Voici une autre solution de base R. Nous pouvons utiliser read.tablemais comme il n'accepte qu'un separgument sur un octet et ici nous avons un séparateur sur plusieurs octets que nous pouvons utiliser gsubpour remplacer le séparateur sur plusieurs octets par n'importe quel séparateur sur un octet et l'utiliser comme separgument dansread.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

Dans ce cas, nous pouvons également le raccourcir en le remplaçant par un separgument par défaut afin de ne pas avoir à le mentionner explicitement

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