R Basics - Programmierung, Datenanalyse und Regression

Ihr lernt was "packages" sind und wie ihr diese installieren und laden könnt.

In dieser Lektion erstellen wir erste Objekte, behandeln Vektoren und unterschiedliche Vektortypen. Ausserdem gehe ich auf "atomic-types" ein. Entweder programmiert Ihr einfach mit oder ihr kopiert den Inhalt der angehängten txt-Datei einfach in ein neues R-Script, welches Ihr in R-Studio erstellt.

In dieser Lektion behandeln wir einfache Indizierung und führen die "c" Funktion ein.

Wir fassen das gelernte kurz zusammen und erstellen Vektoren mit vordefinierter Laenge und Type mit "integer" und "character",  "double", "logical" und "vector".

Wir erstellen nun Sequenzen mit ":" ,"seq" und "rep" und damit Vektoren unterschiedlicher Laenge.

Wir behandeln mathematische und logische Operatoren. 

Nun erklaeren wir die unterschiedlichen Moeglichkeiten um Vektoren zu indizieren.

Wir besprechen nun die Umwandlung von Vektortypen u.a. mit den "as.xxx" Funktionen.

Nun behandeln wir die Grundeigenschaften einer Matrix und führen einige nützliche Funktionen, wie "rbind" und "cbind" ein.

Wie greifen nun auf Elemente einer Matrix zu. Wir arbeiten mit "[]".

Wir lernen, wie wir auf Elemente einer Matrix mit logischen Vektoren zugreifen können.

Wir führen die Funktionen "rowSums", "colSums", "min", "max" und "summary" ein.

Faktoren sind spezielle Vektoren, die ein u.a. ein "levels" Attribut besitzen.

Wir behandeln die Struktur eines Faktors.

Wir beginnen nun mit Data Frames. Ihr lernt die Erstellung eines Data Frames mit der "data.frame" Funktion. Wir führen ausserdem die "subset" Funktion ein und demonstrieren das Verhalten der "[]" Funktion.

Auf Spalten eines Data Frames koennen wir mit dem "$" - Operator zugreifen.

In dieser Lektion lernen wir, wie wir Zeilen und Spalten zu einem Data Frame hinzufügen koennen.

Listen werden mit der "list" Funktion erstellt und sind der "komplexeste" Objekttyp in R.

For und While Schleifen werden nun eingeführt. Ihr lernt, auf welche Fallstricke ihr bei For-Schleifen achten muesst.

For-Schleifen koennen als Laufvariable auch andere Vektortypen haben. Ausserdem behandeln wir geschachtelte Schleifen und wie ihr diese vermeiden könntet.

Wie führen nun if else Ausdruecke ein und demonstrieren das Verhalten für Vektoren einer Laenge > 1

Die ifelse-Funktion ist die Vektorvariante von if else.

Wir vertiefen die ifelse-Funktion und werden die Anwendung in Data Frames verdeutlichen.  Ausserdem zeige ich euch unterschiedliche Moeglichkeiten um eine Spalte zu einem Data Frame mit einer Bedingung hinzuzufügen.

Die "apply"-Funktion kann eine for-loop in Matrizen ersetzen.

Nun werden wir eine selbst definierte Funktion nutzen um Berechnung auf einer Matrix durchzuführen.

"lapply" ist Teil der "apply" - Familie. Wir behandeln mit "lapply" vor allem Listen.

"sapply" ist Teil der "apply"- Familie, es gibt Unterschiede zu "lapply", die wir hier behandeln.

"tapply" ist ebenfalls Teil der "apply" Familie. Wir stellen hier eine Anwendungsmöglichkeit der Funktion vor.

Dies ist der Start der Funktions-Reihe. Funktionen sind essentiell um guten und organisierten Code zu schreiben. Wir nutzen die "function" Funktion.

Wir arbeiten weiter an der "FSquare" Funktion.

Wir üben nun das "debuggen" einer Funktion.

Wir bearbeiten ein letztes mal die "FSquare" Funktion. Wir nutzen die "which" Funktion um Indizes zurückzugeben.

Wir übergeben einer Funktion nun zwei Argumente. Einem Argument wird bereits in der Funktionsdefnition ein Wert übergeben.

Wir schreiben eine einfache Funktion und lernen die "missing" Funktion kennen.

Wir übergeben einer Funktion eine Funktion als Argument und nutzen "match.fun".

Wie schreiben wir eine Funktionen, die mehrfache Objekte zurückgeben soll?

Ihr lernt das Plotten mit der "plot" Funktion, welches aus einem Basis-Paket ("graphics") stammt.

Wir lernen nun die "par" Funktion kennen, mit der ihr graphische Parameter setzen könnt.

Wir plotten den iris-Datensatz um die unterschiedlichen Eigenschaften der Spezies darzustellen.

Wir plotten den "orange" Datensatz als Linien-Plot. Wir arbeiten mit vielen nützlichen Plot-Funktionen, wie "xaxis".

Nun lernt ihr, wie ihr zu dem leeren Plot Linien hinzufügen könnt. Wir nutzen ausserdem die "split" Funktion.

Wir manipulieren nun Strings. Ihr lernt grundlegende String-Operationen.

Ihr lernt nun, wie ihr aus einem character string ein Datum mit "as.Date" macht.

Wir führen die "strptime" Funktion ein, um aus einem character Vektor ein "DateTime"-Objekt zu erzeugen.

Ihr lernt nun den Unterschied zwischen "POSIXlt" und "POSIXct" Objekten

Wir behandeln in dieser Lektion die Formatierung eines "DateTime" Objektes.

Wir nutzen die "class" Funktion  um die Klasse eines Objektes abzurufen. Ausserdem demonstrieren wir, wie Funktionen auf Objekte unterschiedlicher Klassen reagieren.

Übersicht über die verschiedenen Datentypen in R.

Wir behandeln die "attributes" Funktion.

Wir nutzen die "read.table" Funktion um Daten einzulesen und "write.table" um Daten in eine Datei zu schreiben.

Ich demonstriere euch nun einen Workflow, um grosse Dateien einzulesen und verhindere das Speichern von "rownames".

Wir nutzen die "combn" Funktion und "expand.grid" Funktionen um Kombinationen auszurechnen.

Ihr lernt, wie ihr Unterschiede in Vektoren berechnet und ausgebt. Wir nutzen "setdiff", "intersect", "%in%" und "unique".

"do.call" ist eine hilfreiche Funktion, die einen etwas anderen Funktionsaufruf implementiert.

Wir erstellen nun aus der "txt" Datei ein ".rmarkdown" - Dokument. Ihr solltet rmarkdown bereits installiert haben. Falls nicht, zeige ich euch, wie ihr das package installiert.

Erläuterungen der Übungsaufgaben.

Ich zeige euch, wie ihr die Lösungen als html Datei ausgeben könnt. Die txt Datei befindet sich im Anhang.

Wir besprechen nun die Lösungen zu den Übungsaufgaben.

Wir lernen die Erstellung eines "tibbles", der grundlegenden Datenstruktur des "tidyverse".

Wir wandeln ein "data.frame" Objekt in ein "tibble" Objekt um und greifen auf Elemente eines tibbles zu.

Wir nutzen "add_column" und "add_row" um zu einem tibble eine neue Spalte, bzw. Zeile hinzuzufügen.

Wir definieren "tidy data" und beginnen mit dem "tidyr" package des tidyverse. Wir nutzen die "gather" & "spread"

Nun nutzen wir "separate" und "unite"  des tidyr packages.

Wir nutzen nun das "dpylr" package, welches das zentrale package des "tidyverse" ist. In den folgenden Lektionen behandeln wir "dplyr" im Detail. Wir betrachten den "diamonds" Datensatz des "ggplot2" packages.

Ihr lernt nun den Umgang mit der "mutate" Funktion und wir führen "group_by"  und "summarise" ein.

Wir arbeiten mit dem "who" Datensatz um die bisher gelernten Funktionen zu vertiefen.

Erläuterung des "who" Beispiels.

Wir beginnen mit dem "ggplot2" package des "tidyverse" und erstellen erste Plots.

Ihr lernt den Unterschied zwischen "xlim", "ylim" und "coord_cartesian(xlim, ylim)"

Ihr lernt in diesem Video, wie ihr Punkte in Abhängigkeit von einer Variablen farblich kodiert.

Ihr lernt den Umgang mit "scale_" Funktionen um die x- und y-Achse zu definieren

Wir behandeln die "facet" Funktionen um weitere Informationen in einem Plot darzustellen.

Wir vertiefen die eingeführten "facet_grid" Funktion.

Wir vertiefen die "facet_wrap" Funktion und nutzen die "theme" Funktion, um die x-Achse zu rotieren.

Ihr installiert den "gapminder" Datensatz, den wir in folgenden Lektionen nutzen werden.

Ihr lernt "geom_line" kennen, um Daten darzustellen. Wir nutzen den "gapminder" Datensatz aus dem "gapminder" package.

Wir führen Barplots & Boxplots ein.

Ihr lernt, wie ihr Histogramme und Density-Plots erstellt.

Wir lernen nun die grundlegenden Join-Typen, um Daten aus unterschiedlichen Tabellen zu kombinieren. Bitte erstellt die Objekte aus dem Skript, das sich im Anhang befindet.

Wir führen die "inner_join", "left_join", "right_join" Funktionen ein

Wir nutzen "full_join" und "anti_join".

Wir vertauschen x und y um den Einfluss der Reihenfolge in "Joins" zu verdeutlichen.

Wir fügen eine Zeile zu einem tibble hinzu und führen nochmals die Joins durch.

Wir beginnen mit dem "data.table" package, welches sehr interessante und wichtige Features bietet.

Ihr lernt nun, wie Ihr Variablen zu einem "data.table" hinzufügen könnt.

Wir nutzen nun die ".N" und ".SD" und ".SDcols" Funktionen.

Nun berechnen wir die Zeilen und die Summen pro Gruppe.

Wir lernen die ".I"  Funktion kennen.

Ihr lernt den richtigen Umgang mit der "set" Familie.

Wir nutzen die "set" Funktion in einer for-Schleife.

Wir ersetzen jetzt fehlende Werte in einem "data.table" Objekt

Ihr lernt nun die grundlegende Join-Typen mit "data.table" im Vergleich zu "dplyr".

Wir setzen einen key mit "setkey" und führen Joins durch.

Ich stelle euch nun das data.table Equivalent zu tidyr "gather" & "spread" vor.

Wir nutzen "tstrsplit" um Spalten auf Variablen aufzuteilen und "paste" um Spalten zusammenzuführen.

Wir nutzen die "fread" & "fwrite" Funktion um Daten einzulesen und zu speichern. Wir prüfen ausserdem mit "file.exist", ob eine Datei in einem Ordner existiert.

Wir führen eine Fallstudie mit dem Ames Housing Datensatz durch. Wir arbeiten in RMarkdown.

Explorative Datenanalyse des Datensatzes.

Erläuterung der selbstgeschriebenen Funktionen "CheckNA" und "PlotFunc".

EDA der Faktorvariablen und Einführung in Near Zero Variance.

Wir laden eine excel-Datei herunter und nutzen dafür "httr". Ausserdem lesen wir eine excel-Datei aus einer temporären Datei mit "readxl" ein.

Ich demonstriere euch am gapminder Datensatz einen Unterschied zwischen dplyr und data.table.

Wir plotten den gapminder Datensatz mit plotly.

Ihr lernt wie ihr eine Zufallsstichprobe aus  "gapminder" erstellt und plottet.

Ihr lernt den Umgang mit der "subplot" Funktion um multiple Plots zu generieren.

Wir nutzen nun die "layout"-Funktion um x- und y-Achse zu einem "subplot" hinzuzufügen.

Wir nutzen nun die "plot_geo" Funktion um den Standort von Starbucks-Läden auf eine Karte zu plotten

Wir erstellen eine dynamische Web-App mit dem "shiny" package.

Wir lernen wie das ui- und server-Object verknüpft sind und erstellen eine Tabelle.

Wir ändern den output, den wir der renderTable-Funktion übergeben.

Wir erstellen ein "selectInput" Widget und erlauben dem User damit die Analyse von weiteren Datensätzen.

Wir nutzen "updateSelectInput" in einem observer-Kontext.

Wir analysieren die Warnmeldung und versuchen die Warnung mit einer "if"-Abfrage zu verhindern.

Wir nutzen nun die "eventReactive"-Funktion um mehr Kontrolle über die Abläufe in der App zu gewinnen.

"eventReactive" mit zwei input-Objekten.

Wir nutzen nun die "validate" und "need" Funktionen, um in "render" Funktionen Abfragen durchzuführen.

Wir fügen weitere Element zu der UI hinzu.

Wir schließen Shiny-Apps nun ab. Die Funktionalität des Action Buttons wird implementiert.

Ihr lernt einige Pakete kennen, welche euch den Umgang mit fehlenden Werten (NA) erleichtern. Wir nutzen "naniar", "visdat", "mlbench" und "simputation".

Auflistung einiger Datenquellen, mit denen Ihr eure Fertigkeiten testen könnt.

In diesem kleinen Projekt zeige ich euch, wie Ihr eine kleine Finance-API programmieren könnt. Dies ist die Einführung in das Projekt.

Nun laden wir das quantmod package herunter und importieren Aktienkurse von yahoo finance.

Nun wandeln wir das xts-Objekt in einen tibble um.

Hier stelle ich euch die Funktionen pivot_longer und pivot_wider aus tidyr vor.

Wir erstellen einen candlestick-Plot in plotly

Der bisher geschriebene Code wird in Funktionen definiert.

Wir arbeiten weiter an den Funktionen.

Ich gebe euch eine Einführung in Web-APIs

Mit plumber können wir eine API entwickeln.

Die entwickelte API wird nun (lokal) live geschaltet.

Wir behandeln nun die Notwendigkeit eines serializers.

Die API wird leicht umgeschrieben und die Funktionalität erweitert.

Wir interagieren mit der API und lernen local R jobs kennen.

Ich zeige euch wie Ihr eine API der NASA benutzen könnt, um Bilder des Mars Rovers herunterzuladen

Wir fassen das Projekt zusammen und ich gebe einen Ausblick.

https://www.tidymodels.org/start/

https://r4ds.had.co.nz/introduction.html

https://scikit-learn.org/stable/modules/cross_validation.html

https://dplyr.tidyverse.org/reference/across.html

Geschafft :-)