R-Datentypen: numeric, character, logical (typeof & class)

Die Datentypen in R

Jeder Wert in R hat einen von wenigen atomaren Typen. Vier davon erledigen fast die gesamte Arbeit:

• double - Dezimalzahlen: 3.14, -2, 1e6. Das ist, was R mit "numeric" meint, und der Standard für jede Zahl, die du tippst.
• integer - ganze Zahlen, exakt gespeichert, geschrieben mit L-Suffix: 42L.
• character - Text in Anführungszeichen: "hello".
• logical - die beiden Wahrheitswerte TRUE und FALSE (dazu NA, der fehlende Wert - siehe fehlende Werte).

Es gibt außerdem complex (2 + 3i) für gelegentliche Signalverarbeitungsmathematik; man kann jahrelang ohne auskommen. typeof() verrät dir, welchen Typ ein Wert hat:

cat(typeof(3.14), "\n")
cat(typeof(42L), "\n")
cat(typeof("hello"), "\n")
cat(typeof(TRUE), "\n")
cat(typeof(2 + 3i), "\n")

Beachte die erste Zeile: Eine einfache Zahl ist ein double, selbst wenn sie ganzzahlig aussieht. typeof(42) ist "double"; nur 42L ist ein Integer. Im Analysealltag spielt der Unterschied selten eine Rolle - R konvertiert stillschweigend zwischen beiden -, aber er erklärt viel von der sonst verwirrenden Ausgabe von typeof().

typeof() vs. class(): Warum sie sich uneins sind

R hat zwei Funktionen, die beide die Frage "Was ist das?" zu beantworten scheinen, und sie beantworten subtil unterschiedliche Fragen.

• typeof() meldet den Speichertyp: wie der Wert im Arbeitsspeicher liegt.
• class() meldet den Verhaltenstyp: das Etikett, mit dem R's Methodendispatch entscheidet, welches print oder summary etwa ausgeführt wird.

Bei einfachen Werten unterscheiden sich die Antworten nur im Vokabular:

x <- 3.14
cat(typeof(x), "\n")
cat(class(x), "\n")

typeof() sagt double (die Speicherung), class() sagt numeric (das Verhalten). Bei Strukturen wird die Kluft größer:

m <- matrix(1:4, nrow = 2)
cat(typeof(m), "\n")
print(class(m))

Die Matrix wird als schlichter Integer-Vektor gespeichert, verhält sich aber wie eine Matrix - class() ist das, was R sagt, sie als Gitter auszugeben. Dieselbe Trennung zeigt sich bei Data Frames (typeof sagt "list", class sagt "data.frame") und bei Datumswerten (typeof sagt "double", class sagt "Date").

Die praktische Regel: Nutze class(), wenn du wissen willst, was etwas im Alltagssinn ist, und typeof(), wenn du debuggst, was R unter der Haube tut.

Typen prüfen mit is.*()

Zu jedem Typ gibt es ein passendes Prädikat, das TRUE oder FALSE zurückgibt - praktisch in Funktionen, die ihre Eingaben validieren müssen:

x <- 10
cat(is.numeric(x), is.character(x), is.logical(x), "\n")

Eine Falle lohnt es zu kennen: is.numeric() ist TRUE für beides, Doubles und Integers (beides sind Zahlen), aber is.integer() prüft die Speicherung und ist deshalb FALSE für ein schlichtes 42:

cat(is.numeric(42L), "\n")
cat(is.integer(42), "\n")
cat(is.integer(42L), "\n")

Falls du dich je gewundert hast, dass is.integer(7) für eine Zahl, die im mathematischen Sinne offensichtlich ganzzahlig ist, FALSE ergibt - das ist der Grund. 7 ist ein Double; 7L ist ein Integer.

Typen konvertieren mit as.*()

Explizite Konvertierung nutzt die as.*-Familie, eine Funktion pro Zieltyp:

cat(as.numeric("3.5") + 1, "\n")
cat(as.integer(7.9), "\n")
cat(as.character(42), "\n")
cat(as.logical("TRUE"), "\n")

Zwei Verhaltensweisen zum Merken. as.integer() schneidet in Richtung null ab, statt zu runden - 7.9 wird 7. Und wenn eine Konvertierung keinen Sinn ergibt, wirft R keinen Fehler; es gibt NA zurück und meldet eine Warnung:

result <- as.numeric("abc")
print(result)

Führ das aus, und du siehst NA plus eine "NAs introduced by coercion"-Warnung. Das ist wirklich nützlich - konvertiere eine ganze Spalte unsauberen Texts in Zahlen, und die nicht parsbaren Einträge werden zu NA, statt dein Skript abstürzen zu lassen -, es bedeutet aber auch, dass sich ein stilles NA in deine Daten schleichen kann. Wenn eine Konvertierung wichtig ist, prüfe hinterher auf neue NAs.

Logicals konvertieren von und zu Zahlen so, wie man es sich wünscht: as.numeric(TRUE) ist 1, as.logical(0) ist FALSE. Deshalb zählt sum() bei einem logischen Vektor die TRUEs:

passed <- c(TRUE, TRUE, FALSE, TRUE)
cat(sum(passed), "out of", length(passed), "\n")

Implizite Coercion: Die Ein-Typ-Regel für Vektoren

Ein atomarer Vektor in R kann nur einen Typ enthalten. Kombinierst du gemischte Werte mit c(), befördert R stillschweigend alles auf den flexibelsten vorhandenen Typ, entlang einer festen Leiter:

logical → integer → double → character

print(c(TRUE, FALSE, 2L))
print(c(1L, 2L, 3.5))
print(c(1, 2, "three"))

Die Logicals wurden zu 1 und 0, die Integers zu Doubles, und in der letzten Zeile wurde alles zu Text - character gewinnt immer, denn jeder Wert lässt sich als Zeichenkette schreiben. Bestätigen kannst du das mit typeof():

cat(typeof(c(TRUE, 1L)), "\n")
cat(typeof(c(1L, 2.5)), "\n")
cat(typeof(c(1, "a")), "\n")

Coercion ist die Ursache Nummer eins für "Warum ist meine Spalte Text?"-Bugs: Ein einziger verirrter "N/A"-String in einer Zahlenspalte zwingt den gesamten Vektor auf character. Wenn das passiert, korrigiere zuerst den störenden Wert und konvertiere dann mit as.numeric() zurück.

Was du mitnimmst

• Vier Arbeitspferd-Typen: double ("numeric"), integer (42L), character, logical.
• typeof() = wie gespeichert; class() = wie es sich verhält. 3.14 ist ein double, das sich als numeric verhält.
• Prüfen mit is.numeric() und Co.; konvertieren mit as.numeric() und Co. - gescheiterte Konvertierungen liefern NA mit Warnung, keinen Fehler.
• Vektoren enthalten nur einen Typ; Mischen erzwingt Coercion entlang logical → integer → double → character.

Als Nächstes: ein genauerer Blick auf die numerischen Typen - Runden, Mathematikfunktionen und die Fließkomma-Überraschungen, die alle Sprachen teilen.