programing-letters-numbers.qmd

# Buchstaben und Zahlen {#sec-letter-number}

*Letzte Änderung am `r format(fs::file_info("programing-letters-numbers.qmd")$modification_time, '%d. %B %Y um %H:%M:%S')`*

> *"Beyond this place there be dragons (lat. Hic sunt dracones)" --- Captain Picard, Star Trek: The Next Generation, Where Silence Has Lease*

```{r}
#| warning: false
#| echo: false

pacman::p_load(tidyverse, readxl, knitr, kableExtra)
data_tbl <- read_excel("data/flea_dog_cat.xlsx") |>
  mutate(flea_count = as.integer(flea_count),
         infected = as.logical(infected))

```

{{< video https://youtu.be/OnRaSmybhOQ >}}

Was ist eigentlich das Problem mit den Buchstaben und Zahlen? Anscheinend haben Programmier*sprachen* ein Problem Zahlen und Buchstaben auseinander zuhalten. Eigentlich eher die Arten von Zahlen und Buchstaben die es so gibt. Es gibt nicht nur die eine Zahl und den einen Buchstaben. Je nach Kontext hat eine Zahl und ein Buchstabe eine andere Bedeutung. In den vorherigen Beispielen haben wir uns die Sprungweiten und andere Eigenschaften von Hunden und Katzen angeschaut. Bevor wir uns weiter mit statistischen Kennzahlen beschäftigen, wollen wir uns einmal die Realisierung des Beispiels in R anschauen. Das heißt, wie ist eine Tabelle in R aufgebaut und was sehen wir da eigentlich?

Hier siehst du nochmal die Tabelle, wie wir die Tabelle in Microsoft Word darstellen würden.

```{r}
#| echo: false
#| label: tbl-dog-cat-letter
#| tbl-cap: Sprunglängen [cm] für Hunde- und Katzenflöhe.

data_tbl |>
  kable(align = "c", "pipe")
```

Wir wollen jetzt an der Datentabelle die Besonderheiten von Zahlen und Buchstaben in einer Programmiersprache verstehen. Da wir uns jetzt hier mit der Programmiersprache R beschäftigen wollen, konzentrieren wir uns auf den Fall R. In anderen Programmiersprachen ist die Sachlage ähnlich aber nicht unbedingt gleich. Dabei wollen wir insbesondere die Eigenschaften von Zahlen und Buchstaben lernen, die notwendig sind um mit einem Programm wie R kommunizieren zu können. Nun haben wir in der @tbl-dog-cat-letter mit Daten zu verschiedenen Outcomes, wie Sprungweite \[cm\], Anzahl an Flöhen auf Hunden und Katzen, die Boniturnoten oder aber den Infektionsstatus. Die Tabelle ist zwar nicht groß aber auch nicht wirklich klein. Wir wollen uns nun damit beschäftigen, die Zahlen sinnvoll in R darzustellen. Wir wollen mit der Darstellung einer Datentabelle in R beginnen, einem `tibble()`.

## Daten in R sind `tibble()`

Im Folgenden sehen wir die Daten aus der @tbl-dog-cat-letter in R als `tibble` dargestellt. Was ist nun ein `tibble`? Ein `tibble` ist zu aller erst ein Speicher für Daten in R. Das heißt wir lagern unsere Daten in Spalten und Zeilen. Jede Spalte repräsentiert eine Messung oder Variable und die Zeilen jeweils eine Beobachtung.

```{r echo = FALSE}
data_tbl 
```

Schauen wir uns also ein `tibble()` der obigen Datentabelle einmal näher an. Als erstes erfahren wir, dass wir einen `A tibble: 14 x 5` vorliegen haben. Das heißt, wir haben 14 Zeile und 5 Spalten. In einem `tibble` wird immer in der ersten Zeile angezeigt wie viele Beobachtungen wir in dem Datensatz haben. Wenn das `tibble` zu groß wird, werden wir nicht mehr das ganze `tibble` sehen sondern nur noch einen Ausschnitt. Im Weiteren hat jede Spalte noch eine Eigenschaft unter dem Spaltennamen:

-   `<chr>` bedeutet `character`. Wir haben also hier Worte vorliegen.
-   `<dbl>` bedeutet `double`. Ein `double` ist eine Zahl mit Kommastellen.
-   `<int>` bedeutet `integer`. Ein `integer` ist eine ganze Zahl ohne Kommastellen.
-   `<lgl>` bedeutet `logical` oder `boolean`. Hier gibt es nur die Ausprägung *wahr* oder *falsch*. Somit `TRUE` oder `FALSE`. Statt den Worten `TRUE` oder `FALSE` kann hier auch 0 oder 1 stehen.
-   `<str>` bedeutet `string` der aus verschiedenen `character` besteht kann, getrennt durch Leerzeichen.

Wieso ist das wichtig? Wir sehen hier, was R glaubt in den Spalten an Zahlen und Buchstaben vorzufinden. Es mag aber sein, dass R sich irrt. Dann müssen wir die Eigenschaften der Spalte ändern.

## Faktoren als Wörter zu Zahlen

[Ein *Faktor* ist eine Variable mit mehreren *Faktorstufen* oder *Leveln*. Für uns sieht der Faktor wie ein Wort aus, hinter jedem Wort steht aber eine Zahl mit der gerechnet werden kann.]{.aside}

Ein Computer und somit auch eine Programmsprache wie R kann keine Buchstaben *verrechnen*. Ein Programm kann nur mit Zahlen rechnen. Wir haben aber in der @tbl-dog-cat-letter in der Spalte `animal` Buchstaben stehen. Da wir hier einen Kompromiss eingehen müssen führen wir Faktoren ein. Ein Faktor kombiniert Buchstaben mit Zahlen. Wir als Anwender sehen die Buchstaben, die Wörter bilden. Intern steht aber jedes Wort für eine Zahl, so dass R mit den Zahlen rechnen kann. Klingt ein wenig kryptisch, aber wir schauen uns einen `factor` einmal in R an.

```{r }
data_tbl$animal[1:8]
```

[Über das `$` Symbol kannst du im @sec-dollar mehr erfahren.]{.aside}

Was haben wir gemacht? Als erstes haben wir die Spalte `animal` aus dem Datensatz `data_tbl` mit dem Dollarzeichen `$` *herausgezogen*. Mit dem `$` Zeichen können wir uns eine einzelne Spalte aus dem Datensatz `data_tbl` raus ziehen. Du kannst dir das `$` wie einen Kleiderbügel und das `data_tbl` als einen Schrank für Kleiderbügel verstellen. An dem Kleiderbügel hängen dann die einzelnen Zahlen und Worte. Wir nehmen aber nicht den ganzen Vektor sondern nur die Zahlen 1 bis 8, dargestellt durch `[1:8]`. Die Gänsefüßchen `"` um `dog` zeigen uns, dass wir hier Wörter oder `character`vorliegen haben. Schauen wir auf das Ergebnis, so erhalten wir sieben Mal `dog` und einmal `cat`. Insgesamt die ersten acht Einträge der Datentabelle. Wir wollen diesen Vektor uns nun einmal als Faktor anschauen. Wir nutzen die Funktion `as_factor()`.

[Über Funktionen kannst du im @sec-R-function mehr erfahren.]{.aside}

```{r}
as.factor(data_tbl$animal[1:8])
```

Im direkten Vergleich verschwinden die Gänsefüßchen `"` um `dog` und zeigen uns, dass wir hier keine `character` mehr vorliegen haben. Darüber hinaus sehen wir auch, dass die der Faktor jetzt `Levels` hat. Exakt zwei Stück. Jeweils einen für `dog` und einen für `cat`. Wir werden später Faktoren benötigen, wenn wir zum Beispiel eine einfaktorielle ANOVA rechnen. Hier siehst du schon den Begriff *Faktor* wieder.

## Von Wörtern und Objekten

Das mag etwas verwirrend sein, denn es gibt in R Wörter `string <str>` oder `character <chr>`. Wörter sind was anderes als Objekte. Streng genommen sind beides Wörter, aber in Objekten werden Dinge gespeichert wohin gegen das Wort einfach ein Wort ist. Deshalb kennzeichnen wir Wörter auch mit Gänsefüßchen als `"wort"` und zeigen damit, dass es sich hier um einen String handelt.

Wir tippen `"animal"` in R und erhalten `"animal"` als Wort zurück. Das sehen wir auch an dem Ausdruck mit den Gänsefüßchen.

```{r}
"animal"
```

[Über den Zuweisungspfeil `<-` kannst du im @sec-R-pfeil mehr erfahren.]{.aside}

Wir tippen `animal` ohne die Anführungszeichen in R und erhalten den Inhalt von `animal` ausgegeben. Dafür müssen wir aber das Objekt `animal` erst einmal über den Zuweisungspfeil `<-` erschaffen.

```{r}
animal <- c("dog", "cat", "fox")
animal
```

Sollte es das Objekt `animal` nicht geben, also nicht über den Zuweisungspfeil `<-` erschaffen worden, dann wird eine Fehlermeldung von R ausgegeben:

`Fehler in eval(expr, envir, enclos) : Objekt 'animal' nicht gefunden`

Das Konzept des Objekts als Speicher für Dinge und der Unterschied zum Wort ist hier etwas sehr abstrakt. Wenn wir aber in R anfangen zu arbeiten wird dir das Konzept klarer werden. Hier müssen wir aber einmal Objekte einführen, damit wir auch etwas in R speichern können und nicht immer wieder neu erschaffen müssen.

## Zusammenfassung

[*Variablennamen* meint hier immer den *Namen der Spalte* im Datensatz bzw. `tibble`]{.aside}

@tbl-skalenniveau zeigt eine Übersicht wie einzelne Variablennamen und deren zugehörigen Beispielen sowie den Namen in R, der Informatik allgemein, als Skalenniveau und welcher Verteilungsfamilie die Variable angehören würde. Leider ist es so, dass wieder gleiche Dinge unterschiedliche benannt werden. Aber an dieses doppelte Benennen können wir uns in der Statistik schon mal gewöhnen.

::: column-page
| Variablenname | Beispiel                    | R         | Infomatik        | Skalenniveau                   | Verteilungsfamilie |
|---------------|-----------------------------|-----------|------------------|--------------------------------|--------------------|
| weight        | 12.3, 12.4, 5.4, 21.3, 13.4 | numeric   | double           | continuous                     | Gaussian           |
| count         | 5, 0, 12, 23, 1, 4, 21      | integer   | integer          | discrete                       | Poisson            |
| dosis         | low, mid, high              | ordered   |                  | categorical / ordinal          | Ordinal            |
| field         | mainz, berlin, kiel         | factor    |                  | categorical                    | Multinomial        |
| cancer        | 0, 1                        | factor    |                  | dichotomous / binary / nominal | Binomial           |
| treatment     | "placebo", "aspirin"        | character | character/string | dichotomous / binary / nominal | Binomial           |
| birth         | 2001-12-02, 2005-05-23      | date      |                  |                                |                    |

: Zusammenfassung und Übersicht von Variablennamen und deren Bennung in R, in der Informatik allgemein, als Skalenniveau und die dazugehörige Verteilungsfamilie. {#tbl-skalenniveau}
:::