03_einfuehrung-in-rstudio.Rmd

## **Einführung in RStudio**

[![License: CC BY 4.0](https://img.shields.io/badge/License-CC%20BY%204.0-lightgrey.svg)](https://creativecommons.org/licenses/by/4.0/deed.de)

*"Einführung in RStudio" von Nina Hauser, Zoé Wolter & Susan Reichelt in "R Lernen - der Datenkurs von und für die Zivilgesellschaft" von CorrelAid e.V. Lizensiert unter [Creative Commons Attribution 4.0 International](https://creativecommons.org/licenses/by/4.0/deed.de).*

```{r settings_rstudio, echo=FALSE, include=FALSE}
library(rio)
```

Ab dieser Woche geht es ans Eingemachte: Nachdem Ihr in den vergangenen Lektionen bereits erste Codezeilen ausgeführt habt, beginnen wir nun zu programmieren. Um die R-Dateien, die wir nutzen werden, lokal zu öffnen, benötigt Ihr [R](https://ftp.fau.de/cran/){target="_blank"} und [RStudio](https://rstudio.com/products/rstudio/download/#download){target="_blank"}. Versucht gerne selbst beide Programme für Euer Betriebssystem zu installieren – idealerweise auf einem Laptop oder PC, auf dem Ihr **Adminrechte** habt. Gerne auch auf Eurem privaten PC. Bei Installationsschwierigkeiten könnt Ihr uns gerne vor unserer Live-Session am Freitag **per Slack-Nachricht** kontaktieren - dann lösen wir die Herausforderungen mit Euch gemeinsam.

![*Video: Einführung in RStudio (30min)*](https://youtu.be/sgczH-e0Cxg)

### **Kernaussagen**

#### R

-   R ist eine **freie, statistische Programmiersprache**
-   **Groß- und Kleinschreibung** muss in R unbedingt beachtet werden
-   Nicht jede **Funktionalität** müsst Ihr in R selbst schreiben: Über **`install.packages()`** und **`library()`** könnt Ihr Funktionalitäten, die andere Coder:innen für Euch bereitstellen, nutzen - das spart viel Zeit!

#### RStudio

-   RStudio ist auf R spezialisierte **integrierte Entwicklungsumgebung** (eng. Integrated Development Environment oder IDE), in der Ihr Code schreiben, ausführen, auf Dokumentation und Dateien zugreift, Eure Arbeit mit Anderen teilen könnt uvm.
-   Es ist empfehlenswert Code im **Code Editor** (zu dt. Codebearbeitungsprogramm) zu schreiben und mit "\#" zu kommentieren - den Code könnt Ihr mit "CMD + ENTER" für Mac und "CTRL + ENTER" für Windows ausführen - die Ergebnisse erhaltet Ihr in der **Console**
-   In der **Environment** (zu dt. Umgebung) sind Objekte (also auch Eure Daten) Eurer Arbeit gespeichert
-   Unter dem Environment findet Ihr einen **File Explorer** (zu dt. Dateimanager), mit dem Ihr Dateien auf Eurer Festplatte suchen und per Doppelklick öffnen könnt
-   Zusätzlich werden dort Plots (zu dt. Abbildungen), geladene Packages und die **Dokumentation** ("Hilfe") angezeigt, die Ihr mit dem Befehl **help("Funktion")** oder **?Funktion** durchsuchen könnt
-   Alle **Shortcuts** für RStudio findet Ihr unter ("Menü Help -\> Keyboard Shortcuts Help)
-   In englischer Sprache ist zudem ein **Schummelblatt** zur [IDE RStudio](https://github.com/CorrelAid/lernplattform/blob/main/cheatsheets/03_cheatsheet-rstudio.pdf){target="_blank"} verfügbar

#### R Projekt (RProj)

-   Um nervige Dateipfad-Verwirrungen zu vermeiden und eine Art "Container" für Eure R Projekte anzulegen, erstellt Ihr am besten immer ein **R Projekt**
-   Im Ordner mit dem R Projekt legt Ihr am besten immer einen **Ordner** für Eure Daten und einen Ordner für Euren Code an und falls nötig noch für Grafiken o.ä.

Alle Informationen zu dem Datensatz, mit dem wir in diesem Kurs arbeiten, findet Ihr [hier](https://github.com/rfordatascience/tidytuesday/tree/master/data/2021/2021-01-26){target="_blank"}.

### **Quiz**

```{r quiz_rstudio}
quiz(caption = NULL,
  question("Ich muss nicht auf die Groß- und Kleinschreibung achten, wenn ich in R programmiere.",
    answer("Korrekt"),
    answer("Inkorrekt", correct = TRUE),
    correct = "Richtig!",
    incorrect = "Leider falsch: Groß- und Kleinschreibung, aber auch Kommas und Klammern, sind wichtig für funktionierenden Code in R!",
    allow_retry = TRUE,
    try_again_button = "Nochmal versuchen"
  ),
  
  question("Code ist über Patent- und Urheberrechte geschützt, deshalb darf ich nichts von anderen Coder:innen benutzen.",
    answer("Korrekt, Code von anderen sollte ich auf keinen Fall kopieren."),
    answer("Inkorrekt, Code von anderen kann ich immer übernehmen."),
    answer("Bei der Verwendung von Code sollte ich immer beachten, welcher Lizenz der Code unterliegt.", correct = TRUE),
    correct = "Richtig!",
    incorrect = "Leider falsch: Austausch von Code in Foren wie StackOverflow ist wichtig und hilfreich, aber dabei solltest Du immer beachten, ob der Code einer Lizenz unterliegt und du den Code tatsächlich einfach kopieren darfst (Beispiele für Lizenzen findest Du [hier](https://creativecommons.org/about/cclicenses/)).",
    allow_retry = TRUE,
    try_again_button = "Nochmal versuchen"
  ),
  
  question("Wo in RStudio schreibst Du Deinen Code?",
    answer("Konsole", correct = TRUE),
    answer("Environment"),
    answer("Terminal"),
    answer("Code Editor", correct = TRUE),
    correct = "Richtig!",
    incorrect = "Leider falsch. Öffne am besten direkt nochmal RStudio. Wo findest Du die oben genannten Fenster und kannst Du dort Code eingeben?",
    allow_retry = TRUE,
    try_again_button = "Nochmal versuchen"
  ),
  
  question("IDE steht für Integrated Development Environment (zu dt. integrierte Entwicklungsumgebung). RStudio ist eine integrierte Entwicklungsumgebung für R.",
    answer("Korrekt", correct = TRUE),
    answer("Inkorrekt"),
    correct = "Richtig!",
    incorrect = "Leider falsch - die beiden Aussagen sind richtig.",
    allow_retry = TRUE,
    try_again_button = "Nochmal versuchen"
  )
)
```

<br>
<div style="border-width:1px; border-style:solid; border-color:#acc940; padding: 1em;">

*Jetzt geht es so richtig los! Bitte denke daran: am Anfang passieren immer viele Fehler und Du wirst vermutlich auch nicht alles auf Anhieb verstehen, das ist völlig normal. Lass Dich davon nicht abschrecken, schreibe Dir einfach Deine Fragen auf und bringe sie zur nächsten Livesession am Freitag mit!*
</div>
<br>

### **Grundlagen: Syntax in R**

Einen Überblick über die Grundlagen in R erhaltet Ihr in diesem [**Schummelblatt**](https://github.com/CorrelAid/lernplattform/blob/main/cheatsheets/03_cheatsheet-base-r.pdf){target="_blank"}. In diesem Abschnitt stellen wir Euch die wichtigsten Grundlagen für die kommenden Wochen vor!

Die simpelste Version von R ist einfach die Verwendung als Taschenrechner. Führt mal folgenden Code-Block aus:

```{r mathop, exercise = TRUE}
### mathematische Operatoren
2 + 2   # plus
2 - 1   # minus
2 * 2   # mal
2 / 2   # geteilt
```

Wie Ihr seht: **Kommentare** erkennt Ihr an dem Hash **"\#"**, d.h. alles was in der Zeile nach einem **"\#"** kommt, wird von R nicht als Code ausgeführt!

R kann aber auch eine Art Orakel sein: Mit **logischen Ausdrücken** könnt Ihr u.a. Datensätze filtern und Wenn-Dann-Begingungen für Operationen definieren. Was denkt Ihr, sind die folgenden logischen Ausdrücke wahr (=TRUE) oder falsch (=FALSE)?

```{r logik, exercise = TRUE}
### logische Ausdrücke
2 == 2                      # ist gleich
2 != 3                      # nicht gleich
!(2 == 2)                   # nicht
2 < 3                       # kleiner als
2 > 3                       # größer als
2 <= 2                      # kleiner gleich
2 >= 3                      # größer gleich
(1 + 1 == 2) & (2 + 2 == 5) # und
(1 + 1 == 2) | (2 + 2 == 5) # oder
```

Was für Daten gibt es denn eigentlich? Erinnert euch mal zurück an letzte Woche, da haben wir uns verschiedene Datentypen angeschaut und überlegt was für (un)geordneten Informationen in den Daten enthalten sein können. Diese Unterscheidungen sind in R wichtig, denn sie bestimmen was ihr mit Daten überhaupt anstellen könnt. In R könnt Ihr mit den folgenden Grundtypen an Daten arbeiten:

```{r grundtypen, exercise = TRUE}
7                # integer (also eine ganze Zahl)
7.234123         # numeric (also alle Zahlen)
'irgendein Text' # character (jegliche Text-Daten müssen immer in Anführungszeichen stehen)
TRUE             # boolean (also das binäre TRUE oder FALSE)
```

R hat darüber hinaus aber auch eine Art Gedächtnis. D.h. Ihr könnt Werte in Objekten speichern, das geht über den Zuweisungspfeil `<-`:

```{r zuweisung, exercise = TRUE}
zahl <- 2       # Variablenzuweisung: Der Wert 2 wird im Objekt mit dem Namen 2 gespeichert
zahl            # Wenn Ihr dann das Objekt aufruft, wird Euch der Wert angezeigt, der im Objekt gespeichert ist
```

Nun denkt ihr vielleicht, dass ein Objekt, bestehend aus nur einem Wert, ja ziemlich übersichtlich ist und man dafür vielleicht gar kein R braucht ... aber neben einzelnen Werten lässt sich natürlich auch eine ganze Reihe an Werten in einem Objekt speichern. Hierbei handelt es sich um einen Vektor, d.h. alle einzelnen Werte werden über das `c()` zusammengepackt. Achtung: in einem Vektor sollten nur Werte des gleichen Grundtyps gespeichert sein!

```{r vector, exercise = TRUE}
# Einzelne Werte werden in einem Vektor mit der Bezeichnung 'irgendein_vektor' gespeichert, wenn Ihr diesen aufruft, werden alle darin enthaltenen Werte angezeigt
irgendein_vektor <- c('R', 'ist', 'richtig', 'toll!')   
irgendein_vektor      

# Natürlich könnt Ihr auch einen einzelnen Wert, der in einem Vektor enthalten ist, wieder aufspüren, dazu nutzt Ihr einfach die Position des Wertes im Vektor
irgendein_vektor[1] 
irgendein_vektor[4]
```

Einen letzten Datentyp neben den vier Grundtypen und Vektoren möchten wir Euch hier noch vorstellen: Listen - in Listen können Werte von unterschiedlichen Grundtypen gespeichert werden:

```{r list, exercise = TRUE}
# Einzelne Werte werden in einer Liste mit der Bezeichnung 'meine_liste' gespeichert, wenn Ihr diese aufruft, werden alle darin enthaltenen Werte angezeigt
meine_liste <- list('Das', 'ist', 'eine', 'Liste', 1, 5.23, TRUE)
meine_liste

# Natürlich könnt Ihr auch einen einzelnen Wert, der in einer Liste enthalten ist, wieder aufspüren, dazu nutzt Ihr einfach die Position des Wertes in der Liste
meine_liste[1]
```

In der Environment behaltet ihr einen ganz guten Überblick über die verschiedenen Daten und Objekte, mit denen ihr in R arbeitet. Aber ihr könnt auch Funktionen nutzen, um euch einen schnellen Überblick zu verschaffen. Wie genau die Objekte im Detail aufgebaut sind, schauen wir uns gleich noch an!

```{r class, exercise = TRUE}
# Um herauszufinden mit was für einem Objekt ihr umgeht, könnt ihr die class() Funktion anwenden.
beispiel1 <- 5+4
beispiel2 <- c('Hund', 'Katze')
beispiel3 <- list('Auch', 'das', 'ist', 'eine', 'Liste', TRUE)

class(beispiel1)
class(beispiel2)
class(beispiel3)
```

### **Interaktive Übung**

<div style="border-width:1px; border-style:solid; border-color:#acc940; padding: 1em;">
*Hinweis: In den folgenden Übungslektionen gibt es einen Teil, den Ihr innerhalb der Lernplattform erledigen könnt. Den anderen Teil solltet Ihr lokal auf Eurem Rechner ausführen, um Euch an die IDE RStudio zu gewöhnen.*
</div>
<br>

Wenn Ihr mit Eurem Datenprojekt startet, solltet Ihr Euch überlegen, welche **Funktionalitäten** Ihr braucht, um Daten zu importieren, zu bereinigen und zu analysieren. Die benötigten Funktionalitäten müsst Ihr nicht alle selbst programmieren, dafür gibt es sogenannte **Packages** (zu dt. Pakete) - eine ziemlich gute Sache. Eure Arbeit beginnt deshalb in der Regel mit der **Installation und dem Laden** dieser Funktionalitäten. Dazu nutzen wir die Funktionen **`install.packages("package")`** und **`library(package)`**. Die Nutzung von Anführungszeichen ist nur bei der Installation (also für `install.packages()`) relevant. Bitte denkt daran, `install.packages()` auszukommentieren (also ein \# vor die Zeile zu packen), wenn die Installation abgeschlossen ist - sonst wird die Installation bei jedem Ausführen des Skripts wieder durchgeführt. In der Zukunft könnt Ihr auch eine eigene Datei für Installationsskripte einrichten - damit könnt Ihr Euch aber noch zu einem späteren Zeitpunkt beschäftigen.

Ein **Code Chunk** (zu dt. Codeblock), also ein Abschnitt mit Code, der Pakete installiert und lädt, sieht so aus. Hier wurde der Code auskommentiert (da wir alle Pakete, die für die Lernplattform notwendig sind für Euch schon installiert und geladen haben).

```{r pakete, exercise = TRUE}
# Installation und Laden des Packages "rio"
# install.packages("rio")
library(rio)
```

Mit der Notation **`package::funktion()`** kennzeichnen wir, woher eine Funktion kommt und können - unabhängig von geladenen Package-Libraries - Funktionen nutzen. Dabei ist es zwar nicht nötig, das Package vor die Funktion zu schreiben - aber definitiv best practice! Es gibt unglaublich viele Packages, die jeweils auch viele Funktionen mitbringen. Für viele Vorgehensweisen gibt es demnach nicht "einen" richtigen Weg, sondern je nach Package und Funktionen relativ viel Variation. Das Hinzufügen aus welchem Package eine bestimmte Funktion stammt, hilft also auch dabei, den eigenen Überblick über den gewählten Ansatz zu behalten.

Dateien können u.a. mit dem Package **`rio`** und der Funktion **`import()`** geladen werden, wie ihr im Code Chunk unten sehen könnt. Die geladenen Daten werden dann in einem Dataframe gespeichert - hier wird dem Datensatz der Name "data_raw" zugewiesen ("objektname \<- objekt"). Über diesen ist er dann im weiteren Skript abrufbar. Wenn Ihr Daten aus lokalen Ordnern laden möchtet, müsst Ihr den Link durch den Pfad der Datei (einsehbar über Rechtsklick auf den Dateinamen) auf Eurem Rechner ersetzen. Leichter wird das mit der Funktion **`here::here()`**, die für Euch in Verbindung mit RProjekten die Navigation in den entsprechenden Ordner stark vereinfacht (Recap: die `here`-Funktion setzt das Arbeitsverzeichnis in den Ordner mit der .Rproj-Datei).

```{r daten_einlesen, exercise = TRUE}
# Hier laden wir mit dem rio-Package und der Funktion "import()" unseren Datensatz.
data_raw <- rio::import('https://raw.githubusercontent.com/rfordatascience/tidytuesday/master/data/2021/2021-01-26/plastics.csv')
# Wenn Ihr das Objekt aufruft, bekommt Ihr die darin gespeicherten Daten angezeigt
data_raw


# Alternative für lokale Dateien, die in Eurem R-Projekt als CSV-Datei in einem Ordner namens "Daten" hinterlegt wurden, mit dem "here"-Package
# data_raw <- rio::import(here::here('daten/plastics.csv'))
```

Überprüft hier nochmal, als welche Art von **Objekt** `rio::import()` unseren Datensatz importiert. Das haben wir eben schon mit anderen Objekten probiert ... Wenn Ihr auf "Antwort einreichen" klickt, bekommt Ihr Feedback zu Eurem Code. Mit Hilfe von "Lösung anzeigen" könnt Ihr nachschauen, wie die richtige Lösung aussieht.

```{r exercise_class, exercise = TRUE}
# Euer Code hier
```

```{r exercise_class-solution}
# Datenformate überprüfen wir mit "class()"
class(data_raw)
```

```{r exercise_class-check}
grade_this_code()
```

Mit der Funktion **`head()`** könnt Ihr Euch die ersten sechs Beobachtungen anzeigen lassen, um den Datensatz zu erkunden. Das Gegenteil von `head()` ist `tail()` - damit könnt Ihr die letzten sechs Beobachtungen erkunden.

```{r head, exercise = TRUE}
# Erste sechs Zeilen anzeigen lassen
head(data_raw)
```

Um eine Übersicht über die Variablen zu bekommen, könnt Ihr Euch mit der Funktion **`colnames()`** deren Namen anzeigen lassen.

```{r variablen, exercise = TRUE}
# Spaltennamen anzeigen lassen
colnames(data_raw)
```

Die Funktionen **`nrow()`, `ncol()` und `dim()`** helfen Euch die **Dimensionen** Eures Datensatzes zu bestimmen. Mit `help("Funktion")` könnt Ihr Euch über RStudio in der Konsole die Erklärung zu den Funktionen anzeigen lassen. Nutzt das bisher Gelernte, um Euch die Spaltenanzahl (also die Anzahl an Variablen) ausgeben zu lassen.

```{r exercise_ncol, exercise = TRUE}
# Euer Code hier
```

```{r exercise_ncol-solution}
# Mit ncol() könnt Ihr Euch die Anzahl an Spalten (eng. columns) anzeigen lassen
ncol(data_raw)
```

```{r exercise_ncol-check}
  give_code_feedback(grade_this({
    pass_if_equal(.solution)
    if (length(.result) != 1) {
        fail("Eure Antwort enthält {length(.result)} Wert(e) und nicht: {length(.solution)}. Habt Ihr die richtige Funktion genutzt?")
    }
    if (.result == 13380) {
        fail("Das ist die Zeilenanzahl, also die Anzahl an Beobachtungen! Habt Ihr die richtige Funktion genutzt?")
    }
    fail("Noch nicht ganz richtig.")
  }))
```

Elementare Merkmale des Datensatzes könnt Ihr Euch mit der Funktion **`summary()`** anzeigen lassen. Bei Text sind das Länge, Objektart und Mode; bei numerischen Werten Minimum, Mittelwert, Maximum, Quartile und fehlende Werte (diese Begriffe sollten euch aus der letzten Lektion bekannt vorkommen - wir werden in der nächsten Lektion auch nochmal genauer auf die Bedeutung schauen).

```{r datenstruktur_summary, exercise = TRUE}
# Überblick über Daten
summary(data_raw)
```

Alternativ gibt es auch die Funktion **`str()`**, die ähnlich wie **`summary()`** Grundeigenschaften von Datentabellen anzeigt. Welche Unterschiede findet Ihr zwischen den beiden Funktionen?

```{r datenstruktur_str, exercise = TRUE}
# Überblick über Daten
str(data_raw)
```

Wenn Ihr einzelne Spalten oder **Subsets** (zu dt. Teilmengen) eines Datensatzes braucht, könnt Ihr diese aus dem Datensatz herausziehen. Dazu nutzen wir das Dollarzeichen "\$" mit Datensatz\$Spaltenname oder die eckigen Klammern mit Datensatz['Spaltenname']. Wollt Ihr mehrere Spalten aufrufen, könnt Ihr die Logik Datensatz[c('Spaltenname1', 'Spaltenname2')] nutzen (Recap: **`c()`** ist hierbei die Notation von R für Vektoren, in denen Ihr mehrere Werte hinterlegen könnt).

Wenn Ihr mit einem bestimmten Subset weiterarbeiten wollt, könnt ihr auch einfach über eine neue Objektzuweisung und einen Objektnamen einen zusätzlichen Datensatz erstellen.

```{r slicing1, exercise = TRUE}
# Auslesen der Spalte 'country'
data_raw$country 
# Auslesen der Spalten 'country' und 'year'
data_raw[c('country', 'year')]
```

```{r slicing2, exercise = TRUE}
# Erstellung eines Subsets auf Basis von Bedingungen
subset(data_raw, country == "Argentina" & year == 2020)
```

```{r slicing3, exercise = TRUE}
# Erstellung eines neuen Objekts auf Basis von Bedingungen
ARG_2020 <- subset(data_raw, country == "Argentina" & year == 2020)
```

<div style="border-width:1px; border-style:solid; border-color:#acc940; padding: 1em;">

*Uff geschafft! Wenn Du direkt noch mehr zu R lernen möchtest, dann schau Dir gerne den Exkurs zu Kontrollstrukturen an. Gerne kannst Du aber auch direkt weiter zur Übung springen!*

</div>

---

<details>
  <summary><h4>&#10145; Exkurs: Kontrollstrukturen</h4></summary>
  <br>
  
<h3><b>Exkurs: Kontrollstrukturen</b></h3>  

In der Programmierung gibt es verschiedene Kontrollstrukturen: Nur *wenn* die Note eines Teilnehmenden besser als eine 2 ist, *dann* soll R den Text 'Gut gemacht' ausgeben? Dann braucht Ihr eine **Wenn-Dann-Bedingung** (*engl. If-Then-Statement*). Hier die Syntax und ein kleines Beispiel - Welcher Text (*Operation innerhalb der geschwungenen Klammern*) wird hier ausgegeben?

```{r wenndann, exercise = TRUE}
# if (Bedingung, die überprüft wird) {
#   Code, der ausgeführt wird, wenn die Bedingung erfüllt ist
# } else {
#   Code, der ausgeführt wird, wenn die Bedingung NICHT erfüllt ist
# }

if (2 + 2 == 5) {
  print("Oh nein!")
  } else if (2 + 2 <= 3) {
  print("Oh nein!")
  } else if (2 + 2 >= 5) {
  print("Oh nein!")
  } else {
  print("Puh, nicht verrechnet...")
    }
```

Da haben wir nochmal Glück gehabt: Unser **regelbasiertes System** funktioniert. Neben **Maschinellem Lernen** sind solche regelbasierten Systeme übrigens eine wichtige Form von allen Technologien, die unter das Modewort **Künstliche Intelligenz** fallen. Die zugehörigen Regeln werden in komplexeren Systemen von Expert:innen verfasst und erst nach und nach, wenn es möglich ist, durch alternative Technologien ersetzt. Ein gutes Beispiel dafür sind Verfahren zur Verarbeitung von Sprache (siehe [hier](https://aclanthology.org/D13-1079.pdf){target="_blank"}). Ihr könnt Euch aber auch einfach ein regelbasiertes System vorstellen, das automatisch bei der Erreichung einer bestimmten Spendensumme eine Dankesnachricht an alle Spender:innen versendet.

Neben der Ausführung von Aktionen unter bestimmten Bedingungen können wir durch technische Implementierungen **Aktionen mehrfach ausführen**. Ein Beispiel: Nach der Erreichung der Spendensumme soll eine Dankesnachricht an alle Spender:innen gesendet werden. In der Programmierung bezeichnet man diese iterierenden Verfahren als **Loop** (zu dt. Schleife). Sind alle Spender:innen bekannt (und somit die Liste der Elemente, über die man iteriert), nutzt man einen **For Loop** (zu dt. Für-Schleife).

![](https://github.com/CorrelAid/lernplattform/blob/main/abbildungen/03_einfuehrung-in-rstudio/forloop.png?raw=true){#id .class width="30%" height="100%"}

```{r fuerschleife, exercise = TRUE}
# Aus der Liste "list("Lisa", "Frie", "Zoe")" picken wir uns eine "spenderin" raus...
for (spenderin in list("Lisa", "Frie", "Zoe")) {
  # für diese "spenderin" geben wir den Satz 'Danke, <Name diese:r:s Spender:in>!' aus
  print(paste("Danke,", spenderin, "!"))
}
```

Soll die Aktion ausgeführt werden, bis eine Bedingung eintritt, z.B. weil alle Spender:innen kontaktiert wurden, dann nutzt man einen **While Loop** (zu dt. Solange-Schleife).

![](https://github.com/CorrelAid/lernplattform/blob/main/abbildungen/03_einfuehrung-in-rstudio/whileloop.png?raw=true){.class width="30%" height="100%"}

```{r solangeschleife, exercise = TRUE}
# Erstellung der Liste unbekannter Länge
spenderinnenliste <- list("Lisa", "Frie", "Zoe")

# definiere Startwert
i <- 1

# führe den Code für alle i kleiner gleich der Länge der Liste durch...
while (i <= length(spenderinnenliste)) {
  # ...gebe für diesen Eintrag den Satz 'Danke, <Name diese:r:s Spender:in>!' aus...
  print(paste("Danke,", spenderinnenliste[[i]], "!"))
  # ...setze den Counter i um 1 herauf
  i = i + 1
}
```

</details>

---

Eine letzte Anmerkung: Es ist ganz normal, dass Euer Code mal **Fehler** wirft - auch uns passiert das. In der Console (und in RMDs unter dem Code Chunk) wird Euch dann angezeigt, **wo der Fehler auftritt und um welche Art von Fehler es sich handelt** (sog. Fehlermeldung). Beliebte Fehlerquellen sind **Syntaxfehler** (wenn Ihr beispielsweise Klammern nicht schließt, die falsche Klammerart nutzt oder Argumente nicht durch Kommata trennt) oder die falsche Verwendung von Argumenten in Funktionen. Auch das Schreiben von Kommentaren in Code Chunks ist nur mit "\#" zu Beginn des Textes möglich. Wenn Ihr mal gar nicht weiter wisst, kopiert einfach die Fehlermeldung aus der Console und begebt Euch damit auf eine Googlesuche. Auf [**Stack Overflow**](https://stackoverflow.com/){target="_blank"} und in der [**R-Online Community**](https://community.rstudio.com/){target="_blank"} finden sich für (fast) alle Herausforderungen Antworten und Hilfestellungen.

### **Und jetzt Ihr**

Legt nun ein neues R Projekt (wie im Video) und eine neue R Markdown-Datei auf Eurem Rechner an und...

1.  Installiert und ladet das Package "rio".
2.  Lest den Datensatz über den Hyperlink oder lokal ein. Ihr findet ihn unter diesem [Link](https://raw.githubusercontent.com/rfordatascience/tidytuesday/master/data/2021/2021-01-26/plastics.csv){target="_blank"} und könnt ihn dort auch herunterladen, wenn Ihr Euch für die zweite Variante entscheidet.
3.  Nutzt die vorgestellten Funktionen, um den Datensatz zu erkunden. Dafür könnt Ihr die Code Chunks aus der Lernplattform einfach in RStudio kopieren und sie dort ausführen.

### **Zusätzliche Ressourcen**

-   Schummelblatt zu den [Grundlagen in R](https://github.com/CorrelAid/lernplattform/blob/main/cheatsheets/03_cheatsheet-base-r.pdf){target="_blank"} (dt.)
-   Schummelblatt zur [IDE RStudio](https://github.com/CorrelAid/lernplattform/blob/main/cheatsheets/03_cheatsheet-rstudio.pdf){target="_blank"} (engl.)
-   [Introduction to Programming in R (engl.)](https://app.dataquest.io/course/intro-to-r-rewrite){target="_blank"} von Dataquest
-   [Data Structures in R (engl.)](https://app.dataquest.io/course/datastructure-in-r-rewrite){target="_blank"} von Dataquest
-   [Control Flow, Iteration and Functions in R (engl.)](https://app.dataquest.io/course/intermediate-r){target="_blank"} von Dataquest
-   [R Studio Learn: Programming Basics](https://rstudio.cloud/learn/primers/1.2){target="_blank"}