Zum Hauptinhalt springen

Datentypen in R

Lerne Datentypen kennen und warum sie in Programmiersprachen wichtig sind. Konkret: wie du Vektoren, Matrizen, Listen und Data Frames in R nutzt.
· 12 Min. lesen

Entdecke KI

Diagramm zu Datenstrukturen in R

Bevor wir in die Einführung starten und die verschiedenen Datentypen in R kennenlernen, richten wir die R-Umgebung kurz im Terminal und in Jupyter Notebook ein.

Der folgende Befehl gilt für macOS und wird R in deinem Terminal installieren.

brew install r --build-from-source

Um zu prüfen, ob die Installation erfolgreich war, tippe einfach R (Großbuchstabe) ins Terminal. Du landest dann in einer R-Session, wie unten gezeigt.

R-Session

Für die Installation auf anderen Betriebssystemen wirf einen Blick in dieses Tutorial.

Jetzt fügen wir R als Kernel im Jupyter Notebook hinzu. Stelle sicher, dass Jupyter Notebook bereits auf deinem System installiert ist.

Öffne im Terminal eine R-Session und gib die folgenden zwei Befehle ein. Damit wird der R-Kernel zu deinem Jupyter Notebook hinzugefügt.

install.packages('IRkernel')
IRkernel::installspec()

Wenn beide Befehle erfolgreich waren, starte Jupyter im Terminal und öffne ein Notebook mit dem R-Kernel, wie unten zu sehen:

R-Kernel

Jetzt bist du bereit, deinen ersten R-Code im Jupyter Notebook zu schreiben.

Einführung

Um R voll auszuschöpfen, ist es wichtig, die verschiedenen Datentypen und Datenstrukturen in R zu kennen und zu verstehen und zu wissen, wie sie funktionieren. Sie spielen in fast allen Aufgaben eine zentrale Rolle — besonders bei datengetriebenen Machine-Learning-Problemen.

In Programmiersprachen brauchen wir Variablen, um Informationen zu speichern — etwa Ganzzahlen, Zeichen, Gleitkommazahlen, Booleans usw. Der Typ einer Variablen richtet sich allein nach der Art der Information, die sie hält. Wird ihr eine Ganzzahl zugewiesen, hat sie den Datentyp int. Variablen sind reservierte Speicherplätze, an denen Werte abgelegt werden. Sobald du eine Variable erstellst, wird dafür Speicher reserviert.

Je nach Datentyp einer Variablen reserviert das Betriebssystem Speicher. In R belegt eine Variable mit einer Ganzzahl z. B. 4 Bytes, ein einzelnes Zeichen 1 Byte.

In Sprachen wie C, C++ und Java werden Variablen mit einem Datentyp deklariert; in Python und R sind Variablen dagegen Objekte. Objekte sind Datenstrukturen mit Attributen und Methoden, die auf diese Attribute angewendet werden.

Es gibt verschiedene R-Objekte bzw. Datenstrukturen, die wir in diesem Tutorial behandeln:

Schauen wir uns zuerst die grundlegenden Datentypen an, auf denen R-Objekte aufbauen: Numeric, Integer, Character, Factor und Logical.

  • Numeric: Zahlen mit Dezimalstellen oder als Bruch haben den Datentyp numeric.
num <- 1.2
print(num)

[1] 1.2

Den Datentyp von a prüfst du mit class().

class(num)

'numeric'
  • Integer: Zahlen ohne Dezimalstellen haben den Datentyp integer. Um einen Integer explizit zu erzeugen, nutzt du as.integer() und übergibst die Variable als Argument.
int <- as.integer(2.2)
print(int)

[1] 2

class(int)

'integer'
  • Character: Wie der Name sagt: Ein Zeichen oder eine Zeichenfolge in Anführungszeichen wird in R als character interpretiert. Das können Buchstaben oder Ziffern sein.
char <- "datacamp"
print(char)

[1] "datacamp"

class(char)

'character'

char <- "12345"
print(char)

[1] "12345"

class(char)

'character'
  • Logical: Eine Variable, die die Werte TRUE oder FALSE annehmen kann, entspricht einem logischen Datentyp (boolean).
log_true <- TRUE
print(log_true)

[1] TRUE

class(log_true)

'logical'

log_false <- FALSE
print(log_false)

[1] FALSE

class(log_false)

'logical'
  • Factor: Faktoren beschreiben qualitative Merkmale wie Farben, gut & schlecht, Kurs- oder Film-Bewertungen usw. Sie sind in der Statistik sehr nützlich.

Dafür nutzt du die Funktion c(), die alle Elemente kombiniert und einen (eindimensionalen) Vektor zurückgibt.

fac <- factor(c("good", "bad", "ugly","good", "bad", "ugly"))

print(fac)

[1] good bad  ugly good bad  ugly
Levels: bad good ugly

class(fac)

'factor'

Der Faktor fac hat drei Ausprägungen: good, bad und ugly. Das prüfst du mit levels; der Typ der Ausprägungen ist character.

levels(fac)
  1. 'bad'
  2. 'good'
  3. 'ugly'
nlevels(fac)

3

class(levels(fac))

'character'

Bevor wir weitermachen, zwei nützliche Hinweise!

  • Merke dir: R ist case-sensitiv. Alle oben definierten Objekte müssen exakt gleich geschrieben werden, ob groß oder klein — wie im folgenden Beispiel.
Num

Error in eval(expr, envir, enclos): object 'Num' not found
Traceback:
  • Mit ls() listest du alle von dir definierten Variablen bzw. Objekte in der aktuellen Arbeitsumgebung auf.
ls()
  1. 'char'
  2. 'int'
  3. 'num'

Listen

Listenindizierung in Python
(Quelle)

Anders als Vektoren können Listen Elemente verschiedener Datentypen enthalten und werden oft als geordnete Sammlung von Werten beschrieben. In ihnen können Vektoren, Funktionen, Matrizen und sogar weitere Listen (verschachtelte Listen) liegen.

Listen in R sind einsbasiert, d. h. die Indizierung beginnt bei eins.

Verstehen wir Listen mit einem kurzen Beispiel, das drei unterschiedliche Datentypen in einer Liste speichert.

lis1 <- 1:5  # Integer-Vektor
lis1
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
lis2 <- factor(1:5)  # Faktor-Vektor
lis2
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
Ausprägungen:
  1. '1'
  2. '2'
  3. '3'
  4. '4'
  5. '5'
lis3 <- letters[1:5]  # Character-Vektor
lis3
  1. 'a'
  2. 'b'
  3. 'c'
  4. 'd'
  5. 'e'
combined_list <- list(lis1, lis2, lis3)

combined_list
    1. 1
    2. 2
    3. 3
    4. 4
    5. 5
    1. 1
    2. 2
    3. 3
    4. 4
    5. 5
  2. Ausprägungen:
    1. '1'
    2. '2'
    3. '3'
    4. '4'
    5. '5'
    1. 'a'
    2. 'b'
    3. 'c'
    4. 'd'
    5. 'e'

Greifen wir nun auf jeden Vektor in der Liste separat zu. Dafür nutzt du doppelte eckige Klammern, da die drei Vektoren auf derselben Ebene in der Liste liegen. python combined_list[[1]]

  1. 1
  2. 2
  3. 3
  4. 4
  5. 5

python combined_list[[2]]

  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
Ausprägungen:
  1. '1'
  2. '2'
  3. '3'
  4. '4'
  5. '5'
combined_list[[3]]
  1. 'a'
  2. 'b'
  3. 'c'
  4. 'd'
  5. 'e'

Als Nächstes greifen wir auf das fünfte Element des dritten Vektors zu — das ist der Buchstabe e.

combined_list[[3]][5]

'e'

Zum Schluss flatten wir die Liste. Wichtig: Da combined_list eine Kombination aus character- und numeric-Datentypen enthält, hat character Vorrang und der Datentyp der gesamten Liste wird zu character.

flat_list <- unlist(combined_list)

class(flat_list)

'character'

flat_list
  1. '1'
  2. '2'
  3. '3'
  4. '4'
  5. '5'
  6. '1'
  7. '2'
  8. '3'
  9. '4'
  10. '5'
  11. 'a'
  12. 'b'
  13. 'c'
  14. 'd'
  15. 'e'
length(flat_list)

15

Vektoren

Vektor-Matrix
(Quelle)

Vektoren sind Objekte, die mehrere Werte desselben Datentyps speichern. Ein Vektor kann nicht gleichzeitig Integer und Character enthalten. Wenn du z. B. die Gesamtpunkte von 100 Studierenden speichern willst, erstellst du statt 100 einzelner Variablen einen Vektor der Länge 100, der alle Punktzahlen enthält.

Einen Vektor erstellst du mit c(), das alle Elemente kombiniert und ein eindimensionales Array zurückgibt.

Erstellen wir den Vektor marks mit fünf Werten vom Typ numeric.

marks <- c(88,65,90,40,65)

class(marks)

'numeric'

Prüfen wir die Länge des Vektors. Sie entspricht der Anzahl der enthaltenen Elemente.

length(marks)

5

Jetzt greifen wir über den Index auf einzelne Elemente zu.

marks[4]

40

marks[5]

65

marks[6] #gibt NA zurück, da es kein sechstes Element im Vektor gibt

<NA>

  • Slicing: Wie in Python kannst du auch in R slicen.

    Greifen wir per Slicing auf die Elemente vom zweiten bis zum fünften zu.

marks[2:5]
  1. 65
  2. 90
  3. 40
  4. 65

Erstellen wir nun einen character-Vektor — analog zu numeric.

char_vector <- c("a", "b", "c")
print(char_vector)

[1] "a" "b" "c"

class(char_vector)

'character'

length(char_vector)

3

char_vector[1:3]
  1. 'a'
  2. 'b'
  3. 'c'

Wenn ein Vektor sowohl numeric- als auch character-Werte enthält, werden die numerischen Werte in character konvertiert.

char_num_vec <- c(1,2, "a")

char_num_vec
  1. '1'
  2. '2'
  3. 'a'
class(char_num_vec)

'character'

Erstellen wir einen Vektor mit 1024 numerischen Werten mithilfe eines Bereichs.

vec <- c(1:1024)

Greifen wir nun auf das mittlere und das letzte Element zu. Dafür verwenden wir length.

vec[length(vec)]

1024

vec[length(vec)/2]

512
  • Wie erstellst du einen Vektor aus ungeraden Zahlen?

Mit seq erzeugst du einen Vektor aus ungeraden Zahlen. Die Funktion nimmt drei Parameter: Start, Ende und Schrittweite.

seq(1,10, by = 2)
  1. 1
  2. 3
  3. 5
  4. 7
  5. 9

Matrix

Matrix in R
(Quelle)

Wie ein Vektor speichert auch eine Matrix Werte desselben Datentyps. Im Unterschied zum Vektor hält sie jedoch zweidimensionale Informationen.

Die Syntax zum Definieren einer Matrix lautet:

M <- matrix(vector, nrow=r, ncol=c, byrow=FALSE, dimnames=list(char_vector_rownames, char_vector_colnames))

byrow=TRUE bedeutet, dass die Matrix zeilenweise befüllt wird. byrow=FALSE füllt spaltenweise (Standard).

Definieren wir schnell eine Matrix M der Form 2×3.

M = matrix( c('AI','ML','DL','Tensorflow','Pytorch','Keras'), nrow = 2, ncol = 3, byrow = TRUE)
print(M)

     [,1]         [,2]      [,3]   
[1,] "AI"         "ML"      "DL"   
[2,] "Tensorflow" "Pytorch" "Keras"

Nutzen wir Slicing und holen Elemente aus Zeilen und Spalten.

M[1:2,1:2] #Die erste Dimension wählt beide Zeilen, die zweite die Elemente aus der 1. und 2. Spalte
Eine Matrix: 2 × 2 des Typs chr
AIML
TensorflowPytorch

DataFrame

Data Frames
(Quelle)

Im Gegensatz zur Matrix sind Data Frames eine verallgemeinerte Form davon. Sie enthalten Daten in Tabellenform. Die Spalten eines Data Frames können unterschiedliche Datentypen haben. Die erste Spalte kann character sein, die zweite integer und die dritte logical.

Variablen bzw. Features stehen spaltenweise, auch Header genannt. Die Beobachtungen stehen in den Zeilen; das erste Element ist der Zeilenname, gefolgt von den eigentlichen Daten, auch Datenzeilen genannt.

Einen DataFrame erstellst du mit data.frame().

DataFrames werden häufig zum Einlesen von CSV- und Textdateien genutzt. Sie eignen sich nicht nur fürs Laden von Daten, sondern auch für Machine-Learning-Aufgaben — besonders bei numerischen Daten. DataFrames helfen beim Verständnis der Daten, beim Data Wrangling sowie beim Plotten und Visualisieren.

Erstellen wir ein kleines Beispieldataset und lernen ein paar Data-Frame-spezifische Funktionen.

dataset <- data.frame(
   Person = c("Aditya", "Ayush","Akshay"),
   Age = c(26, 26, 27),
   Weight = c(81,85, 90),
   Height = c(6,5.8,6.2),
   Salary = c(50000, 80000, 100000)
)

print(dataset)

  Person Age Weight Height Salary
1 Aditya  26     81    6.0  5e+04
2  Ayush  26     85    5.8  8e+04
3 Akshay  27     90    6.2  1e+05

class(dataset)

'data.frame'

nrow(dataset) # Anzahl der Zeilen im Data Frame dataset

3

ncol(dataset) # Anzahl der Spalten im Data Frame dataset

5

df1 = rbind(dataset, dataset) # Row-Bind: hängt die Argumente zeilenweise an.

df1
Ein data.frame: 6 × 5
PersonAgeWeightHeightSalary
<fct><dbl><dbl><dbl><dbl>
Aditya26816.05e+04
Ayush26855.88e+04
Akshay27906.21e+05
Aditya26816.05e+04
Ayush26855.88e+04
Akshay27906.21e+05
df2 = cbind(dataset, dataset) # Column-Bind: hängt die Argumente spaltenweise an.

df2
Ein data.frame: 3 × 10
PersonAgeWeightHeightSalaryPersonAgeWeightHeightSalary
<fct><dbl><dbl><dbl><dbl><fct><dbl><dbl><dbl><dbl>
Aditya26816.05e+04Aditya26816.05e+04
Ayush26855.88e+04Ayush26855.88e+04
Akshay27906.21e+05Akshay27906.21e+05

Schauen wir uns die Funktion head an. Sie ist praktisch, wenn du Millionen Zeilen hast und nur die ersten Zeilen sehen willst. Analog gibt tail die letzten Zeilen aus.

head(df1,3) # gibt hier nur drei Zeilen aus
Ein data.frame: 3 × 5
 PersonAgeWeightHeightSalary
 <fct><dbl><dbl><dbl><dbl>
1Aditya26816.05e+04
2Ayush26855.88e+04
3Akshay27906.21e+05
str(dataset) #gibt die einzelnen Klassen bzw. Datentypen je Spalte zurück.

'data.frame':    3 obs. of  5 variables:
 $ Person: Factor w/ 3 levels "Aditya","Akshay",..: 1 3 2
 $ Age   : num  26 26 27
 $ Weight: num  81 85 90
 $ Height: num  6 5.8 6.2
 $ Salary: num  5e+04 8e+04 1e+05

Jetzt die Funktion summary(), mit der du dir schnell einen statistischen Überblick verschaffst. Wie unten gezeigt, teilt sie die Daten in Quartile und gibt dir so ein Gefühl für die Verteilung. Außerdem siehst du, ob fehlende Werte vorhanden sind.

summary(dataset)

    Person       Age            Weight          Height        Salary      
 Aditya:1   Min.   :26.00   Min.   :81.00   Min.   :5.8   Min.   : 50000  
 Akshay:1   1st Qu.:26.00   1st Qu.:83.00   1st Qu.:5.9   1st Qu.: 65000  
 Ayush :1   Median :26.00   Median :85.00   Median :6.0   Median : 80000  
            Mean   :26.33   Mean   :85.33   Mean   :6.0   Mean   : 76667  
            3rd Qu.:26.50   3rd Qu.:87.50   3rd Qu.:6.1   3rd Qu.: 90000  
            Max.   :27.00   Max.   :90.00   Max.   :6.2   Max.   :100000

Fazit

Glückwunsch — du hast das Tutorial abgeschlossen.

Dieses Tutorial ist ein guter Einstieg für alle, die neugierig auf die Programmiersprache R sind. Als Übung kannst du weitere nützliche Funktionen zu jedem Datentyp ausprobieren.

Es gibt noch vieles zu R zu entdecken: Conditionals und Control Flow in R, Utilities in R und — besonders spannend — Machine Learning mit R. Das behandeln wir in kommenden Tutorials. Bleib dran!

Stelle gern deine Fragen zu diesem Tutorial in den Kommentaren unten.

Wenn du mehr über R lernen willst, starte mit DataCamps Kurs Intermediate R und sieh dir das Tutorial Introduction to Data frames in R an.

Themen

R Datenwissenschaft

Ähnlich

Tutorial

Python Datenstrukturen Tutorial

Tutorial

Python-Arrays

Mehr anzeigen →