datenanalyse mit r begeistert: praxisnahe Code-Beispiele

Kennst du das Gefühl, vor einem Datendschungel zu stehen und nicht zu wissen, wo du anfangen sollst? Ein Meer aus Tabellen rauscht über dein Dashboard. Hmm, manchmal ist es einfach zu viel.

In diesem Beitrag begleiten wir dich Schritt für Schritt: Installation, Datenimport, Datenbereinigung, Visualisierung und Modellierung. Wir halten es lebendig mit dplyr (zum Filtern und Formen von Daten), ggplot2 (für bunte Diagramme) und tidyr (um Spalten zu sortieren).

Es ist wie Radio abstimmen – zuerst wählst du deine Frequenz, dann übernimmt AI (künstliche Intelligenz) das Feintuning. Oops, lass mich umformulieren… Echtzeit-Feedback aus der Konsole fühlt sich an, als säße das Programm direkt neben dir.

Als Nächstes sorgt das R Markdown-Dokument dafür, dass alles an Ort und Stelle bleibt. Überschriften wellen sich übers Dashboard und erzählen deine Datenstory. Instant Alerts.

Am Ende dirigierst du deinen Datenstrom wie ein Orchester. Und plötzlich macht’s das ganze Chaos Sinn.

Überblick über den Workflow der datenanalyse mit R

Dieser End-to-End-Prozess in sechs Schritten hilft dir, jederzeit den Durchblick zu behalten. So arbeitest du effizient mit tidyverse-Workflows. Es fühlt sich an, als würden Überschriften über dein Dashboard flirren. Klingt gut? Dann legen wir los.

1. Installation
   • R von CRAN (Comprehensive R Archive Network) herunterladen
   • RStudio Desktop oder Server einrichten
2. Projektstruktur anlegen
   • Ordner “Daten”, “Ergebnisse”, “Code” und “Sonstiges” anlegen
3. Datenimport
   • CSV, Excel oder JSON einlesen
   • Pakete mit install.packages() (um Pakete zu installieren) und library() (zum Laden) verwalten
4. Datenbereinigung
   • Zeilen filtern mit dplyr::filter()
   • Spalten auswählen mit select()
   • Neue Variablen erstellen mit mutate()
   • Daten umbauen mit tidyr::pivot_longer() und unite()
5. Visualisierung
   • Starte dein Chart mit ggplot2: ggplot(data, aes()) + geom_*
   • Spiel mit Farbschemas, Themes und Faceting
6. Modellierung
   • Lineare Regression mit lm() ausprobieren
   • Logistische Regression und Modellchecks durchführen

Dann tauchen wir in praxisnahe Code-Beispiele ein: dplyr (Datenmanipulation), ggplot2 (grafische Darstellung) und tidyr (Datenumformung). Du siehst, wie du R-Pakete direkt verwaltest und im Handumdrehen nutzbare Skripte bastelst. Am Ende verbinden wir alles in einem reproduzierbaren R Markdown-Dokument (dokumentengesteuerte Analyse). Echtzeit-Feedback aus der Konsole – hmm, fast so, als würde das Programm neben dir sitzen. Mit klar kommentierten Skripten verfolgst du jeden Schritt: von der ersten Datenzeile bis zur fertigen Grafik und dem schlüssigen Modell. Echt praktisch, oder?

Setup und Installation von R und RStudio für datenanalyse mit R

So, wir legen los mit R und RStudio auf deinem Rechner. Wenn du die Basisinstallation schon kennst, kannst du direkt runter scrollen. Oops, ich wollte dich nicht nerven.

Zuerst checken wir die R-Version. Gib in der Konsole R.Version() ein (gibt dir Infos zur installierten R-Version). Zum Beispiel:

R.Version()
# $version.string
# "R version 4.2.1 (2023-06-30)"

Cool, die Version stimmt. Schon mal ausprobiert?

Jetzt ein Blick auf die RStudio-Oberfläche. Stell dir vier Kästen vor, die wie Kontrolllampen leuchten und dir den Weg zeigen:

• Script-Editor zum Schreiben und Speichern deines Codes.
• Konsole für direkte Ausführung und Fehlermeldungen.
• Environment-Tab, der alle aktiven Objekte (Datenframes, Vektoren) auflistet.
• Multi-Tab-Fenster mit Plots, Packages, Files und Help.

Wenn du eine Grafik sichern willst, klick im Plot-Tab auf Export und dann Save as Image. Kurz warten – zack, Grafik gespeichert.

Hmm, noch was zu Paketen: Mit Admin-Rechten installierst du sie systemweit. Ohne Admin geht’s nur für dich persönlich. Dann liegen die Pakete in deinem eigenen Bereich.

Datenimport und -bereinigung in R

Einsteigen in R fühlt sich an, als öffnete man Türen zu verschiedenen Datenwelten. Spannend, oder? Hier kommt ein schnelles Menü mit fünf gängigen Formaten und den passenden Lesefunktionen.

• CSV-Dateien:

raw_csv <- read.csv("daten/mitarbeiter.csv", header = TRUE)

• Textdateien (Tabulator-getrennt):

raw_txt <- read.table("daten/log.txt", sep = "\t", header = TRUE)

• Excel-Dateien (readxl-Paket):

library(readxl)
raw_xlsx <- read_excel("daten/bericht.xlsx", sheet = 1)

• JSON-Daten (JavaScript Object Notation):

library(jsonlite)
raw_json <- fromJSON("daten/infos.json")

• R-Binärdatei (.rds):

raw_rds <- readRDS("daten/modell.rds")

Okay, jetzt ab ins Aufräum-Atelier. In vier Schritten – ganz im tidyr- und dplyr-(Datenmanipulations-)Stil.

1. Fehlende Werte aussortieren

   clean1 <- raw_csv %>%
     filter(!is.na(umsatz))
   

   Wir werfen alle Zeilen raus, in denen umsatz fehlt. Sauber.

2. Überflüssige Spalten aussuchen

   clean2 <- clean1 %>%
     select(kunde, produkt, umsatz)
   

   Nur das, was zählt: Kunde, Produkt, Umsatz.

3. Neue Spalte anlegen

   clean3 <- clean2 %>%
     mutate(umsatz_in_euro = umsatz / 1.1)
   

   Einfach umrechnen – voilà, Umsatz in Euro.

4. Ins lange Format drehen

   library(tidyr)
   clean4 <- clean3 %>%
     pivot_longer(cols = starts_with("umsatz"), 
               names_to = "kennzahl", 
               values_to = "wert")
   

   Langformat ist super für Visualisierungen. Echt praktisch.

Am Ende liegt dein Datensatz glänzend vor dir. Fast wie frisch geputzt. Jetzt bist du bereit für explorative Datenanalyse und schicke Charts. Echt.

Explorative datenanalyse mit R

Erste Einblicke mit base::summary() geben rasch Minimum, Maximum, Mittelwert und Median – ein schneller Check für grobe Ausreißer. Für detailliertere Kennzahlen wie Standardabweichung und Schiefe (Maß für Asymmetrie) ruft psych::describe() auf.

library(wooldridge)
data("wage1")
# Schnelle Übersicht
summary(wage1)
# Detaillierte Statistik
psych::describe(wage1[, c("wage", "educ", "exper")])

Im Datensatz wage1 siehst du: durchschnittlicher Stundenlohn, Jahre der Ausbildung und Berufserfahrung. Mit plot() oder hist() tauchst du direkt in Verteilungen ein.

• Basis-Histogramm:

hist(wage1$wage, main="Lohnverteilung", xlab="Stundenlohn")

• Boxplot nach Geschlecht:

boxplot(wage ~ female, data=wage1,
        names=c("Männer","Frauen"), 
        ylab="Stundenlohn")

Etwas schicker mit ggplot2: geom_histogram() für Verteilung, geom_boxplot() für Gruppenvergleich und geom_point() für Zusammenhänge. Mehr Tipps zu explorative datenanalyse findest du in unserer ausführlichen Anleitung.

Datenvisualisierung mit R und ggplot2

Mit ggplot(data, aes(x, y)) + geom_* legst du los. Es ist, als würdest du am Senderegler drehen. Hmm, wir sind im Fluss. Das Diagramm erwacht sofort.

Ein Histogramm zeigt dir, wie sich die Werte verteilen. Versuch’s so:

ggplot(wage1, aes(x = wage)) +
  geom_histogram(binwidth = 1, fill = "skyblue", color = "white") +
  theme_minimal()

Die Balken flüstern dir, wo die meisten Daten liegen. Echt praktisch, um den Überblick zu behalten.

Ein Boxplot hilft, Gruppen direkt zu vergleichen. So geht’s:

ggplot(wage1, aes(x = factor(female), y = wage, fill = factor(female))) +
  geom_boxplot() +
  scale_fill_brewer(palette = "Set2") +
  theme_bw()

Fällt dir auf, wie flott du Unterschiede im Median erkennst? Manchmal reicht ein kurzer Blick.

Streudiagramme mit geom_point() machen Zusammenhänge sichtbar. Versuch das hier:

ggplot(wage1, aes(x = educ, y = wage)) +
  geom_point(alpha = 0.6, color = "darkgreen") +
  theme_minimal()

Die Punkte tanzen übers Panel und zeigen dir, ob Bildung und Lohn zusammenhängen.

Für Häufigkeiten in Kategorien nutzt du geom_bar(). Einfach so:

ggplot(wage1, aes(x = factor(female), fill = factor(female))) +
  geom_bar() +
  scale_fill_brewer(palette = "Pastel1") +
  theme_bw()

Die Farben leiten den Blick. Du erkennst schnell Unterschiede.

Faceting trennt deine Plots nach Gruppen. Schau hier:

ggplot(wage1, aes(x = experi, y = wage)) +
  geom_point() +
  facet_wrap(~ female) +
  theme_minimal()

Dann flirrt jedes Panel eigenständig. Echt clever, um Trends nebeneinander zu sehen!

Geom	Anwendungsfall
geom_histogram()	Verteilung numerischer Werte
geom_boxplot()	Vergleich mehrerer Gruppen
geom_point()	Streudiagramm für Zusammenhänge
geom_bar()	Häufigkeitsdarstellung kategorisch

Statistische Modellierung und Regression in datenanalyse mit R

Lineare Regression

So legen wir los. Mit diesem R-Befehl passt du ein einfaches lineares Modell an.

model_lin <- lm(wage ~ educ, data = wage1)

lm(y ~ x, data) schätzt, wie wage (Stundenlohn) von educ (Bildungsjahre) abhängt. Der Koeffizient verrät, um wie viel dein Lohn steigt, wenn du ein Jahr länger zur Schule gehst. p-Wert (Wahrscheinlichkeit, dass das Ergebnis Zufall ist, <0,05 bedeutet echt) und R² (Anteil der erklärten Varianz) flattern übers Dashboard. Wer hätte gedacht, dass Bildung fast 30 % der Lohnschwankungen erklärt?

Multiple Regression

Das Upgrade: Mehr Einflussfaktoren auf einen Schlag.

model_mul <- lm(wage ~ educ + exper + tenure, data = wage1)

Jetzt kontrollierst du Bildung, Erfahrung (exper) und Betriebszugehörigkeit (tenure) gleichzeitig. Ein hoher Adjusted R² (angepasster Anteil der Varianz) zeigt dir, wie viel echte Performance du erzielst, ohne überflüssige Variablen. Um Multikollinearität (wenn Prädiktoren sehr ähnlich arbeiten) zu prüfen, nutzt du den Variance Inflation Factor (VIF):

car::vif(model_mul)

Ein VIF über 5 klingt nach zu viel Überschneidung. Dann aufräumen oder Prädiktoren verschieben.

Logistische Regression

Und wenn das Ergebnis nur Ja oder Nein ist? Dann kommt logistische Regression zum Zug.

model_log <- glm(female ~ wage + educ, family = binomial, data = wage1)

glm(y ~ x, family=binomial) schätzt die Wahrscheinlichkeit, dass female = 1 ist. exp(coef(model_log)) liefert Odds Ratios (Verhältnis der Chancen). Ein Wert über 1 heißt höhere Chancen pro Einheit x. Mit summary(model_log) checkst du Signifikanz, AIC (Modellgüte) und Residuen.

Modellvalidierung

Modellvalidierung fühlt sich fast schon wie Quality Check an.

plot(model_mul, which = 1:4)

So findest du Ausreißer und Heteroskedastizität (uneinheitliche Fehlerverteilung). Für Cross-Validation (Daten mehrfach aufteilen und prüfen) nimmst du caret::train() oder tidymodels:

caret::train(wage ~ ., data = training_set, method = "lm", trControl = trainControl(method = "cv", number = 10))

Die 10-fache CV testet deine Modelle immer wieder neu und bremst Overfitting aus. Hm, fühlt sich gut an, wenn dein Modell auch außerhalb deiner Daten verlässlich bleibt?

Reproduzierbare Berichte und Skriptdokumentation mit R Markdown

So packen wir deine Ergebnisse in ein R Markdown-Dokument. Im YAML-Header legst du zuerst Titel, Autor und Ausgabeformat fest:

---
title: "Analysebericht"
author: "Dein Name"
output:
  html_document:
    toc: true
  pdf_document: default
---

So kannst du später interaktives HTML oder ein druckfertiges PDF erstellen. Ein Klick – und fertig.

Dann kommt der Code. Ein R-Chunk (code-Abschnitt) ist wie ein kleines Puzzleteil in deinem Bericht. Hier versteckt echo=FALSE den Setup-Code, message=FALSE blendet Warnungen aus:

library(dplyr) # dplyr (Paket für Datenmanipulation)

Deine Analyseblöcke folgen mit echo=TRUE. So sehen Leser*innen den Code und verstehen jeden Schritt. Wirklich übersichtlich.

Ein paar Tipps:

• Mit cache=TRUE sparst du Zeit bei aufwendigen Berechnungen.
• warning=FALSE blendet unerwünschte Warnungen aus.
• eval=FALSE stoppt die Ausführung im Bericht (falls du nur zeigen willst).

Ein Klick auf den Knit-Button in RStudio zaubert dir das fertige Dokument im Vorschaufenster. Real-time. Interaktive Parameter lassen dich Berichte dynamisch anpassen. Du änderst Werte, ohne den Code neu zu schreiben. Clever, oder?

Mit diesen Skripten stellst du sicher, dass deine Forschung jederzeit reproduzierbar bleibt. Hmm, so verlierst du nie den roten Faden.

Kommentare sind deine Wegweiser im Text. Sie erklären jeden Schritt. Um den Überblick zu behalten, setzt du Versionskontrolle mit Git ein. So siehst du alle Änderungen im Detail, bevor du sie nach GitHub pushst.

Ordne dein Projekt sauber:

• Ordner „Code“ für Rmd-Dateien
• Ordner „Ergebnisse“ für Grafiken und Tabellen
• Ordner „Sonstiges“ für Notizen

Dann entsteht ein nachvollziehbarer und professioneller Forschungsbericht.

Final Words

Vom Projektaufbau in RStudio bis zur Erstellung interaktiver Berichte haben wir den kompletten End-to-End-Workflow für datenanalyse mit R durchlaufen. Ihr habt gesehen, wie tidyverse-Pakete Datenimport, Aufbereitung und Visualisierung vereinfachen.

Mit praktikablen dplyr-, tidyr- und ggplot2-Beispielen sowie Modellierungsansätzen lassen sich Trends blitzschnell erkennen. Dank R Markdown bleibt alles sauber dokumentiert und reproduzierbar.

So, jetzt liegt es an euch: Nutzt dieses Know-how für effiziente Analyse und trefft Entscheidungen in Echtzeit. Auf spannende Ergebnisse mit datenanalyse mit r!

FAQ