Convertir le type de plusieurs colonnes d'un dataframe à la fois

J'ai l'impression de passer beaucoup de temps à la création d'un dataframe à partir d'un fichier, base de données ou quelque chose, puis la conversion de chaque colonne dans le type je le voulais dans (numérique, facteur, caractère, etc). Est-il un moyen de faire cela en une seule étape, éventuellement en donnant un vecteur de types ?

foo<-data.frame(x=c(1:10), 
                y=c("red", "red", "red", "blue", "blue", 
                    "blue", "yellow", "yellow", "yellow", 
                    "green"),
                z=Sys.Date()+c(1:10))

foo$x<-as.character(foo$x)
foo$y<-as.character(foo$y)
foo$z<-as.numeric(foo$z)

au lieu de les trois dernières commandes, j'aimerais faire quelque chose comme

foo<-convert.magic(foo, c(character, character, numeric))
  • Utiliser le colClasses argument read.table.
  • Des plages de valeurs peuvent également être attribués simplement à l'aide de: for(n in names(foo)[1:2]{foo[[n]]<-as.character(foo[[n]])} Pratique pour beaucoup de colonnes à convertir.
  • Appris si la conversion de plusieurs champs de facteur numérique, vous aurez besoin d'un autre appel à as.character ou levels. voir: stackoverflow.com/questions/3418128/...
InformationsquelleAutor PaulHurleyuk | 2011-10-06
  1. 32

    Modifier Voir cette liés à la question pour quelques simplifications et d'extensions sur cette idée de base.

    Mon commentaire à Brandon réponse à l'aide de switch:

    convert.magic <- function(obj,types){
    for (i in 1:length(obj)){
        FUN <- switch(types[i],character = as.character, 
                                   numeric = as.numeric, 
                                   factor = as.factor)
        obj[,i] <- FUN(obj[,i])
    }
    obj
}

out <- convert.magic(foo,c('character','character','numeric'))
> str(out)
'data.frame':   10 obs. of  3 variables:
 $ x: chr  "1" "2" "3" "4" ...
 $ y: chr  "red" "red" "red" "blue" ...
 $ z: num  15254 15255 15256 15257 15258 ...

    Pour vraiment de gros blocs de données, vous souhaiterez peut-être utiliser lapply au lieu de la for boucle:

    convert.magic1 <- function(obj,types){
    out <- lapply(1:length(obj),FUN = function(i){FUN1 <- switch(types[i],character = as.character,numeric = as.numeric,factor = as.factor); FUN1(obj[,i])})
    names(out) <- colnames(obj)
    as.data.frame(out,stringsAsFactors = FALSE)
}

    Ce faisant, d'être conscient de certaines des complexités de contraindre des données dans R. Par exemple, la conversion du facteur numérique implique souvent as.numeric(as.character(...)). Aussi, soyez conscient de data.frame() et as.data.frame()s comportement par défaut de la conversion de caractère de facteur.

    • +1 pour la postérité, même si je ne comprends pas quelle est la différence.
    • Si vous faites allusion à l'utilisation de switch, pour moi, c'est essentiellement esthétique et rend le code plus facile à lire. Vous ne savez pas si il n'y a aucune différence de performances, bien que je soupçonne pas.
    • +1 pour recommander lapply. J'ai lutté pour optimiser ce type de problème dans le passé, et il s'avère que le [<- opération est plutôt lent.
    • Comment le temps passe vite. Maintenant que data.table a := c'est le chemin à parcourir pour que cette question devrait être beaucoup beaucoup plus rapide. [<- a été lente parce que c'était la copie de l'ensemble des données.image chaque fois qu'une colonne changé. Si j'ajoute une réponse, aura besoin de votes et puis demandez-OP à accepter le changement?
    • Est-ce à la fonction de convertir des facteurs numériques numériques (j'.e 3.6 = 3.6, pas le facteur numéro de commande)? Comment les intégrer dans la fonction? J'ai essayé aussi.numérique(comme.caractère), qui ne fonctionne pas.
    • esprit de la publication des données.le tableau de la solution? N'ai pas fait beaucoup avec elle, de sorte que ce n'est pas forcément une évidence pour moi. Semble intéressant, cependant.
    • Salut. Une boucle set comme lors de la dernière édition en cette réponse c'est la façon dont je le ferais. Remplacer le - avec un appel à as(...), ou similaire.
    • Est-il possible d'utiliser les noms réels des colonnes au lieu d'en partenariat avec le type de l'index?
    • Je reçois l'erreur Error in FUN(1:11[[11L]], ...) : could not find function "FUN1". Toutes les pensées de ce que je fais de mal?
    • avez-vous jamais à comprendre comment gérer les sous.numérique(comme.caractère) problème?
    • Oui. Je l'ai ajouté comme une réponse à ce fil.

    InformationsquelleAutor joran
  2. 17

    Si vous voulez détecter automatiquement les colonnes de type de données, plutôt que de spécifier manuellement (par ex. après des données-rangement, etc.), la fonction type.la fonction convert() peut aider.

    La fonction type.convert() prend un caractère de vecteur et tente de déterminer le type optimal pour tous les éléments (ce qui signifie qu'il doit être appliqué une fois par colonne). 

    df[] <- lapply(df, function(x) type.convert(as.character(x)))

    Puisque j'aime dplyr, je préfère:

    library(dplyr)
df <- df %>% mutate_all(funs(type.convert(as.character(.))))
    • Votre première option devrait probablement être df[] <- lapply(df, function(x) type.convert(as.character(x)). Je voudrais déposer le apply option, car il est généralement destiné à produire une matrice ou d'un tableau. Vous avez mal orthographié dplyr dans votre troisième option. Enfin, ce n'est pas vraiment une réponse à la discussion de la question, mais plutôt à une question connexe.
    • Merci pour la mise en forme des conseils. Il m'a fallu beaucoup de temps pour trouver une fonctionnalité comme le type.convertir, alors j'ai pensé à le placer ici sur un problème similaire qui est venu le plus souvent aiderait quelqu'un comme moi en bas de la route.
    • juste assez, mais la peine peut-être à la recherche à cette question
    InformationsquelleAutor Luke Hankins
  3. 7

    J'ai trouver je rencontre ce aussi beaucoup. C'est la façon dont vous importez des données. Tous de le lire...() les fonctions ont un certain type de l'option permettant de spécifier le pas de la conversion de chaînes de caractères à un facteur. Ce qui signifie que les chaînes de texte de séjour de caractère et de choses qui ressemblent à des numéros de rester comme des nombres. Un problème se pose lorsque vous avez des éléments qui sont vides et pas NA. Mais encore une fois, na.chaînes = c("",...) devrait résoudre cela. Je voudrais commencer par prendre un coup d'oeil dur à votre processus d'importation et de l'ajuster en conséquence.

    Mais vous pouvez toujours créer une fonction et appuyez sur cette chaîne à travers.

    convert.magic <- function(x, y=NA) {
for(i in 1:length(y)) { 
if (y[i] == "numeric") { 
x[i] <- as.numeric(x[[i]])
}
if (y[i] == "character")
x[i] <- as.character(x[[i]])
}
return(x)
}

foo <- convert.magic(foo, c("character", "character", "numeric"))

> str(foo)
'data.frame':   10 obs. of  3 variables:
 $ x: chr  "1" "2" "3" "4" ...
 $ y: chr  "red" "red" "red" "blue" ...
 $ z: num  15254 15255 15256 15257 15258 ...
    • Essayez de remplacer le if états avec un appel à switch, ce qui peut réellement de retour de la fonction appropriée: switch(expr,character = as.character, numeric = as.numeric,...).
    • meh, écrire comme une réponse si vous pouvez obtenir des points bonus 🙂 je viens de whiped quelque chose de rapide.
    InformationsquelleAutor Brandon Bertelsen
  4. 5

    Je sais je suis très en retard pour répondre, mais à l'aide d'une boucle avec les attributs de la fonction est une solution simple à votre problème.

    names <- c("x", "y", "z")
chclass <- c("character", "character", "numeric")

for (i in (1:length(names))) {
  attributes(foo[, names[i]])$class <- chclass[i]
}
    InformationsquelleAutor SeaJane
  5. 2

    Je viens de tomber sur quelque chose comme ça avec RSQLite méthode de récupération... les résultats de revenir comme atomique types de données. Dans mon cas, c'était un horodatage qui était de me causer de la frustration.
    J'ai trouvé que le setAs fonction est très utile pour aider à faire as fonctionner comme prévu. Voici mon petit exemple de cas. 

    ##data.frame conversion function
convert.magic2 <- function(df,classes){
  out <- lapply(1:length(classes),
                FUN = function(classIndex){as(df[,classIndex],classes[classIndex])})
  names(out) <- colnames(df)
  return(data.frame(out))
}

##small example case
tmp.df <- data.frame('dt'=c("2013-09-02 09:35:06", "2013-09-02 09:38:24", "2013-09-02 09:38:42", "2013-09-02 09:38:42"),
                     'v'=c('1','2','3','4'),
                     stringsAsFactors=FALSE)
classes=c('POSIXct','numeric')
str(tmp.df)
#confirm that it has character datatype columns
##  'data.frame':  4 obs. of  2 variables:
##    $ dt: chr  "2013-09-02 09:35:06" "2013-09-02 09:38:24" "2013-09-02 09:38:42" "2013-09-02 09:38:42"
##    $ v : chr  "1" "2" "3" "4"

##is the dt column coerceable to POSIXct?
canCoerce(tmp.df$dt,"POSIXct")
##  [1] FALSE

##and the conver.magic2 function fails also:
tmp.df.n <- convert.magic2(tmp.df,classes)

##  Error in as(df[, classIndex], classes[classIndex]) : 
##    no method or default for coercing “character” to “POSIXct” 

##ittle reading reveals the setAS function
setAs('character', 'POSIXct', function(from){return(as.POSIXct(from))})

##better answer for canCoerce
canCoerce(tmp.df$dt,"POSIXct")
##  [1] TRUE

##better answer from conver.magic2
tmp.df.n <- convert.magic2(tmp.df,classes)

##column datatypes converted as I would like them!
str(tmp.df.n)

##  'data.frame':  4 obs. of  2 variables:
##    $ dt: POSIXct, format: "2013-09-02 09:35:06" "2013-09-02 09:38:24" "2013-09-02 09:38:42" "2013-09-02 09:38:42"
##   $ v : num  1 2 3 4
    InformationsquelleAutor Osunderdog
  6. 1

    Un peu simple de données.le tableau de la solution, même si cela prendra quelques étapes si vous sont en train de changer beaucoup de différents types de colonne.

    dt <- data.table( x=c(1:10), y=c(10:20), z=c(10:20), name=letters[1:10])

dt <- dt[, lapply(.SD, as.numeric), by= name]

    Cela va changer toutes les colonnes à l'exception de ceux spécifiés dans by numérique (ou ce que vous définissez dans lapply)

    InformationsquelleAutor moman822
  7. 0

    Outre @joran réponse, en ce qui convert.magic ne seraient pas préserver les valeurs numériques du facteur de conversion numérique:

    convert.magic <- function(obj,types){
    out <- lapply(1:length(obj),FUN = function(i){FUN1 <- switch(types[i],
    character = as.character,numeric = as.numeric,factor = as.factor); FUN1(obj[,i])})
    names(out) <- colnames(obj)
    as.data.frame(out,stringsAsFactors = FALSE)
}

foo<-data.frame(x=c(1:10), 
                    y=c("red", "red", "red", "blue", "blue", 
                        "blue", "yellow", "yellow", "yellow", 
                        "green"),
                    z=Sys.Date()+c(1:10))

foo$x<-as.character(foo$x)
foo$y<-as.character(foo$y)
foo$z<-as.numeric(foo$z)

str(foo)
# 'data.frame': 10 obs. of  3 variables:
# $ x: chr  "1" "2" "3" "4" ...
# $ y: chr  "red" "red" "red" "blue" ...
# $ z: num  16777 16778 16779 16780 16781 ...

foo.factors <- convert.magic(foo, rep("factor", 3))

str(foo.factors) # all factors

foo.numeric.not.preserved <- convert.magic(foo.factors, c("numeric", "character", "numeric"))

str(foo.numeric.not.preserved)
# 'data.frame': 10 obs. of  3 variables:
# $ x: num  1 3 4 5 6 7 8 9 10 2
# $ y: chr  "red" "red" "red" "blue" ...
# $ z: num  1 2 3 4 5 6 7 8 9 10

# z comes out as 1 2 3...

    Suivantes doivent préserver les valeurs numériques:

    ## as.numeric function that preserves numeric values when converting factor to numeric

as.numeric.mod <- function(x) {
    if(is.factor(x))
      as.numeric(levels(x))[x]
  else
      as.numeric(x)
}

## The same than in @joran's answer, except for as.numeric.mod
convert.magic <- function(obj,types){
    out <- lapply(1:length(obj),FUN = function(i){FUN1 <- switch(types[i],
    character = as.character,numeric = as.numeric.mod, factor = as.factor); FUN1(obj[,i])})
    names(out) <- colnames(obj)
    as.data.frame(out,stringsAsFactors = FALSE)
}

foo.numeric <- convert.magic(foo.factors, c("numeric", "character", "numeric"))

str(foo.numeric)
# 'data.frame': 10 obs. of  3 variables:
# $ x: num  1 2 3 4 5 6 7 8 9 10
# $ y: chr  "red" "red" "red" "blue" ...
# $ z: num  16777 16778 16779 16780 16781 ...

# z comes out with the correct numeric values
    InformationsquelleAutor Mikko
  8. 0

    Transformer, c'est ce que vous semblez décrire:

    foo <- transform(foo, x=as.character(x), y=as.character(y), z=as.numeric(z))
    InformationsquelleAutor leo277