Comment faire pour convertir un bloc de données de la colonne de type numérique?

Depuis (encore) personne n'a pu vérifier la marque, je suppose que vous avez une question pratique à l'esprit, surtout parce que vous n'avez pas spécifié de quel type de vecteur que vous voulez convertir à numeric. Je suggère que vous devriez appliquer transform fonction afin de compléter votre tâche.

Maintenant, je suis sur le point de démontrer certaines "conversion anomalie":

# create dummy data.frame
d <- data.frame(char = letters[1:5], 
                fake_char = as.character(1:5), 
                fac = factor(1:5), 
                char_fac = factor(letters[1:5]), 
                num = 1:5, stringsAsFactors = FALSE)

Laissez-nous jeter un coup d'œil à data.frame

> d
  char fake_char fac char_fac num
1    a         1   1        a   1
2    b         2   2        b   2
3    c         3   3        c   3
4    d         4   4        d   4
5    e         5   5        e   5

et courons:

> sapply(d, mode)
       char   fake_char         fac    char_fac         num 
"character" "character"   "numeric"   "numeric"   "numeric" 
> sapply(d, class)
       char   fake_char         fac    char_fac         num 
"character" "character"    "factor"    "factor"   "integer" 

Maintenant vous avez probablement vous demandez-vous à ", Où une anomalie?" Bien, je l'ai croisé tout à fait étrange, les choses dans R, et ce n'est pas la la plupart de confusion chose, mais il peut vous confondre, surtout si vous lisez ceci avant de rouler dans le lit.

Va ici: les deux premières colonnes sont character. J'ai délibérément appelé 2^ème un fake_char. Spot la similitude de ce character variable avec un que Dirk créé dans sa réponse. C'est en fait un numerical vecteur converti à character. 3^rd et 4^ème de la colonne sont factor, et le dernier est "purement" numeric.

Si vous utilisez transform fonction, vous pouvez convertir le fake_char en numeric, mais pas le char variable elle-même.

> transform(d, char = as.numeric(char))
  char fake_char fac char_fac num
1   NA         1   1        a   1
2   NA         2   2        b   2
3   NA         3   3        c   3
4   NA         4   4        d   4
5   NA         5   5        e   5
Warning message:
In eval(expr, envir, enclos) : NAs introduced by coercion

mais si vous faites la même chose sur fake_char et char_fac, vous aurez de la chance, et sortir avec aucun NA:

> transform(d, fake_char = as.numeric(fake_char), 
               char_fac = as.numeric(char_fac))

  char fake_char fac char_fac num
1    a         1   1        1   1
2    b         2   2        2   2
3    c         3   3        3   3
4    d         4   4        4   4
5    e         5   5        5   5

Si vous enregistrez transformé data.frame et vérifier mode et class, vous obtiendrez:

> D <- transform(d, fake_char = as.numeric(fake_char), 
                    char_fac = as.numeric(char_fac))

> sapply(D, mode)
       char   fake_char         fac    char_fac         num 
"character"   "numeric"   "numeric"   "numeric"   "numeric" 
> sapply(D, class)
       char   fake_char         fac    char_fac         num 
"character"   "numeric"    "factor"   "numeric"   "integer"

Donc, la conclusion est: Oui, vous pouvez convertir character vecteur dans un numeric, mais seulement si c'est des éléments sont des "convertibles" à numeric. Si il y a juste un character élément dans le vecteur, vous obtiendrez l'erreur quand vous essayez de convertir les vecteurs de numerical un.

Et, juste pour prouver mon point:

> err <- c(1, "b", 3, 4, "e")
> mode(err)
[1] "character"
> class(err)
[1] "character"
> char <- as.numeric(err)
Warning message:
NAs introduced by coercion 
> char
[1]  1 NA  3  4 NA

Et maintenant, juste pour le plaisir (ou la pratique), d'essayer de deviner le résultat de ces commandes:

> fac <- as.factor(err)
> fac
???
> num <- as.numeric(fac)
> num
???

Salutations à Patrick Burns! =)

si x est le nom de la colonne de dataframe dat, et x est de type facteur, utilisation:

as.numeric(as.character(dat$x))

Tim est correct, et Shane a une omission. Voici d'autres exemples:

R> df <- data.frame(a = as.character(10:15))
R> df <- data.frame(df, num = as.numeric(df$a), 
                        numchr = as.numeric(as.character(df$a)))
R> df
   a num numchr
1 10   1     10
2 11   2     11
3 12   3     12
4 13   4     13
5 14   5     14
6 15   6     15
R> summary(df)
  a          num           numchr    
 10:1   Min.   :1.00   Min.   :10.0  
 11:1   1st Qu.:2.25   1st Qu.:11.2  
 12:1   Median :3.50   Median :12.5  
 13:1   Mean   :3.50   Mean   :12.5  
 14:1   3rd Qu.:4.75   3rd Qu.:13.8  
 15:1   Max.   :6.00   Max.   :15.0  
R> 

Notre data.frame a maintenant un résumé du facteur de colonne (compte) et numérique des résumés de la as.numeric() --- qui est mal comme il a obtenu le numérique facteur de niveaux --- et le (bon) résumé de la as.numeric(as.character()).

Alors que votre question est strictement numérique, il y a beaucoup de conversions qui sont difficiles à comprendre au début R. je vais le but d'aborder les méthodes pour aider. Cette question est similaire à Cette Question.

Type de conversion peut être une douleur dans R, parce que (1) les facteurs ne peuvent pas être directement converti en numérique, ils doivent être convertis pour le caractère de classe de première, (2) les dates sont un cas spécial que vous n'avez généralement besoin de traiter séparément, et (3) en boucle à travers le bloc de données des colonnes peut être délicat. Heureusement, le "tidyverse" a résolu la plupart des problèmes.

Cette solution utilise mutate_each() appliquer une fonction à toutes les colonnes d'un bloc de données. Dans ce cas, nous voulons appliquer la type.convert() fonction qui convertit les chaînes en numérique, où il peut. Parce que les R aime facteurs (je ne sais pas pourquoi) les colonnes de caractères qui doit rester personnage a changé de facteur. Pour corriger cela, le mutate_if() fonction est utilisée pour détecter les colonnes et les facteurs de changement de personnage. Enfin, j'ai voulu montrer comment lubridate peut être utilisé pour modifier un horodatage dans la classe de personnage à jour en temps parce que c'est aussi souvent un coincement de bloc pour les débutants.

library(tidyverse) 
library(lubridate)

# Recreate data that needs converted to numeric, date-time, etc
data_df
#> # A tibble: 5 × 9
#>             TIMESTAMP SYMBOL    EX  PRICE  SIZE  COND   BID BIDSIZ   OFR
#>                 <chr>  <chr> <chr>  <chr> <chr> <chr> <chr>  <chr> <chr>
#> 1 2012-05-04 09:30:00    BAC     T 7.8900 38538     F  7.89    523  7.90
#> 2 2012-05-04 09:30:01    BAC     Z 7.8850   288     @  7.88  61033  7.90
#> 3 2012-05-04 09:30:03    BAC     X 7.8900  1000     @  7.88   1974  7.89
#> 4 2012-05-04 09:30:07    BAC     T 7.8900 19052     F  7.88   1058  7.89
#> 5 2012-05-04 09:30:08    BAC     Y 7.8900 85053     F  7.88 108101  7.90

# Converting columns to numeric using "tidyverse"
data_df %>%
    mutate_all(type.convert) %>%
    mutate_if(is.factor, as.character) %>%
    mutate(TIMESTAMP = as_datetime(TIMESTAMP, tz = Sys.timezone()))
#> # A tibble: 5 × 9
#>             TIMESTAMP SYMBOL    EX PRICE  SIZE  COND   BID BIDSIZ   OFR
#>                <dttm>  <chr> <chr> <dbl> <int> <chr> <dbl>  <int> <dbl>
#> 1 2012-05-04 09:30:00    BAC     T 7.890 38538     F  7.89    523  7.90
#> 2 2012-05-04 09:30:01    BAC     Z 7.885   288     @  7.88  61033  7.90
#> 3 2012-05-04 09:30:03    BAC     X 7.890  1000     @  7.88   1974  7.89
#> 4 2012-05-04 09:30:07    BAC     T 7.890 19052     F  7.88   1058  7.89
#> 5 2012-05-04 09:30:08    BAC     Y 7.890 85053     F  7.88 108101  7.90

De façon universelle à l'aide de type.convert() et rapply():

convert_types <- function(x) {
    stopifnot(is.list(x))
    x[] <- rapply(x, utils::type.convert, classes = "character",
                  how = "replace", as.is = TRUE)
    return(x)
}
d <- data.frame(char = letters[1:5], 
                fake_char = as.character(1:5), 
                fac = factor(1:5), 
                char_fac = factor(letters[1:5]), 
                num = 1:5, stringsAsFactors = FALSE)
sapply(d, class)
#>        char   fake_char         fac    char_fac         num 
#> "character" "character"    "factor"    "factor"   "integer"
sapply(convert_types(d), class)
#>        char   fake_char         fac    char_fac         num 
#> "character"   "integer"    "factor"    "factor"   "integer"

Si d'autres ont couvert le sujet assez bien, je voudrais ajouter ce supplément de pensée rapide/hint. Vous pouvez utiliser les regexp de vérifier à l'avance si les caractères potentiellement se composer uniquement de chiffres.

for(i in seq_along(names(df)){
     potential_numcol[i] <- all(!grepl("[a-zA-Z]",d[,i]))
}
# and now just convert only the numeric ones
d <- sapply(d[,potential_numcol],as.numeric)

Pour les plus sophistiquées des expressions régulières et soigné pourquoi à apprendre de l'expérience de leur pouvoir voir cette très belle site web: http://regexr.com/

Pour convertir les caractères numériques, vous devez le convertir en facteur en appliquant

BankFinal1 <- transform(BankLoan,   LoanApproval=as.factor(LoanApproval))
BankFinal1 <- transform(BankFinal1, LoanApp=as.factor(LoanApproval))

Que vous avez à faire deux colonnes avec les mêmes données, car une colonne ne peut pas convertir en numérique. Si vous effectuez une conversion, il donne l'erreur ci-dessous

transform(BankData, LoanApp=as.numeric(LoanApproval))

Warning message:
  In eval(substitute(list(...)), `_data`, parent.frame()) :
  NAs introduced by coercion

donc, après avoir fait deux colonnes de données s'appliquent

BankFinal1 < transform(BankFinal1, LoanApp      = as.numeric(LoanApp), 
                                   LoanApproval = as.numeric(LoanApproval))

il va transformer le caractère numérique avec succès

avec hablar::convertir

De les convertir facilement en plusieurs colonnes à différents types de données que vous pouvez utiliser hablar::convert. La syntaxe est Simple: df %>% convert(num(a)) convertit la colonne a de df numérique.

Exemple détaillé

Vous permet de convertir toutes les colonnes de mtcars de caractère.

df <- mtcars %>% mutate_all(as.character) %>% as_tibble()

> df
# A tibble: 32 x 11
   mpg   cyl   disp  hp    drat  wt    qsec  vs    am    gear  carb 
   <chr> <chr> <chr> <chr> <chr> <chr> <chr> <chr> <chr> <chr> <chr>
 1 21    6     160   110   3.9   2.62  16.46 0     1     4     4    
 2 21    6     160   110   3.9   2.875 17.02 0     1     4     4    
 3 22.8  4     108   93    3.85  2.32  18.61 1     1     4     1    

Avec hablar::convert:

library(hablar)

# Convert columns to integer, numeric and factor
df %>% 
  convert(int(cyl, vs),
          num(disp:wt),
          fct(gear))

résultats dans:

# A tibble: 32 x 11
   mpg     cyl  disp    hp  drat    wt qsec     vs am    gear  carb 
   <chr> <int> <dbl> <dbl> <dbl> <dbl> <chr> <int> <chr> <fct> <chr>
 1 21        6  160    110  3.9   2.62 16.46     0 1     4     4    
 2 21        6  160    110  3.9   2.88 17.02     0 1     4     4    
 3 22.8      4  108     93  3.85  2.32 18.61     1 1     4     1    
 4 21.4      6  258    110  3.08  3.22 19.44     1 0     3     1