Konvertieren Sie data.frame-Spalten von Faktoren in Zeichen

Ich habe einen Datenrahmen. Nennen wir ihn bob:

> head(bob)
                 phenotype                         exclusion
GSM399350 3- 4- 8- 25- 44+ 11b- 11c- 19- NK1.1- Gr1- TER119-
GSM399351 3- 4- 8- 25- 44+ 11b- 11c- 19- NK1.1- Gr1- TER119-
GSM399352 3- 4- 8- 25- 44+ 11b- 11c- 19- NK1.1- Gr1- TER119-
GSM399353 3- 4- 8- 25+ 44+ 11b- 11c- 19- NK1.1- Gr1- TER119-
GSM399354 3- 4- 8- 25+ 44+ 11b- 11c- 19- NK1.1- Gr1- TER119-
GSM399355 3- 4- 8- 25+ 44+ 11b- 11c- 19- NK1.1- Gr1- TER119-

Ich möchte die Zeilen dieses Datenrahmens verketten (dies wird eine andere Frage sein). Aber schau:

> class(bob$phenotype)
[1] "factor"

BobDie Spalten sind Faktoren. Also zum Beispiel:

> as.character(head(bob))
[1] "c(3, 3, 3, 6, 6, 6)"       "c(3, 3, 3, 3, 3, 3)"      
[3] "c(29, 29, 29, 30, 30, 30)"

Ich fange nicht an, das zu verstehen, aber ich denke, dies sind Indizes für die Faktoren der Säulen (des Hofes des Königs Caractacus) von bob? Nicht was ich brauche.

Seltsamerweise kann ich die Säulen bobvon Hand durchgehen und es tun

bob$phenotype <- as.character(bob$phenotype)

das funktioniert gut. Und nach einigem Tippen kann ich einen data.frame erhalten, dessen Spalten eher Zeichen als Faktoren sind. Meine Frage lautet also: Wie kann ich das automatisch tun? Wie konvertiere ich einen data.frame mit Faktorspalten in einen data.frame mit Zeichenspalten, ohne jede Spalte manuell durchgehen zu müssen?

Bonusfrage: Warum funktioniert der manuelle Ansatz?

Ich folge nur Matt und Dirk. Wenn Sie Ihren vorhandenen Datenrahmen neu erstellen möchten, ohne die globale Option zu ändern, können Sie ihn mit einer apply-Anweisung neu erstellen:

bob <- data.frame(lapply(bob, as.character), stringsAsFactors=FALSE)

Dadurch werden alle Variablen in die Klasse "Zeichen" konvertiert. Wenn Sie nur Faktoren konvertieren möchten, siehe Mareks Lösung unten .

Wie @hadley hervorhebt, ist das Folgende prägnanter.

bob[] <- lapply(bob, as.character)

In beiden Fällen wird lapplyeine Liste ausgegeben. []Aufgrund der magischen Eigenschaften von R behält die Verwendung von im zweiten Fall jedoch die data.frame-Klasse des bobObjekts bei, wodurch die Notwendigkeit entfällt, as.data.framemit dem Argument zurück in einen data.frame zu konvertieren stringsAsFactors = FALSE.

Um nur Faktoren zu ersetzen:

i <- sapply(bob, is.factor)
bob[i] <- lapply(bob[i], as.character)

Im Paket dplyr in Version 0.5.0 wurde eine neue Funktion mutate_ifeingeführt :

library(dplyr)
bob %>% mutate_if(is.factor, as.character) -> bob

Das Paket purrr von RStudio bietet eine weitere Alternative:

library(purrr)
library(dplyr)
bob %>% map_if(is.factor, as.character) %>% as_tibble -> bob

Die globale Option

stringAsFactors: Die Standardeinstellung für die Argumente data.frame und read.table.

Möglicherweise möchten Sie dies FALSEin Ihren Startdateien festlegen (z. B. ~ / .Rprofile). Bitte sehen Sie help(options).

Wenn Sie verstehen, wie Faktoren gespeichert werden, können Sie vermeiden, anwendungsbasierte Funktionen zu verwenden, um dies zu erreichen. Was keineswegs bedeutet, dass die Anwendungslösungen nicht gut funktionieren.

Faktoren sind als numerische Indizes strukturiert, die an eine Liste von „Ebenen“ gebunden sind. Dies wird angezeigt, wenn Sie einen Faktor in einen numerischen Wert umwandeln. Damit:

> fact <- as.factor(c("a","b","a","d")
> fact
[1] a b a d
Levels: a b d

> as.numeric(fact)
[1] 1 2 1 3

Die in der letzten Zeile zurückgegebenen Zahlen entsprechen den Pegeln des Faktors.

> levels(fact)
[1] "a" "b" "d"

Beachten Sie, dass levels()ein Array von Zeichen zurückgegeben wird. Mit dieser Tatsache können Sie Faktoren einfach und kompakt in Zeichenfolgen oder Zahlen wie diese umwandeln:

> fact_character <- levels(fact)[as.numeric(fact)]
> fact_character
[1] "a" "b" "a" "d"

Dies funktioniert auch für numerische Werte, sofern Sie Ihren Ausdruck einschließen as.numeric().

> num_fact <- factor(c(1,2,3,6,5,4))
> num_fact
[1] 1 2 3 6 5 4
Levels: 1 2 3 4 5 6
> num_num <- as.numeric(levels(num_fact)[as.numeric(num_fact)])
> num_num
[1] 1 2 3 6 5 4

Wenn Sie einen neuen Datenrahmen wünschen, bobcin dem jeder Faktorvektor in bobfeinen Zeichenvektor konvertiert wird, versuchen Sie Folgendes:

bobc <- rapply(bobf, as.character, classes="factor", how="replace")

Wenn Sie es dann zurückkonvertieren möchten, können Sie einen logischen Vektor erstellen, dessen Spalten Faktoren sind, und diesen verwenden, um den Faktor selektiv anzuwenden

f <- sapply(bobf, class) == "factor"
bobc[,f] <- lapply(bobc[,f], factor)

Normalerweise mache ich diese Funktion von all meinen Projekten getrennt. Schnell und einfach.

unfactorize <- function(df){
  for(i in which(sapply(df, class) == "factor")) df[[i]] = as.character(df[[i]])
  return(df)
}

Eine andere Möglichkeit besteht darin, es mit apply zu konvertieren

bob2 <- apply(bob,2,as.character)

Und eine bessere (die vorherige ist von der Klasse 'Matrix')

bob2 <- as.data.frame(as.matrix(bob),stringsAsFactors=F)

Update: Hier ist ein Beispiel für etwas, das nicht funktioniert. Ich dachte, es würde, aber ich denke, dass die Option stringsAsFactors nur für Zeichenfolgen funktioniert - sie lässt die Faktoren in Ruhe.

Versuche dies:

bob2 <- data.frame(bob, stringsAsFactors = FALSE)

Wenn Sie Probleme mit Faktoren haben, die Zeichen sein sollten, gibt es im Allgemeinen eine stringsAsFactorsEinstellung, die Ihnen helfen kann (einschließlich einer globalen Einstellung).

Oder Sie können versuchen transform:

newbob <- transform(bob, phenotype = as.character(phenotype))

Stellen Sie einfach sicher, dass Sie jeden Faktor, den Sie konvertieren möchten, in Zeichen umwandeln.

Oder Sie können so etwas tun und alle Schädlinge mit einem Schlag töten:

newbob_char <- as.data.frame(lapply(bob[sapply(bob, is.factor)], as.character), stringsAsFactors = FALSE)
newbob_rest <- bob[!(sapply(bob, is.factor))]
newbob <- cbind(newbob_char, newbob_rest)

Es ist keine gute Idee, die Daten in Code wie diesen zu verschieben, ich könnte das tunsapply Teil separat (eigentlich ist es viel einfacher, dies so zu tun), aber Sie verstehen, dass ... ich den Code nicht überprüft habe, weil Ich bin nicht zu Hause, also hoffe ich, dass es funktioniert! =)

Dieser Ansatz hat jedoch einen Nachteil ... Sie müssen die Spalten anschließend neu organisieren, während transformSie mit dem tun können, was Sie möchten , jedoch auf Kosten des "Code-Schreibens im Fußgängerstil" ...

Also da ... =)

Zu Beginn Ihres Datenrahmens schließen Sie ein stringsAsFactors = FALSE, um alle Missverständnisse zu ignorieren.

Wenn Sie data.tablepackage für die Operationen an data.frame verwenden würden, liegt das Problem nicht vor.

library(data.table)
dt = data.table(col1 = c("a","b","c"), col2 = 1:3)
sapply(dt, class)
#       col1        col2 
#"character"   "integer" 

Wenn Ihr Datensatz bereits eine Faktorspalte enthält und Sie diese in Zeichen konvertieren möchten, können Sie Folgendes tun.

library(data.table)
dt = data.table(col1 = factor(c("a","b","c")), col2 = 1:3)
sapply(dt, class)
#     col1      col2 
# "factor" "integer" 
upd.cols = sapply(dt, is.factor)
dt[, names(dt)[upd.cols] := lapply(.SD, as.character), .SDcols = upd.cols]
sapply(dt, class)
#       col1        col2 
#"character"   "integer" 

Das funktioniert bei mir - ich habe mir endlich einen Einzeiler ausgedacht

df <- as.data.frame(lapply(df,function (y) if(class(y)=="factor" ) as.character(y) else y),stringsAsFactors=F)

Diese Funktion macht den Trick

df <- stacomirtools::killfactor(df)

Vielleicht eine neuere Option?

library("tidyverse")

bob <- bob %>% group_by_if(is.factor, as.character)

Sie sollten verwenden convertin hablarmit kompatibeler lesbarer Syntax gibt , die tidyverse: Rohre

library(dplyr)
library(hablar)

df <- tibble(a = factor(c(1, 2, 3, 4)),
             b = factor(c(5, 6, 7, 8)))

df %>% convert(chr(a:b))

was dir gibt:

  a     b    
  <chr> <chr>
1 1     5    
2 2     6    
3 3     7    
4 4     8   

Mit dem dplyrgeladenen Paket verwenden

bob=bob%>%mutate_at("phenotype", as.character)

wenn Sie nur die phenotype-column speziell ändern möchten.

Dies funktioniert, indem alle in Zeichen und dann die Zahlen in Zahlen umgewandelt werden:

makenumcols<-function(df){
  df<-as.data.frame(df)
  df[] <- lapply(df, as.character)
  cond <- apply(df, 2, function(x) {
    x <- x[!is.na(x)]
    all(suppressWarnings(!is.na(as.numeric(x))))
  })
  numeric_cols <- names(df)[cond]
  df[,numeric_cols] <- sapply(df[,numeric_cols], as.numeric)
  return(df)
}

Angepasst von: Holen Sie sich automatisch Spaltentypen von Excel-Tabellen