Quantitative Datenanalyse mit R

Neuen Absatz erschaffen

• Reiter oben im Menü “Code” -> “Insert Section”

• oder: str+Umsch+R

Daten importieren

• Von Excel: Befehl im script: library(readxl)

  • Enviroment: import Dataset -> from Excel -> code kopieren

  • Code im Skript eingeben zwecks Nachvollziehbarkeit (auf Schrägstriche achten!)

    • (z.B: Dateiname <- read_excel(“anlageort am PC/Dateiname)

      View(dateiname)

• Von SPSS: Befehl im Skript: library(haven)

  • Enviroment: import Dataset -> from SPSS-> code kopieren

  • Code im Skript eingeben zwecks Nachvollziehbarkeit (auf Schrägstriche achten!)

    • (z.B: Dateiname <- read_sav(“ablageort am PC/Dateiname)

      View(dateiname)

R-Daten hochladen

• load(ablageort+Dateiname)

• Auf Schrägstriche achten -> immer /

Hochgeladene Daten auf Objekttypen prüfen

• Objektklassifizierung: sapply(Datenname, class) oder str(Datenname)

  • gibt dann für jede Spalte den Objekttypen heraus

  • Objekttypen:

    • numeric → Für Berechnungen mit Zahlen

      • Integer: Ganze Zahlen

      • double: Kommazahlen

    • factor → Für (Text)Kategorien mit begrenzten Ausprägungen

      • Levels gibt Menge aller möglichen Kategorien (Ausprägungen) an, die diese Variable annehmen kann.

      • zeigt aber nicht, wie oft diese Kategorie vorkommt – das kommt später, z. B. mit table() oder summary().

      • Funktion: levels(dateiname$variable)

    • character → Für Text

    • date → Für Zeitangaben

    • logical → Für Wahr/Falsch-Aussagen

• Ausprägungsarten für Faktoren ausgeben lassen:

  • min(datennamen$Variable, na.rm = TRUE)

  • max(….”)

  • Häufigkeit: summary(….”)

R ist eine Open-Source-Programmiersprache für Statistik, Datenanalyse und Visualisierung, die kostenlos für verschiedene Betriebssysteme verfügbar ist.

• Vorteile von R

  • Flexibel für quantitative und qualitative Forschung

  • Zukunftssicher durch kontinuierliche Weiterentwicklung

  • Schnittstellen zu Web-Daten und Mehr-Datensatz-Logik möglich

  • Breites Spektrum an statistischen Verfahren und Visualisierungsmöglichkeiten

• Installation & Updates

  • Installationsdateien über CRAN

  • Regelmäßige Updates für R, RStudio und Pakete verfügbar

  • Versionen erscheinen häufiger als bei klassischen Statistikprogrammen (SPSS, Stata)

RStudio – Grafische Oberfläche für R

RStudio erleichtert die Arbeit mit R durch eine benutzerfreundliche Oberfläche.

• Allgemeines

  • Anbieter: Posit (posit.co) als Open-Source-Edition verfügbar für alle Betriebssysteme

  • Ermöglicht Skript-basiertes Arbeiten → Befehle können gespeichert und reproduziert werden

• Fensteraufteilung

  1. Links oben: Skript-Fenster → Befehle eingeben, an Console senden

  2. Links unten: Console → Ergebnisse anzeigen, Befehle direkt ausführen

  3. Rechts oben: Environment & History → geladene Daten und bisherige Befehle

  4. Rechts unten: Files, Plots, Packages, Help → Dateien, Grafiken, Pakete, Hilfe

• Praktische Hinweise

  • Skripte speichern statt Workspace → bessere Nachvollziehbarkeit

  • Anpassung Layout etc. über Global Options: Theme, Schriftgröße, Pane Layout

  • Cheat Sheets & Tastaturkürzel über Help verfügbar

  • Beliebte Themes: „Dracula“, „Twilight“

= Ein- und Ausgabefenster in RStudio (links unten)

1. Einsatz:

   • Einfache Berechnungen

   • Logische Abfragen

   • Ergebnisse werden sofort angezeigt

2. Limitierung:

   • Eingaben werden nicht automatisch gespeichert → für Nachvollziehbarkeit Skript verwenden

3. Aufräumen der Console:

   • Besensymbol (rechts oben) anklicken → Inhalt löschen

In RStudio werden Analysen und Berechnungen idealerweise nicht direkt in der Console durchgeführt, sondern in Skriptdateien. Skripte ermöglichen eine strukturierte, nachvollziehbare und wiederholbare Bearbeitung von Daten.

• Skript erstellen:

  • Menü: File → New File → R Script

  • Tastenkürzel: STRG + Shift + N (Windows)

• Befehle ausführen:

  • Run-Button im Skript-Fenster

  • Tastenkürzel: STRG + Enter

  • Der Cursor bestimmt, welcher Befehl oder welche markierten Zeilen ausgeführt werden

• Speichern von Skripten:

  • Menü: File → Save As… oder STRG + S

  • Dateiendung: .R

• Kommentare einfügen:

  • Symbol # für Kommentare in einer eigenen Zeile oder hinter Befehlen

  • Text nach # wird von R ignoriert

• Vorteile von Skripten:

  • Alle Berechnungen sind reproduzierbar

  • Analyseschritte können nachvollzogen und geteilt werden

  • Erleichtert Dokumentation und Fehlersuche

• Skripte strukturieren: 10 goldene Regeln

  1. Konsequenter Coding-Style: Wähle einen Style (z.B. TidyVerse-Style) und halte ihn im gesamten Skript durch.

  2. Klare Dateinamen: Keine Leerzeichen oder Sonderzeichen, Unterstrich oder Bindestrich zur Trennung nutzen.

     • Beispiel: 10_skript_datenaufbereitung.R

  3. Skriptstruktur & Abschnitte:

     • Abschnitte einfügen: Code → Insert Section

       • Tastenkürzel: STRG + Shift + R

       • Hilft, längere Skripte zu gliedern und die Übersicht zu behalten

  4. Pakete am Anfang laden: Installierte Pakete nur einmal installieren, in jedem Skript laden.

     • Beispiel: library(tidyverse)

  5. Variablen- und Funktionsnamen:

     • Variablen: Substantive, klein, Unterstrich für Trennung (lern_daten)

     • Funktionen: Verben, klein, Unterstrich für Trennung (berechne_korrelation())

  6. Kommentare nutzen:

     • Mit # Arbeitsschritte erklären, entweder eigene Zeile oder hinter Befehlen.

  7. Lesbarkeit durch Leerzeichen:

     • Vor/nach Operatoren und Kommas Leerzeichen setzen, lange Zeilen (max. 80 Zeichen) vermeiden.

  8. Datenzugriff klar definieren:

     • Variablen in data.frame über $-Operator ansprechen (peanuts_r$punkte).

  9. TidyVerse-Pipes sauber verwenden:

     • Jede Pipe %>% in eigene Zeile mit erklärendem Kommentar.

     • Beispiel:

       # Pakete laden

       library(tidyverse)

       # Beispiel-Datensatz erstellen

       peanuts_r <- data.frame(

       name = c("Charlie", "Snoopy", "Lucy", "Linus", "Peppermint"),

       region = c("Nord", "Süd", "Nord", "Süd", "Nord"),

       punkte = c(25, 40, 28, 32, 23),

       tgeld = c(5, 0, 7, 2, 5)

       )

       # Datenanalyse mit Tidyverse-Pipes

       peanuts_r %>%

       filter(punkte > 25) %>%

       # nur Personen mit mehr als 25 Punkten

       group_by(region) %>%

       # nach Region gruppieren

       summarise(

       durchschnitt_punkte = mean(punkte),

       # Mittelwert der Punkte berechnen

       summe_tgeld = sum(tgeld)

       # Summe des Taschengelds berechnen

       ) %>%

       arrange(desc(durchschnitt_punkte)) %>%

       # Ergebnis nach absteigendem Mittelwert sortieren

       print()

       # Ausgabe in Console

       
       

  10. Skripte speichern & reproduzierbar arbeiten:

      • Berechnungen über Skripte statt Console ausführen

      • Daten, Pakete und Arbeitsschritte am Anfang dokumentieren, Skript regelmäßig speichern.

Hier ist dein Text stichpunktartig und übersichtlich zusammengefasst, ohne inhaltlich etwas zu verlieren:

R-Pakete (Packages)

• CRAN:

  • Zentraler R-Paket-Server: https://cran.r-project.org

  • Über 19.000 Packages verfügbar (Stand 2023)

  • Alphabetische oder nach Veröffentlichungsdatum gelistete Packages

  • CRAN Task Views: kommentierte Auswahl empfohlener Pakete nach Themen (z.B. Bayesian, Psychometrics, WebTechnologies)

• Weitere Quellen:

  • Bioconductor

  • GitHub → oft Pakete in Entwicklung

Installation & Laden von Paketen

1. Installation:

   • Funktion: install.packages("Paketname")

   • Paketname in Anführungszeichen

   • Abhängigkeiten (dependencies) werden automatisch installiert

   • Installation nur einmal nötig, außer es gibt Updates

2. Laden (aktivieren) des Pakets:

   • Funktion: library(Paketname)

   • Kein Anführungszeichen nötig

   • Muss in jeder R-Sitzung ausgeführt werden

3. Wichtig:

   • Paket-Installation sollte im Skript auskommentiert werden:

     # install.packages("tidyverse") library(tidyverse)

4. Reiter Packages:

   • Paketname anklicken → Dokumentation einsehen

   • Bei Paket-Sammlungen wie tidyverse sind die Einzelpakete (z.B. dplyr) sichtbar

   • Pakete können dort auch geladen, deaktiviert oder deinstalliert werden

   • Updates über Symbol im Packages-Reiter oder update.packages()

Wichtige Funktionen

R ist eine objektbasierte Sprache – alles, was du in R verarbeitest, wird als Objekt gespeichert.

Heißt: Ein Objekt kann einen Wert, mehrere Werte, Variablen, Datensätze oder Analyseergebnisse enthalten.

Objekte speichern Werte oder Daten, auf die Funktionen und Berechnungen angewendet werden können.

Zuweisung:

• Mit <- wird ein Wert einem Objekt zugewiesen.

• Beispiel: x <- 32 → erstellt Objekt x mit Wert 32.

• Tastenkombination: Alt + - fügt automatisch Leerzeichen ein.

Regeln für Objektnamen:

• Muss mit Buchstaben beginnen.

• Danach: Buchstaben, Zahlen, Unterstrich _ und Punkt .

• Keine Umlaute oder Sonderzeichen (z.B. ß)

• Kleinbuchstaben empfohlen (R ist case sensitive)

Objekte anzeigen:

• ls() → listet alle Objekte in der Session

• Environment-Fenster zeigt alle erstellten Objekte

Objekte löschen:

• remove(x) oder rm(x) → löscht Objekt x

In R ist es entscheidend, den Objekttyp einer Variable zu kennen, da Funktionen je nach Typ unterschiedliche Ergebnisse liefern oder sogar Fehlermeldungen erzeugen können. Ein typisches Beispiel: Würde man versuchen, das arithmetische Mittel (mean()) einer Textvariable wie name zu berechnen, so führt dies zu einer Fehlermeldung. Deshalb ist es wichtig, die zentralen Objekttypen in R zu verstehen und zu prüfen.

Zentrale Objekttypen in R

1. Zahlen (numeric)

   • Unterscheidung:

     • integer (ganze Zahlen)

     • double (Kommazahlen).

   • Standardmäßig werden Zahlen als double gespeichert, z. B. 2 entspricht 2.0.

   • Ganze Zahlen können explizit mit dem Zusatz L definiert werden, z. B. 2L.

   • Beispiel:

     class(peanuts_r$tgeld) # integer

     class(peanuts_r$punkte) # numeric (double)

2. Text (character)

   • Textvariablen enthalten Zeichenketten.

   • Zahlen, die als Text gespeichert werden sollen, müssen in Anführungszeichen stehen, z. B. "123".

   • Funktionen für die Arbeit mit Text gibt es z. B. im Paket stringr.

   • Beispiel:

     class(peanuts_r$name) # character

3. Faktoren (factor)

   • kategoriale Variablen, z. B. nominale Variablen (Geschlecht) oder ordinale Variablen (Bildungsniveau), die begrenzt sind

   • Vorteile: ermöglicht Häufigkeitsauszählungen und ist oft effizienter bei statistischen Analysen.

   • Beispiel:

     class(peanuts_r$typ) # factor

     class(peanuts_r$sport) # factor

     levels(peanuts_r$typ) # "Mensch", "Tier"

     levels(peanuts_r$sport) # "Baseball", "Eiskunstlauf", "Golf"

     summary(peanuts_r$typ) # Häufigkeitstabelle

4. Datum (Date)

   • Spezieller Typ für Datumsangaben.

   • Erlaubt Berechnungen von Zeitabständen zwischen Daten.

   • Beispiel:

     class(peanuts_r$auftritt) # Date

     Sys.Date() # aktuelles Datum

     date() # aktuelles Datum und Uhrzeit

     peanuts_r$dauer <- Sys.Date() - peanuts_r$auftritt

Objekttyp prüfen

• Mit der Funktion class() kann der Typ einer Variable abgefragt werden:

  class(peanuts_r$name) # character

  class(peanuts_r$auftritt) # Date

  class(peanuts_r$typ) # factor

Objekttyp konvertieren

• In R müssen Variablen manchmal in einen anderen Typ umgewandelt werden, z. B. bei Import aus Excel oder SPSS.

• Beispiel für Excel-Datensatz:

  peanuts_excel$typ2 <- as.factor(peanuts_excel$typ)

  peanuts_excel$sport2 <- as.factor(peanuts_excel$sport)

• Beispiel für SPSS-Datensatz (numerische Variablen zu Faktoren):

  peanuts_spss$typ2 <- factor(peanuts_spss$typ,

  levels = c(1, 2), labels = c("Mensch", "Tier"))

  peanuts_spss$sport2 <- factor(peanuts_spss$sport,

  levels = c(1, 2, 3),

  labels = c("Baseball", "Golf", "Eiskunstlauf"))

  class(peanuts_spss$typ2)

  class(peanuts_spss$sport2)

Zusammenfassung

• Zahlen: für mathematische Operationen, unterscheiden integer/double.

• Text (character): keine direkten Berechnungen, geeignet für Namen oder Textfelder.

• Faktoren (factor): für kategoriale Variablen, sinnvoll bei Häufigkeiten und statistischen Analysen.

• Datum (Date): für Berechnung von Zeitspannen.

Vektoren sind eine zentrale Datenstruktur in R – sie stellen quasi Werte einer einzelnen Spalte (z.B. Alter, Namen) einer Tabelle dar.

Anlegen von Vektoren:

• Zahlen: alter <- c(18, 27, 38, 47, 63)

• Text: namen <- c("Thomas", "Julia", "Lisa", "Christian", "Gerrit")

• c() = concatenate, verbindet Werte zu einem Vektor

Ausgabe von Vektoren:

• Gesamter Vektor: alter → alle Werte werden angezeigt

• Einzelnes Element: alter[1] → erstes Element

• Bereich von Elementen: alter[2:4] → 2. bis 4. Element

• Flexible Reihenfolge: alter[c(1,4,5,1,1)]

• Elemente ausschließen: alter[-1] → alle außer erstes Element

• Werte eines Vektors einer Tabelle ausgeben:

  View(daten1$alter)

  View(daten2$name)

Folgen und Sequenzen:

• Einfacher Zahlenbereich: 1:5 → 1 bis 5

• Wiederholen: rep(1:5, times=3) → ganze Reihe 3x wiederholen

• Wiederholen mit jedem Element: rep(1:3, each=3, times=2)

• Sequenzen: seq(from=3, to=9, by=0.5) → Schrittweite 0,5

• Absteigende Sequenz: seq(from=5, to=-5, by=-1)

• Anzahl Elemente anpassen: seq(1.5, 8.2, length.out=9) → 9 Elemente zwischen 1.5 und 8.2

• Wenn ich mich auf einen bestehenden Datensatz beziehe, dann immer

  • z.B. seq(from=min(peanuts_r$Punkte), to=max(peanuts_r$Punkte), by=1)

Nützliche Funktionen:

• head(sequenz) → erste 6 Elemente

• tail(sequenz) → letzte 6 Elemente

• head(sequenz, 10) → erste 10 Elemente

• tail(sequenz, 10) → letzte 10 Elemente

• length(sequenz) → Anzahl der Elemente im Vektor

Datensatz kennenlernen:

head(daten2) # Die oberen sechs Datenreihen werden ausgegeben

tail(daten2) # Die unteren sechs Datenreihen werden ausgegeben

head(daten2, 3) # Die oberen drei Datenreihen werden ausgegeben

tail(daten2, 3) # Die unteren drei Datenreihen werden ausgeben

Erste Analysen:

table(daten2$alter) #einfache Häufigkeitstabellen der Variablen

table(daten2$punkte)

min(daten2$alter)

max(daten2$alter)

range(daten2$alter) #Minimum und Maximum in einem Schritt

mean(daten2$alter) #arithmetische Mittel

mean(daten2$name) # Fehlermeldung, da kein numerisches Objekt

summary(daten2$alter) #mehrere deskr. statistische Angaben

Erste Grafiken: Streudiagramm

plot(daten2$alter, daten2$einkommen)

plot(daten2$alter, daten2$einkommen,

xlim=c(0,70), #Wertebereich x-Achse

ylim=c(0, 2500), #Wertebereich y-Achse

main="Streudiagramm", #Titel des Streudiagramms

ylab="Einkommen" #y-Achse

xlab="Alter in Jahren", #x-Achse

col ="red", #Farbe der Symbole

pch = 19, #Plotsymbol

cex = 2) #Größe des Plotsymbols

Ein Vektor entspricht einer Spalte einer Tabelle, mehrere Spalten gleicher Länge können zu einer Tabelle zusammengefasst werden. Eine Tabelle wird in R als data.frame bezeichnet.

• Im Folgenden werden die beiden Vektoren alter und namen zu einer Tabelle zusammengefasst. Die Tabelle erhält den Objektnamen daten1. Nach dem Zuweisungspfeil wird der Objekttyp data.frame genannt, in der Klammer sind die beiden Vektoren aufgeführt.

  • daten1 <- data.frame(namen, alter) # Tabelle erstellen

• Mit der Funktion remove werden anschließend die existierenden Vektoren alter und namen gelöscht. Die Funktion View(daten1) öffnet eine Ansicht der Tabelle

  • remove(namen, alter) # alter und namen löschen

    View(daten1) # Tabellenansicht öffnen

    
    

Eine Tabelle kann auch direkt erstellt werden. Dazu werden die Namen der Vektoren und die Werte der Vektoren in Klammern geschrieben. Mit View(daten2) wird die Tabelle angezeigt

• daten2 <- data.frame(name = c("Oliver", "Julia", "Thomas", "Stefanie", "Daniel"),

  • alter = c(32, 38, 49, 35, 52),

  • punkte = c(12, 18, 6, 14, 9),

  • einkommen = c(1900, 2000, 1800, 2200, 1600))

  View (daten2)

Fehlende Werte entstehen, wenn für eine Beobachtung kein gültiger Wert vorliegt (z. B. Befragungen, fehlende Messungen).

• In R werden fehlende Werte mit NA („not available“) gekennzeichnet.

• beispiel_na <- c(1900, 2000, 1800, 2200, NA)

Problem: Funktionen wie mean(), min(), max() liefern Antwort: NA, wenn fehlende Werte vorhanden sind

Lösung: Argument na.rm=TRUE (oder na.rm=T) verwenden, um fehlende Werte zu ignorieren:

• mean(beispiel_na, na.rm=TRUE) # Mittelwert ohne NA

• min(beispiel_na, na.rm=T) # Minimum ohne NA

• max(beispiel_na, na.rm=T) # Maximum ohne NA

Merksatz: Bei allen Funktionen, die auf numerischen Werten arbeiten und NA enthalten, immer na.rm=TRUE hinzufügen, um die Berechnung zu ermöglichen.

Für jeden Befehl bzw. jede Funktion gibt es in R eine Dokumentation. Sie können die Dokumentation zum einen mit einem Fragezeichen (?) und dem Funktionsnamen und zum anderen über den Befehl help gefolgt von dem Funktionsnamen in Klammern abrufen.

• Hilfe in R:

  ?mean

  help(mean)

• Bei der Arbeit mit R werden Sie mit vielen Funktionen und noch mehr Argumenten dieser Funktionen konfrontiert. Es gehört zur täglichen Arbeit mit R, die zentralen Argumente von Funktionen immer wieder nachzuschlagen. Nutzen Sie die Dokumentation als Nachschlagewerk. Am Ende jeder Dokumentation werden auch Beispiele der Funktionen aufgeführt. Die Dokumentation öffnet sich im unteren Fenster auf der rechten Seite (Reiter „Help“). Mit einem Mausklick auf das „Haus“ im Hilfebereich erhalten Sie zusätzlich eine Übersicht nützlicher Seiten. Wenn sich der Cursor innerhalb des Befehls bzw. der Funktion befindet, dann funktioniert alternativ auch die Taste F1.

R wird über Befehle gesteuert, die Funktionen auf Objekte anwenden und optional Argumente spezifizieren.

• Aufbau: funktion(objekt, argument)

  • Funktion → legt fest, was passieren soll

  • Objekt → auf welches die Funktion angewendet wird

  • Argumente → passen die Funktion an (z. B. digits bei round())

• Beispiel: Runden der Kreiszahl Pi

  pi

  # Wert von Pi ausgeben

  round(pi)

  # auf 0 Nachkommastellen runden (Voreinstellung)

  round(pi, 2)

  # auf 2 Nachkommastellen runden

  round(pi, digits=3)

  # alternative Schreibweise

• Hilfe von Funktionen:

  help(round) # vollständige Hilfe ?round # Kurzform

• Voreinstellungen:

  • Viele Funktionen haben Standardwerte für Argumente (z. B. digits = 0 bei round)

  • Durch explizite Angabe eines Arguments wird die Voreinstellung überschrieben

• Verschachtelte Befehle:

  • Befehle können ineinander geschachtelt werden → Ausführung von innen nach außen

  round(sqrt(77))

  # zuerst sqrt(77), dann runden

  round(sqrt(77), digits=2)

• Alternative Verkettung:

  • Mit Pipe-Operator (%>%) können Befehle lesefreundlicher nacheinander ausgeführt werden

  77 %>% # Startwert

  sqrt() %>% # Quadratwurzel berechnen

  round(2) # auf 2 Nachkommastellen runden

Heißt: Ablauf der Pipe:

1. Wert 77 wird an sqrt() übergeben → sqrt(77)

2. Ergebnis wird an round(…, 2) übergeben → gerundet auf 2 Nachkommastellen

= Symbol oder Zeichen, das eine bestimmte Operation auf Werte oder Variablen ausführt, z. B. + für Addition oder <- für Zuweisung.

Mit R können Sie auch logische Abfragen durchführen. Bei einer logischen Abfrage prüft R, ob eine Eingabe korrekt ist oder nicht. Bei einer korrekten Abfrage antwortet R mit TRUE und bei einer falschen Abfrage mit FALSE. In Tabelle 3 sind einige Beispiele für logische Abfragen dokumentiert. Mit dem logischen „und“ (&) und dem logischen „oder“ (|) können logische Abfragen verknüpft werden. Bei einer „und“-Verknüpfung müssen alle Bedingungen erfüllt sein, um ein TRUE zu erhalten, bei einer „oder“-Verknüpfung ist eine Bedingung ausreichend

• 
  

  ==	gleich
  !=	ungleich
  >	größer
  <	kleiner
  >=	größer gleich
  <=	kleiner gleich
  &	logisches und
  |	logisches oder

In der Praxis werden Datensätze in R selten manuell eingegeben. Meist liegen die Daten in externen Dateien vor, die in R geladen bzw. importiert werden.

• R-eigene Datenformate: .RData oder .rds – können direkt mit R geladen werden.

• Andere Formate: Excel (.xlsx) oder SPSS (.sav) – müssen über Importfunktionen oder Pakete (readxl, haven) eingelesen werden.

R-Daten hochladen

• Über das Menü

  • File → Open File… → Datei auswählen.

• Über das Environment-Fenster

  • Datei-Symbol anklicken → Auswahlfenster öffnet sich.

• Tastenkürzel: Strg + O öffnet das Auswahlfenster direkt.

• Direkt über das Skript: EMPFOHLEN

  • Befehl: load(ablageort+Dateiname)

    • Beispiel: load( "H:/Verzeichnis1/Verzeichnis2/peanuts_r.RData")

      
      

  • Vorteil: Analysen werden reproduzierbar.

  • Wichtig: Arbeitsverzeichnis muss korrekt gesetzt sein.

    • Auf Schrägstriche achten -> immer /

• und dann immer: View(Datensatz) (zB. View(peanuts_r))

Daten importieren

• Von Excel:

  • Befehl im script:

    • library(readxl)

    • read_excel(….siehe unten)

    • View(Dateinamen)

  • Enviroment: import Dataset -> from Excel -> code kopieren

    • Code im Skript eingeben zwecks Nachvollziehbarkeit (auf Schrägstriche achten!)

      • (z.B: Dateiname <- read_excel(“anlageort am PC/Dateiname)

      • View(dateiname)

• Von SPSS:

  • Befehl im Skript: library(haven)

    • read_sav(….siehe unten)

    • View(Dateiname)

    • Achtung: Datenansicht: Ziffern statt Beschriftungen in Spalten

  • Enviroment: import Dataset -> from SPSS-> code kopieren

    • Code im Skript eingeben zwecks Nachvollziehbarkeit (auf Schrägstriche achten!)

      • (z.B: Dateiname <- read_sav(“ablageort am PC/Dateiname)

      • View(dateiname)

• CVS-Dateien: Comma-Separated Values, erste Zeile enthält Variablen, folgende Zeilen die Daten.

  • Befehl im Skript: library(readr)

    • read_csv(Ablageort/Dateiname) → für internationale CSVs (Felder durch Komma getrennt)

    • read_csv2(Ablageort/Dateiname) → für deutsch/europäische CSVs (Felder durch Semikolon getrennt)

    • read_delim("Pfad/zur/Datei.csv", delim = ",")

      # oder delim=";"

      • = flexibel, du bestimmst selbst das Trennzeichen

  • Ist die Datei unbekannt und wir wissen nicht ob , oder ; verwendet wurde, dann:

    • read_lines("Pfad/zur/Datei.csv", n_max = 5) zeigt die ersten 5 Zeilen der Datei genau so, wie sie im Text vorliegen, inklusive aller Trennzeichen (;, ,, \t usw.). So siehst du direkt, welches Zeichen als Spaltentrenner verwendet wird.

In R ist neben dem Objekttyp auch die Datenstruktur entscheidend, da sie beschreibt, wie die Daten organisiert und zusammengefasst sind. Die Datenstruktur beeinflusst, welche Operationen und Funktionen auf den Daten angewendet werden können und wie die Daten ausgegeben werden.

Wichtige Datenstrukturen

1. Vektoren

   • Ein Vektor ist eine eindimensionale Sammlung von Elementen.

   • Alle Elemente eines Vektors müssen denselben Objekttyp haben, z. B. nur Zahlen (numeric), nur Text (character) oder nur Faktoren.

   • Mischung verschiedener Typen ist nicht möglich – R wandelt in diesem Fall automatisch alles in einen gemeinsamen Typ (meist Text).

   • Beispiele für Vektoren: Alter, Namen, Punktzahlen.

2. Tabellen (data frames)

   • Ein data frame ist eine Sammlung von Vektoren gleicher Länge, die zu Spalten zusammengefügt werden.

   • Jede Spalte kann einen anderen Objekttyp haben: Zahlen, Text, Faktoren, Datum usw.

   • Ein data frame eignet sich für die Speicherung von Datensätzen mit mehreren Variablen, wie dem peanuts_r-Datensatz.

   • Beispiel:

     class(peanuts_r) # Ausgabe: "data.frame"

3. Tibbles

   • Tibbles sind eine Weiterentwicklung der klassischen data frames und stammen aus dem tidyverse.

   • Vorteile:

     • Optimierte und übersichtlichere Ausgabe in der Konsole

     • Automatisches Beibehalten von Spaltennamen und Typen

     • Vereinfachter Umgang bei fehlenden Werten

   • Viele tidyverse-Funktionen erwarten tibbles statt klassischer data frames.

   • Excel- und SPSS-Datensätze werden beim Import in R standardmäßig als tibbles importiert.

   • Beispiel:

     class(peanuts_excel)

     # Ausgabe: "tbl_df" "tbl" "data.frame"

     class(peanuts_spss)

     # Ausgabe: "tbl_df" "tbl" "data.frame"

Weitere Datenstrukturen

Diese Strukturen werden in dieser Einführung nicht vertieft, können aber für komplexere Analysen wichtig sein.

• Matrix: zweidimensional, alle Elemente müssen denselben Typ haben

• Array: mehrdimensionale Datenstruktur, homogen

• Liste: Sammlung von Objekten beliebigen Typs, z. B. Vektoren, Tabellen, Funktionen

  
  

Konvertierung zwischen Datenstrukturen

• Tibbles können in klassische data frames umgewandelt werden:

  peanuts_excel_df <- as.data.frame(peanuts_excel)

• Das ist nützlich, wenn ältere Funktionen nicht direkt mit tibbles arbeiten.

Zusammenfassung

• Vektor: eindimensional, homogen, z. B. Alter, Namen

• Data frame: mehrdimensional, Spalten können verschiedene Typen haben

• Tibble: moderne Version des data frames, vorteilhaft für tidyverse-Analysen

• Mit class() kann die Datenstruktur eines Objekts jederzeit abgefragt werden.

1. Pakete installieren und laden

• Installation (nur einmal nötig):

install.packages("tidyverse") install.packages("sjmisc") install.packages("sjPlot") install.packages("sjlabelled")

• Laden der Pakete:

library(tidyverse) library(haven) library(sjmisc) library(sjPlot) library(sjlabelled)

2. Datensatz laden

• .RData laden und im Skript verfügbar machen:

load("Pfad/zum/Datensatz/ess9de_m1.RData")

3. Überblick über den Datensatz verschaffen

• Gesamte Tabelle anzeigen:

View(ess9de_m1)

• Variablennamen ausgeben:

names(ess9de_m1)

• Erste/letzte 6 Zeilen:

head(ess9de_m1) tail(ess9de_m1)

• Struktur & Übersicht (kurz und zeilenweise):

glimpse(ess9de_m1) view_df(ess9de_m1) # schöner im Viewer

4. Einzelvariable untersuchen: Politisches Interesse (polintr)

• Häufigkeitstabelle erstellen:

table(ess9de_m1$polintr) # nur gültige Antworten table(ess9de_m1$polintr, useNA = "always") # auch fehlende Werte table(ess9de_m1$polintr, useNA = "ifany") # nur wenn NA vorhanden

• Alternative mit dplyr:

count(ess9de_m1, polintr)

• Alternative mit sjmisc:

frq(ess9de_m1, polintr) # Tabellarische Ausgabe inkl. % frq(ess9de_m1, polintr, out = "viewer") # Ausgabe im Viewer frq(ess9de_m1, polintr, out = "browser") # Ausgabe im Browser

5. Tabellen sortieren (sjmisc frq)

• Absteigend nach Häufigkeit:

frq(ess9de_m1, polintr, sort.frq = "desc", out = "viewer")

• Aufsteigend nach Häufigkeit:

frq(ess9de_m1, polintr, sort.frq = "asc", out = "viewer")

💡 Merksätze / Tipps:

• View() → Daten im RStudio-Viewer ansehen

• head() / tail() → erste/letzte Zeilen schnell prüfen

• glimpse() → kompakter Überblick (Variablen + erste Werte)

• table() → einfache Häufigkeitstabelle

• count() (dplyr) → besser formatierte Häufigkeiten

• frq() (sjmisc) → Tabellen mit % und Optionen für Viewer/Browser

• useNA in table() immer angeben, wenn fehlende Werte berücksichtigt werden sollen

Der Pipe-Operator %>% oder |<ermöglicht, mehrere R-Funktionen nacheinander auszuführen, sodass der Code leichter lesbar wird.

• %>% = entspricht “und dann“ → Ergebnisse einer Funktion werden direkt an die nächste Funktion weitergegeben.

• Entwickelt von Stefan Milton Bache (Paket magrittr).

• Im tidyverse ist %>% automatisch verfügbar.

• Tastenkürzel in RStudio: Strg + Shift + M

Unterschied des Tidyverse-Operators und Native-Pipe Operators:

• Verwende %>%, wenn du mit tidyverse-Paketen (z. B. dplyr, ggplot2) arbeitest.

• Verwende |>, wenn du nur mit Base R arbeitest und einfache Verarbeitungsketten schreiben willst.

Vorteil

• Ersetzt verschachtelte Klammern, die von innen nach außen gelesen werden müssen.

• Code kann linear von links nach rechts gelesen werden → leichter verständlich.

• Besonders praktisch beim Datenmanagement mit dplyr.

Beispielrechnung

Ohne Pipe-Operator (komplizierter, verschachtelt):

x <- c(2, 3, 4) round(sqrt(sum(x^2)), 2)

Mit Pipe-Operator (leicht lesbar):

• Variante 1 (in einer Zeile):

x^2 %>% sum() %>% sqrt() %>% round(2)

• Variante 2 (untereinander, gut für längere Ketten):

x^2 %>%

sum() %>%

sqrt() %>%

round(2)

Lesart:

1. Werte von x quadrieren

2. „und dann“ die Summe berechnen

3. „und dann“ die Quadratwurzel ziehen

4. „und dann“ auf 2 Nachkommastellen runden

Das Paket dplyr gehört zum sogenannten Kern-tidyverse. Mit dplyr können Variablen ausgewählt, Variablen umbenannt, Variablen gefiltert, Variablen verändert und einfache deskriptive Statistiken berechnet werden. Die Funktionen von dplyr sind leicht zu merken, da sie einprägsame Verben verwenden.

Die wichtigsten Funktionen und ihre Aufgaben sind:

Diese Funktionen können miteinander kombiniert werden, z. B. select + rename oder group_by + summarise.

1. Variablen auswählen – select()

Bei großen Datensätzen sind wir oft nur an wenigen Variablen interessiert. Mit select() kann ein Datensatz auf diese Variablen reduziert werden.

Beispiele:

# Variante 1: neues Objekt erstellen auswahl <- select(ess9de_m1, trstprl, stfedu, gndr, bildung) View(auswahl) # Variante 2: Pipe-Operator auswahl <- ess9de_m1 %>% select(trstprl, stfedu, gndr, bildung)

Beide Varianten erstellen ein neues Objekt auswahl mit nur den ausgewählten Variablen.

2. Variablen umbenennen – rename()

Oft geben Variablennamen keine direkten Hinweise auf ihren Inhalt. Mit rename() können Variablen klarer benannt werden.

Beispiel:

auswahl <- rename(auswahl, ver.bundestag = trstprl, z.bildung = stfedu, geschlecht = gndr) View(auswahl)

• Syntax: neuerName = alterName

• Praktisch zur besseren Lesbarkeit oder Standardisierung.

Kombination select + rename:

ver_politik <- ess9de_m1 %>% select(trstprl, stfedu, gndr) %>% rename(ver.bundestag = trstprl, z.bildung = stfedu, geschlecht = gndr) View(ver_politik)

3. Variablen filtern – filter()

filter() erstellt Teildatensätze, d.h. nur bestimmte Zeilen bleiben enthalten.

Vergleich zu select():

• select() → Spalten / Variablen

• filter() → Zeilen / Beobachtungen

Beispiele:

frau <- filter(auswahl, geschlecht == 2) mann <- filter(auswahl, geschlecht == 1) frau.hohe.bildung <- filter(auswahl, geschlecht == 2 & bildung == 2)

Vergleichsoperatoren:

Wichtig: Bei select und filter entscheidet man immer, ob <- benutzt wird, um ein neues Objekt und damit Datensatz gespeichert wird oder nur über die Console angezeigt wird.

4. Variablen erstellen / verändern – mutate()

Mit mutate() können neue Variablen erstellt oder bestehende verändert werden.

Beispiel: Geschlechterkodierung umdrehen

auswahl.neu <- auswahl %>% mutate(geschlecht = ifelse(geschlecht == 1, 2, ifelse(geschlecht == 2, 1, geschlecht))) %>% mutate(geschlecht = set_labels(geschlecht, labels = c("Female" = 1, "Male" = 2))) View(auswahl.neu)

• Ursprüngliche Variable bleibt bestehen, neue Variable wird hinzugefügt oder bestehende ersetzt.

• set_labels() aus sjlabelled fügt Labels zu den numerischen Werten hinzu.

5. Deskriptive Statistiken – summarise()

summarise() berechnet Kennzahlen wie Mittelwert, Minimum, Maximum als Ausgabe über die Console

Beispiel ungruppiert:

summarise(auswahl, Mean.Bundestag = mean(ver.bundestag, na.rm = TRUE), Mean.Bildung = mean(z.bildung, na.rm = TRUE))

• na.rm = TRUE wichtig, um fehlende Werte auszuschließen.

Gruppierte Berechnungen – group_by() + summarise():

auswahl %>% group_by(geschlecht) %>% summarise( Mean.Bundestag = mean(ver.bundestag, na.rm = TRUE), Mean.Bildung = mean(z.bildung, na.rm = TRUE) )

• Berechnet Mittelwerte getrennt nach Geschlecht.

• Kombinierbar mit anderen Gruppen wie Bildungsgrad:

auswahl %>% group_by(bildung) %>% summarise( Mean.Bundestag = mean(ver.bundestag, na.rm = TRUE), Mean.Bildung = mean(z.bildung, na.rm = TRUE) )

6. Pipe-Operator – %>%

• Verbindet mehrere Funktionen zu einer Kette.

• Code kann von links nach rechts gelesen werden („und dann …“).

• Beispiel:

ess9de_m1 %>% select(trstprl, stfedu, gndr) %>% rename(ver.bundestag = trstprl, z.bildung = stfedu, geschlecht = gndr) %>% filter(geschlecht == 2) %>% summarise(Mean.Bundestag = mean(ver.bundestag, na.rm = TRUE))

• Lesbarer als verschachtelte Funktionen.

7. Weitere nützliche Funktionen

Quellen & weiterführende Infos:

• dplyr-Tidyverse: https://dplyr.tidyverse.org

• RStudio-Vignetten: vignette("dplyr")

Das Paket sjmisc bietet in R Funktionen zur Variablenaufbereitung, insbesondere zum Rekodieren, Zusammenfassen und Umkodieren von Variablen. Diese Schritte sind ein zentraler Bestandteil der Datenvorbereitung, da Datensätze oft Rohwerte enthalten, die für Analysen angepasst werden müssen.

Vor einer Analyse ist es empfehlenswert, neue Variablen zu erstellen, anstatt die Originalvariablen zu überschreiben. So bleiben die Originaldaten erhalten und die Datenaufbereitung kann überprüft werden.

1. Häufigkeitstabellen erstellen – frq()

Die Funktion frq() zeigt Häufigkeiten, Prozente und kumulierte Prozente einer Variablen an. Optional kann die Ausgabe direkt im Viewer oder Browser angezeigt werden.

Beispiel:

frq(ess9de_m1, health, out = "viewer")

• ess9de_m1: Datensatz

• health: Variable

• out = "viewer": Anzeige im Viewer-Fenster

Diese Funktion eignet sich gut, um Rohwerte zu überprüfen und den Verteilungstyp einer Variable zu erkennen.

2. Variablen rekodieren – rec()

Mit rec() können Werte einer Variablen geändert oder zusammengefasst werden. Syntax:

ess9de_m1$health_neu <- rec( ess9de_m1$health, # Ursprungsvariable rec = "1=4 [very good]; 2=3 [good]; 3=2 [fair]; 4=1 [bad]; 5=0 [very bad]; NA=NA", var.label = "Gesundheit umkodiert", # Variablenlabel as.num = FALSE # Faktor oder numerisch )

Erläuterung:

• Alte Werte (1, 2, …) werden neuen Werten (4, 3, …) zugeordnet

• In eckigen Klammern können Labels vergeben werden

• NA bleibt unverändert

• as.num = FALSE erzeugt einen Faktor mit Labels

Tipp: Immer eine neue Variable erstellen, damit das Original erhalten bleibt.

3. Gruppierung von Werten

Mehrere Rohwerte können zu Gruppen zusammengefasst werden:

ess9de_m1$health_neugruppe <- rec( ess9de_m1$health, rec = "1:2=2 [very/good]; 3=1 [fair]; 4:5=0 [very/bad]; NA=NA", var.label = "Gesundheit umkodiert in Gruppen", as.num = FALSE )

• 1:2=2: Werte 1 und 2 werden zu 2 zusammengefasst

• 4:5=0: Werte 4 und 5 werden zu 0 zusammengefasst

• Gut geeignet, um ordinalskaliertes Material zu reduzieren.

4. Variableninhalte ändern – Beispiel „Badge“

Manchmal ist es sinnvoll, Variablenwerte inhaltlich umzukodieren:

frq(ess9de_m1, badge, out = "viewer") ess9de_m1$badge_neu <- rec( ess9de_m1$badge, rec = "1=1 [ja]; 2=0 [nein]; else=NA", var.label = "Badge getragen", as.num = TRUE ) frq(ess9de_m1, badge, badge_neu, out = "viewer")

• 1=1 [ja]: Originalwert 1 wird 1 mit Label „ja“

• 2=0 [nein]: Originalwert 2 wird 0 mit Label „nein“

• else=NA: Alle anderen Werte → NA

Hinweis: Das else-Argument sollte immer am Ende stehen.

5. Kontrolle der Datenaufbereitung

Nach jeder Rekodierung sollten die Häufigkeitstabellen der Original- und der neuen Variable überprüft werden:

frq(ess9de_m1, health, health_neu, out = "viewer") frq(ess9de_m1, badge, badge_neu, out = "viewer")

So können Fehler in der Rekodierung früh erkannt werden.

6. Übersicht der wichtigsten Argumente von rec()

7. Zusammenfassung

• frq(): Häufigkeiten kontrollieren

• rec(): Variablenwerte ändern oder zusammenfassen

• Neue Variable erstellen: Immer besser als Überschreiben

• Kontrolle: Häufigkeitstabellen von Original- und neuer Variable prüfen

• Labels vergeben: Klarheit und Interpretierbarkeit erhöhen

———

Variablen zusammenfassen / Indexbildung

3a. Mittelwert – row_means()

ess9de_m1 <- row_means( ess9de_m1, trstprl, trstlgl, trstplc, n = 3, var = "poltrust" )

• Berechnet Zeilenmittelwert

• n = Mindestanzahl gültiger Werte

• var = Name der neuen Variable

3b. Werte zählen – row_count()

ess9de_m1 <- row_count( ess9de_m1, contplt, badge, sgnptit, pbldmn, count = 1, var = "totalpart" )

• Zählt Vorkommen bestimmter Werte pro Zeile

• count = Wert, der gezählt wird (z. B. 1 = Ja)

4. Wertelabels konvertieren – as_label()

Zweck: Numerische Variablen mit Wertelabels versehen, sodass alte Funktionen wie table() Labels anzeigen.

# Ursprungsvariable petition frq(ess9de_m1$petition) table(ess9de_m1$petition) # Konvertieren ess9de_m1$petition.f <- as_label(ess9de_m1$petition) table(ess9de_m1$petition.f)

• as_label() ersetzt Werte durch ihre Labels

• Praktisch für Berichte und Tabellen

5. Dichotomisierung von Variablen

Wenn man eine Variable, z.B. Alter in 2 Gruppen unterteilen möchte

• Funktion: dicho()

• Beispiel: ess9de_m1 <- dicho(

  ess9de_m1,

  agea,

  dich.by = mean #oder eine beliebige Zahl z.B: 40

  suffix = “_categorymedian (oder40) #Name

6.Mehrere Gruppen aus einer Variable erstellen

wenn man nicht nur 2 Gruppen, sondern mehrere braucht, z.B. für Altersgruppen

• Funktion: group_var()

• Beispiel: ess9dem1 <- group_var(

  ess9de_m1,

  agea,

  size = 10, #teilt immer nach 10 Werten

• ODER

  size = “auto”, n = 5, #es werden autom. eingeteilt in 5 Gruppen

  suffix = “_g” ,#(Name)

  right.intervall = TRUE (um unlogische Abf. zu verm

5. Hinweise

• Immer neue Variable erstellen, Ursprungsvariablen nicht überschreiben

• frq() eignet sich zur Kontrolle der Rekodierung und Zusammenfassung

• rec() ist flexibel, erlaubt Einzelskalierungen, Wertbereiche und Gruppierungen

• row_means() und row_count() sind nützlich für Indexbildung und Summenwerte

• as_label() erleichtert die Interpretation in Tabellen und Diagrammen

6. Kurzüberblick aller Funktionen