--- fontsize: 8pt format: beamer: include-in-header: ../PP_Header.tex bibliography: ../PP_Referenzen.bib editor: markdown: wrap: 72 --- # {.plain} \center ```{r, echo = F, out.width = "20%"} knitr::include_graphics("../OvGU_Logo.png") ``` \vspace{1mm} \huge Programmieren für Psychologie \vspace{6mm} \large MSc Umweltpsychologie/Mensch-Technik-Interaktion MSc Klinische Psychologie und Psychotherapie MSc Psychologie \vspace{6mm} \normalsize Joram Soch \| Wintersemester 2026/2027 # {.plain} \vfill \center \huge \textcolor{black}{(3) Arithmetik und Variablen} \vfill # AGENDA {.plain} \large \setstretch{3} \vfill Getting started Arithmetik, Logik und Präzedenz Variablen Datenstrukturen # Arithmetik und Variablen ====================================== {.plain} \AtBeginSection{} \section{Getting started} \large \setstretch{3} \vfill **Getting started** Arithmetik, Logik und Präzedenz Variablen Datenstrukturen # Getting started \setstretch{2.5} \textcolor{darkblue}{Installationen} - Die Programmiersprache [\textcolor{linkblue}{R}](https://cran.r-project.org/) - Die IDE [\textcolor{linkblue}{VSCode}](https://code.visualstudio.com/) - VSCode für R startklar machen (Anleitung [\textcolor{linkblue}{hier}](https://code.visualstudio.com/docs/languages/r)) # Getting started \setstretch{2} \textcolor{darkblue}{Mit VSCode und der R Extension vertraut machen} \vfill ![](Abbildungen/pds_2_VSCode_R_Umgebung.png){width="80%" fig-align="center"} # Getting started \setstretch{1.3} \textcolor{darkblue}{Das Problem mit dem Language Server} \vspace{2mm} \small Die R Extension in VSCode verwendet das R-Paket `languageserver`, um Funktionen wie Code-Vervollständigung, Syntaxprüfung und kontextsensitive Informationen bereitzustellen. Bei der Einrichtung kann es vorkommen, dass der `languageserver` nicht korrekt erkannt oder geladen wird. In diesem Fall empfiehlt es sich, das Paket direkt über die eigenständige R-Konsole zu installieren und die Installation zu überprüfen. \vspace{3mm} \textcolor{darkcyan}{Vorgehen} \vspace{1mm} - Schließen Sie VSCode und andere R-Frontends. - Starten Sie R direkt und öffnen Sie die R-Konsole. - Führen Sie die folgenden Befehle nacheinander aus: \vspace{1mm} ```{r} #| label: language-server-installation #| echo: true #| eval: false install.packages("languageserver") packageVersion("languageserver") find.package("languageserver") library(languageserver) ``` \vspace{2mm} Wenn alle Befehle ohne Fehlermeldung ausgeführt werden, schließen Sie R und starten Sie anschließend VSCode erneut. # Getting started \setstretch{2} \textcolor{darkblue}{Öffnet eine R Console in VS Code} - GUI: *Terminal* $\rightarrow$ *New Terminal* $\rightarrow$ - In die Console hinter das "\$"-Zeichen "`R`" eingeben - Keyboard Shortcut: \fbox{Ctrl} + \fbox{Shift} + \fbox{P} - In das sich öffnende Textfeld "R: Create R Terminal eingeben" \vfill # Getting started \setstretch{2} \textcolor{darkblue}{R Console in VS Code} \vfill ![](Abbildungen/pds_2_R_Console_oeffnen.png){width="80%" fig-align="center"} # R Kommandozeile $\vert$ Working in the Console \setstretch{1.7} \textcolor{darkblue}{Die Basics} \small - Eingabe von R Befehlen bei `>` - Autocomplete mit \fbox{Tab} - Code ausführen mit \fbox{Enter} - Vorherige Befehle mit Cursor \fbox{$\uparrow$} - Code Ausführungsstopp mit \fbox{Ctrl} + \fbox{C} \vspace{2mm} \normalsize \textcolor{darkcyan}{Beispiele für Befehle} \small \setstretch{1.2} ```{r, echo = T, eval = T} #| label: Hello world console print("Hallo Welt!") sum(1:3) ``` \vfill \footnotesize Anmerkung: \color{darkcyan} **Code-Snippets dieser Form immer aktiv in der Konsole nachvollziehen!** # R Funktionen \setstretch{1.1} \small \vspace{2mm} Was sind R Funktionen? \footnotesize \begin{itemize} \footnotesize \justifying \item Funktionen lassen uns etwas ''tun''. \item \texttt{print} und \texttt{sum} sind Beispiele für Funktionen, die etwas ausgeben bzw. aufsummieren. \item Funktionen in R werden mit runden Klammern '()' aufgerufen. In diese Klammern eingeschlossen können einer Funktion eine oder mehrere \textit{Argumente} übergeben werden. \end{itemize} \small Hilfe zu Funktionen \footnotesize \begin{itemize} \footnotesize \justifying \item Der einfachste und zuverlässigste Weg, Hilfe zu Funktionen zu bekommen, ist über die in der lokalen Installation integrierten Dokumentation (Help pages). \item Aufruf über Console mit Fragezeichen '\texttt{?}' gefolgt von dem Namen der Funktion oder mit \texttt{help(funktionsname)}. \item Das Verwenden von zwei Fragezeichen ('\texttt{??}') sucht nach allen Topics, die den Begriff enthalten. \end{itemize} \setstretch{1.0} \tiny ```{r, echo = T, eval = F} ?mean # Öffne die Help page der Funktion "mean" help(mean) # Öffne die Help page der Funktion "mean" ??mean # Suche topics, die den Begriff "mean" enthalten ``` \setstretch{1.1} \begin{itemize} \footnotesize \justifying \item Die Help page jeder Funktion enthält \textbf{Description}, \textbf{Usage}, mögliche \textbf{Arguments}, \textbf{Examples} und viele weitere nützliche Informationen. \item Wie wir später noch sehen werden, gibt es weitere Ausdrücke in R, die keine Funktionen sind. In den meisten solcher Fälle finden wir die entsprechende Help page, indem der Ausdruck in Anführungszeichen gesetzt wird. \end{itemize} \vspace{1mm} \setstretch{1.0} \tiny ```{r, echo = T, eval = F} ?"+" ?"|" ?"if" ``` # VSCode Interactive Viewers \vfill \textcolor{darkblue}{Help Viewer} \vfill ![](Abbildungen/pds_2_R_helpviewer.png){width="70%" fig-align="center"} \setstretch{1.2} \footnotesize Mit dem Befehl `?funktionsname` oder über \fbox{HELP PAGES} links in der R Extension öffnen. Beispiele \footnotesize ```{r, echo = T, eval = F} ?print ?sqrt ``` \tiny \begin{flushright} \textcolor{linkblue}{\href{https://github.com/REditorSupport/vscode-R/wiki/Interactive-viewers}{VS Code Wiki - Interactive viewers}} \end{flushright} # R Skripte $\vert$ Editing and Executing Code \vspace{2mm} \setstretch{1.7} \textcolor{darkblue}{Neue .R Datei erstellen} \vspace{-2mm} \small - GUI: *File* $\rightarrow$ *New File* $\rightarrow$ *R Document (r)* - Keyboard Shortcut: \fbox{Ctrl} + \fbox{N} \normalsize \textcolor{darkblue}{Bestehende .R Datei öffnen} \vspace{-2mm} \small - GUI: File $\rightarrow$ Open File - Keyboard Shortcut: \fbox{Ctrl} + \fbox{O} \normalsize \textcolor{darkblue}{Code in einem R Skript schreiben} (Befehle in Programmiersprache formulieren) \vspace{1mm} \small ```{r, echo = T, eval = T} #| label: Hello World script print("Hallo Welt!") # Hinter Hashtags stehen dokumentierende Kommentare sum(1:3) # Kommentare werden nicht ausgefuehrt ``` \vfill \small Anmerkung: \color{darkcyan} **Code-Snippets dieser Form immer aktiv in einem R Skript dokumentieren!** \vfill # R Skripte $\vert$ Editing and Executing Code \vspace{2mm} \setstretch{1.7} \textcolor{darkblue}{Befehle eines R Skripts ausführen} \normalsize \vspace{-2mm} \small - Befehle an Console schicken: - \small Einzelne Zeile, auf welcher der Cursor ruht: \fbox{Ctrl} + \fbox{Enter} - Ausführen aller Zeilen im Skript: \fbox{Ctrl} + \fbox{Shift} + \fbox{Enter} - Ausführen des gesamten R Skripts (''Source''): - \small GUI: $\triangleright$ - Symbol / Run Source - Keyboard Shortcut: \fbox{Ctrl} + \fbox{Shift} + \fbox{S} - in R Console: ```{r, echo = T, eval = F} source("Pfad/zum/Skript.R") ``` - in bash Console: ```{bash, echo = T, eval = F} Rscript Pfad/zum/Skript.R ``` \vfill # Debugging \vspace{2mm} \setstretch{1.5} \textcolor{darkblue}{Was ist Debugging?} \vspace{2mm} \small **Debugging** bezeichnet den systematischen Prozess, Fehler (*bugs*) in einem Programm zu identifizieren, zu lokalisieren, zu verstehen und zu beheben. \vspace{3mm} Fehler können auf unterschiedlichen Ebenen auftreten: - **Syntaxfehler:** Der Code entspricht nicht den Regeln der Programmiersprache. - **Laufzeitfehler:** Der Code ist syntaktisch korrekt, kann aber nicht erfolgreich ausgeführt werden. - **Logische Fehler:** Der Code wird ausgeführt, liefert aber nicht das beabsichtigte Ergebnis. \vspace{4mm} \textcolor{darkcyan}{Grundprinzip} \small Eine Fehlermeldung ist zunächst keine Katastrophe, sondern eine **diagnostische Information**. Ziel des Debuggings ist es, diese Information systematisch zur Identifikation der Fehlerursache zu nutzen. # Debugging \vspace{2mm} \setstretch{1.4} \textcolor{darkblue}{1. Fehlermeldung lesen} \vspace{2mm} \small Viele Fehler lassen sich unmittelbar aus der Fehlermeldung ableiten. \vspace{2mm} ```{r, echo = T, eval = T, error = TRUE} total_sum <- 42 total_summ ``` \vspace{3mm} \textcolor{darkcyan}{Was ist passiert?} - R findet das Objekt `total_summ` nicht. - Definiert wurde jedoch das Objekt `total_sum`. - Die Ursache ist ein einfacher Tippfehler. \vfill \textcolor{darkcyan}{\textbf{Lesen Sie Fehlermeldungen zunächst selbst und versuchen Sie zu verstehen, was R Ihnen mitteilt.}} # Debugging \vspace{1mm} \setstretch{1.2} \textcolor{darkblue}{2. Fehlermeldung recherchieren} \small Nicht jede Fehlermeldung ist unmittelbar verständlich. \vspace{1mm} ```{r, echo = T, eval = F} y <- c(4.2, 5.1, 4.8, 5.3) gruppe <- factor(c("A", "A", "A", "A")) lm(y ~ gruppe) ``` \footnotesize \textcolor{darkcyan}{Fehlermeldung} ```text Error in `contrasts<-`(`*tmp*`, value = contr.funs[1 + isOF[nn]]) : Kontraste können nur auf Faktoren mit 2 oder mehr Stufen angewendet werden ``` \small \textcolor{darkcyan}{Vorgehen} - Identifizieren Sie den zentralen Teil der Fehlermeldung. - Suchen Sie nach dem möglichst **exakten Wortlaut**. - Prüfen Sie, ob die gefundene Erklärung zu Ihrem Problem passt. \vfill \textcolor{darkcyan}{\textbf{Viele typische R-Fehler sind bereits dokumentiert und diskutiert.}} # Debugging \vspace{1mm} \setstretch{1.15} \textcolor{darkblue}{3. Komplexe Fehler analysieren} \small Bei komplexeren Fehlern müssen häufig Programmcode und mathematische Eigenschaften des Modells gemeinsam betrachtet werden. \vspace{1mm} ```{r, echo = T, eval = F} x <- 1:8 y <- exp(0.2 * x) fit <- nls( y ~ a * exp(b * x) + c * exp(b * x), start = list(a = 1, b = 0.2, c = 1) ) ``` \footnotesize \textcolor{darkcyan}{Fehlermeldung} ```text Error in nlsModel(...): singuläre Gradientenmatrix bei der ersten Parameterschätzung ``` \small \textcolor{darkcyan}{Hier liegt kein einfacher Syntaxfehler vor:} - `a` und `c` treten nur als Summe `a + c` auf und sind daher nicht getrennt identifizierbar. - Die entsprechenden Informationen in der Gradientenmatrix sind linear abhängig. \vspace{1mm} \textcolor{darkcyan}{\large\textbf{$\Rightarrow$ Trauen Sie sich, eine KI zu fragen.}} \footnotesize Wichtig: Fehlermeldung + relevanten Code + Beschreibung des beabsichtigten Ergebnisses mitgeben. # R Skripte $\vert$ Editing and Executing Code \vspace{2mm} \setstretch{1.5} \textcolor{darkblue}{Tipps für ein strukturiertes und übersichtliches R Skript} \small \begin{itemize} \item Beginnen Sie ein R Skript mit einem \textbf{Header}, welche die wichtigsten Informationen zu dem vorliegenden Programm enthält. \item Achten Sie darauf, möglichst jeden Befehl mit einem \textbf{Kommentar} zu versehen, sodass leicht nachvollzogen werden kann, was in jeder Zeile passiert. \end{itemize} \vfill \footnotesize \setstretch{1.2} ```{r, echo = T, eval = T} # Dieses Skript gibt den Text "Hallo Welt!" aus und bildet die Summe der Zahlen von 1 bis 3. # --------------------------- # Seminar: Vorkurs: Programmieren für Psychologie - WiSe 26/27 # Datum: 06-10-2026 # Autor: Domenic Groh print("Hallo Welt!") # Ausgabe des Texts "Hallo Welt!" sum(1:3) # Summe der Zahlen von 1 bis 3 ``` \vfill # R Skripte $\vert$ Editing and Executing Code \vspace{2mm} \setstretch{1.5} \textcolor{darkblue}{Linting} \vspace{2mm} \small **Linting** bezeichnet die automatische, statische Analyse von Quellcode. Der Code wird dabei auf mögliche Probleme untersucht, ohne ausgeführt zu werden. \vspace{3mm} Linting kann beispielsweise auf - mögliche Programmierfehler, - problematische oder uneindeutige Ausdrücke und - Abweichungen von Stilregeln hinweisen. \vfill \textcolor{darkcyan}{\textbf{Linting unterstützt dabei, Probleme frühzeitig zu erkennen und Code konsistent zu halten.}} # R Skripte $\vert$ Editing and Executing Code \vspace{2mm} \setstretch{1.5} \textcolor{darkblue}{Linting in VSCode} \vspace{2mm} \small - Hinweise und Warnungen werden direkt im Editor markiert. - Eine Übersicht aller gefundenen Probleme findet sich unter *View* $\rightarrow$ *Problems*. \vspace{3mm} \textcolor{black}{Problems öffnen} \vspace{1mm} - Windows/Linux: \fbox{\scriptsize Ctrl} + \fbox{\scriptsize Shift} + \fbox{\scriptsize M} - macOS: \fbox{\scriptsize Cmd} + \fbox{\scriptsize Shift} + \fbox{\scriptsize M} \vspace{3mm} \textcolor{black}{Zwischen Problemen wechseln} \vspace{1mm} - nächstes Problem: \fbox{\scriptsize F8} - vorheriges Problem: \fbox{\scriptsize Shift} + \fbox{\scriptsize F8} \vfill # R Pakete \setstretch{1.4} \vfill \textcolor{darkblue}{Das Prinzip} \small \begin{itemize} \justifying \item Ein R Paket ist eine Sammlung von R-Funktionen, Datensätzen und vordefinierten Skripten, die in einem strukturierten Format (Paket) gebündelt sind. \item Analog zu Computerprogrammen (wie MS Word) müssen R Pakete zuerst auf dem Rechner \textbf{installiert} werden, bevor sie verwendet werden können. Ausnahmen sind Standardpakete (\texttt{standard library}), die automatisch mit der Installation von R mitgeliefert werden. \item Wie Computerprogramme müssen R Pakete auch \underline{nur \textit{einmal}} installiert werden. Deshalb empfiehlt es sich, Paketinstallationsbefehle aus Skripten auszukommentieren. \item Analog dazu, dass Computerprogramme bei jedem Neustart zuerst \textit{geöffnet} werden müssen, bevor damit gearbeitet werden kann, müssen R Pakete bei jeder neuen R Sitzung zuerst in die Workspace \textbf{geladen} werden, bevor damit gearbeitet werden kann. \end{itemize} \vfill # R Pakete \setstretch{1.3} \vfill \textcolor{darkblue}{Paket-Management} \begin{itemize} \small \item Anzeigen aller installierter Pakete in der R Extension: \textit{HELP PAGES} $\to$ \textit{Home} $\to$ \textit{Packages} oder mit dem R Befehl \texttt{installed.packages()}. \item Das \textbf{Installieren} eines Pakets erfolgt mit dem R Befehl \texttt{install.packages("\text{paketname}")}. Da das Paket vor Installation noch nicht auf dem System existiert, wird der Paketname als string, d.h. \textbf{mit Anführungsstrichen} an die Funktion übergeben. \item Das \textbf{Laden} eines Pakets erfolgt mit dem R Befehl \texttt{library(paketname)}. Da das Paket nach Installation auf dem System existiert und referenziert werden kann, wird der Paketname als Variable, d.h. \textbf{ohne Anführungsstriche} an die Funktion übergeben. \item Tipp: Integrieren Sie das Paket-Management in Ihr R Skript. \begin{itemize} \small \item Wenn in einem Datenanalyseskript Pakete außerhalb der `standard library` verwendet werden, sollte das Laden des Pakets auch ein Befehl im Analyseskript sein. \item Das gilt \textbf{nicht} für Installationsbefehle (\texttt{install.packages()})! Die Installation von Paketen ist \textbf{nur einmal} notwendig. Falls Installationsbefehle im Skript stehen, sollten sie auskommentiert werden, da sie sonst unnötig Zeit und Rechenressourcen kosten. \item Laden Sie alle benötigten Pakete zu Beginn des Skripts und halten Sie in einem Kommentar fest, wofür es benötigt wird. \end{itemize} \end{itemize} \vfill # R Skripte \vspace{2mm} \setstretch{1.5} \textcolor{darkblue}{Beispiel eines strukturierten R Skripts, das zusätzliche Pakete verwendet} \vfill \footnotesize \setstretch{1.2} ```{r, echo = T, eval = T} # Dieses Skript erstellt eine character Variable und gibt deren Wert und Speicheradresse aus. # --------------------------- # Seminar: Vorkurs: Programmieren für Psychologie - WiSe 26/27 # Datum: 06-10-2026 # Autor: Domenic Groh # --- Paketemanagement ------ # install.packages("lobstr") # Installation des Pakets "lobstr" library(lobstr) # Laden des Pakets lobstr; für obj_addr() # --- Variablendefinition --- Ausgabetext <- "Hallo Welt!" # Definition der Variable 'Ausgabetext' # --- Ausgabe --------------- print(Ausgabetext) # Ausgabe der Variabe 'Ausgabetext' obj_addr(Ausgabetext) # Ausgabe der Speicheradresse der Variable 'Ausgabetext' ``` \vfill # Arithmetik, Logik und Präzedenz ================== {.plain} \AtBeginSection{} \section{Arithmetik, Logik und Präzedenz} \setstretch{3} \large \vfill Getting started **Arithmetik, Logik und Präzedenz** Variablen Datenstrukturen # R Konsole als Taschenrechner \footnotesize \vfill \setstretch{0.7} ```{r, echo = T, eval = T} #| label: addition 1 + 1 ``` \vspace{4mm} ```{r, echo = T, eval = T} #| label: multiplikation 2 * 3 ``` \vspace{4mm} ```{r, echo = T, eval = T} #| label: sqrt sqrt(4) ``` \vspace{4mm} ```{r, echo = T, eval = T} #| label: exp-funk exp(0) ``` \vspace{4mm} ```{r, echo = T, eval = T} #| label: log-funk log(1) ``` \vfill Anmerkungen: \begin{itemize} \item $[1]$ zeigt das erste und einzige Element des Ausgabevektors an \item Vektoren werden noch im Detail behandelt. \end{itemize} # Arithmetische Operatoren \setstretch{1.6} \vfill \small \begin{center} \begin{tabular}{l|l} Operator & Bedeutung \\ \hline $+$ & Addition \\ $-$ & Subtraktion \\ $*$ & Multiplikation \\ $/$ & Division \\ \^{} oder $**$ & Potenz \\ \%$*$\% & Matrixmultiplikation \\ \%$/$\% & Ganzzahlige Teilung (5\%$/$\%2 = 2) \\ \%\% & Modulo (5\%\%2 = 1) \\ \end{tabular} \end{center} \vfill - Matrixmultiplikation, Modulo, ganzzahlige Teilung benötigen wir zunächst nicht. - Ganzzahlige Teilung gibt das Resultat der ganzzahligen Teilung an. - Modulo gibt den ganzzahligen Rest bei ganzzahliger Teilung an. # Logische Operatoren \setstretch{1.6} \small - Die Boolesche Algebra und R kennen zwei *logische Werte*: TRUE und FALSE - Bei Auswertung von Relationsoperatoren ergeben sich logische Werte \begin{center} \begin{tabular}{l|l} Relationsoperator & Bedeutung \\ \hline $==$ & Gleich \\ $!=$ & Ungleich \\ $<$, $>$ & Kleiner, Größer \\ $<=$, $>=$ & Kleiner gleich, Größer gleich \\ $\vert$ & ODER \\ $\&$ & UND \\ \end{tabular} \end{center} \vfill - $<,<=,>,>=$ werden zumeist auf numerische Werte angewendet. - $==,!=$ werden zumeist auf beliebige Datenstrukturen angewendet. - $\vert$ und $\&$ werden zumeist auf logische Werte angewendet. - $\vert$ implementiert das inklusive *oder*. Die Funktion xor() implementiert das exklusive ODER. # Mathematische Funktionen \setstretch{1.4} \small \begin{center} \begin{tabular}{l|l} Aufruf & Bedeutung \\ \hline abs(x) & Betrag \\ sqrt(x) & Wurzel \\ ceiling(x) & Aufrunden (ceiling(2.7) = 3) \\ floor(x) & Abrunden (floor(2.7) = 2) \\ round(x) & Mathematisches Runden (round(2.5) = 2) \\ exp(x) & Exponentialfunktion \\ log(x) & Logarithmus Funktion \\ \end{tabular} \end{center} \vfill - Hierbei handelt es sich um eine Auswahl. Einen vollständigen Überblick gibt \footnotesize ```{r, echo = T, eval = F} #| label: BasicFunsList names(methods:::.BasicFunsList) ``` - \small R unterscheidet formal nicht zwischen Operatoren und Funktionen - Operatoren können mit der Infix Notation als Funktionen genutzt werden \footnotesize ```{r, echo = T, eval = T} #| label: Infixnotation `+`(2,3) # Infixnotation für 2 + 3 ``` # Operatorpräzedenz (Operatorrangfolge) \setstretch{2.2} \small - Regeln der Form "Punktrechnung geht vor Strichrechnung". - Vordefinierte Operatorpräzedenz kann durch Klammern überschrieben werden. \setstretch{0.7} ```{r, echo = T, eval = T} #| label: Praezedenz 2 * 3 + 4 2 * (3 + 4) ``` \begin{itemize} \item Generelle Empfehlung: \setstretch{1.7} \begin{itemize} \item \small Operatorrangfolge nicht raten oder folgern, sondern nachschlagen. \item Lieber Klammern setzen als keine Klammern setzen. \item Immer nachschauen, ob Berechnungen die erwarteten Ergebnisse liefern. \end{itemize} \end{itemize} # Präzedenz und Syntax nachschlagen \vfill \footnotesize ```{r, echo = T, eval = F} #| label: Operatorpräzedenz nachschlagen ?Syntax # öffnet R Help Fenster ``` \vfill ![](Abbildungen/pds_2_precedence.pdf){width="68%"} # Präzedenz und Ausführungsreihenfolge arithmetischer Operatoren \setstretch{2.2} \small \begin{center} \begin{tabular}{l|l} Operator & Reihenfolge \\ \hline \^{} & Rechts nach links \\ $-$x,$+$x & Unitäres Vorzeichen, links nach rechts \\ $*$, $/$ & Links nach Rechts \\ $+$, $-$ & Links nach Rechts \\ \end{tabular} \end{center} \color{darkcyan} Beispiele \setstretch{1.7} \footnotesize ```{r, echo = T, eval = F} #| label: Taschenrechnerbeispiele 2^2^3 # 2^(2^3) = 2^8 = 256 (2^2)^3 # (2^2)^3 = 4^3 = 64 -1^2 # -(1^2) = -1 (-1)^2 # (-1)^2 = 1 2+3/4*5 # 2+(3/4)*5 = 2+(0.75*5) = 2+3.75 = 5.75 2+3/(4*5) # 2+3/(4*5) = 2+3/20 = 2+0.15 = 2.15 ``` # Variablen ======================================= {.plain} \AtBeginSection{} \section{Variablen} \setstretch{3} \large \vfill Getting started Arithmetik, Logik und Präzedenz **Variablen** Datenstrukturen # Definition \vfill \setstretch{1.7} \justifying In der Programmierung ist eine Variable ein abstrakter Behälter für eine Größe, welche im Verlauf eines Rechenprozesses auftritt. Im Normalfall wird eine Variable im Quelltext durch einen Namen bezeichnet und hat eine Adresse im Speicher einer Maschine. Der durch eine Variable repräsentierte Wert kann – im Unterschied zu einer Konstante – zur Laufzeit des Rechenprozesses verändert werden. \begin{flushright} Quelle: \textit{Wikipedia} \end{flushright} # Grundlagen \small \setstretch {1.7} - Variablen sind vom Programmierenden benannte Platzhalter für Werte. - In 3GL Sprachen wird der Variablentyp durch eine Initialisierungsanweisung festgelegt: ```{r, echo = T, eval = F} #| label: Initiierung in 3GL VAR A : INTEGER # A ist eine Variable vom Typ Integer (ganze Zahl) ``` - In 3GL Sprachen wird Variablen durch eine Zuweisungsanweisung ein Wert zugeschrieben: ```{r, echo = T, eval = F} #| label: Zuweisung in 3GL A := 1 # Der Variable A wird der numerische Wert 1 zugewiesen ``` - In 4GL Sprachen wie Matlab, Python, R werden Variablen durch Zuweisung initialisiert: ```{r, echo = T, eval = F} #| label: Variablendefinition in 4GL a = 1 # a ist eine Variable vom Typ double, ihr Wert ist 1 ``` - Der Zuweisungsbefehl in Matlab und Python ist `=`, der Zuweisungsbefehl in R ist `<-` oder `=`. - Offiziell empfohlen für R ist `<-`. ```{r, echo = T, eval = F} #| label: Variablendefinition in R a <- 1 # a ist eine Variable vom Typ double, ihr Wert ist 1 a = 1 # a ist eine Variable vom Typ double, ihr Wert ist 1 ``` # \textcolor{darkcyan}{Beispiel} \footnotesize \justifying \textcolor{darkcyan}{Greta geht ins Schreibwarengeschäft und kauft vier Hefte, zwei Stifte und einen Füller. Wie viele analoge Gegenstände kauft Greta insgesamt?} Wir definieren zunächst alle Variablen: \vspace{1mm} ```{r, echo = T, eval = T} #| label: Defnitionen hefte <- 4 # Definition der Variable 'hefte' und Wertzuweisung 4 stifte <- 2 # Definition der Variable 'stifte' und Wertzuweisung 2 fueller <- 1 # Definition der Variable 'fueller' und Wertzuweisung 1 ``` Nach Zuweisung existieren die Variablen im Arbeitsspeicher, dem sogenannten \textit{Workspace}. Die Variablen können jetzt wie Zahlen in Berechnungen genutzt werden \vspace{1mm} ```{r, echo = T, eval = T} #| label: Berechnung Anzahl Gegenstände gesamt <- hefte + stifte + fueller # Berechnung der Gegenstandsanzahl print(gesamt) ``` Ein Heft kostet einen Euro, ein Stift kostet zwei Euro, und ein Füller kostet 10 Euro. Wie viel Euro muss Greta insgesamt bezahlen? \vspace{1mm} ```{r, echo = T, eval = T} #| label: Berechnung Preis gesamtpreis <- hefte * 1 + stifte * 2 + fueller * 10 # Berechung des Preises print(gesamtpreis) ``` `print()` gibt Variablenwerte in der R Konsole aus. # Workspace \setstretch{1.7} \vfill ```{r, echo = F, eval = T} rm(has_annotations) rm(pandoc_dir) rm(quarto_bin_path) ``` \textcolor{darkblue}{Der Workspace | (globaler) Arbeitsbereich} \small - Enthält alle aktuell definierten Objekte, Variablen und Funktionen während einer R-Sitzung. - Nach Zuweisung werden Variablen automatisch im Workspace gespeichert. - Ausgabe aller existierenden benutzbaren Variablen im Arbeitsspeicher in der Konsole. \footnotesize ```{r, eval = T} #| label: Ausgabe aller Variablen im workspace ls() # Anzeigen aller Variablennamen im aktuellen Workspace ``` \normalsize \textcolor{darkblue}{Löschen von Variablen} \small - Löschen bestimmter Variablen \setstretch{0.9} \footnotesize ```{r, eval = T} #| label: Löschen bestimmer Variablen rm(gesamtpreis) # Löschen der Variable Gesamtpreis ls() ``` - \small Löschen aller Variablen im Workspace \footnotesize ```{r, eval = T} #| label: Löschen aller Variablen rm(list = ls()) # Löschen aller Variablen ls() ``` # Workspace \vfill \small In VSCode kann der Workspace in der `R Extension pane` angezeigt werden \vfill ![](Abbildungen/pds_2_vscode_workspace.pdf){width="60%"} # Variablennamen \setstretch{1.6} \vfill \normalsize \textcolor{darkblue}{Zulässige Variablennamen} \small - bestehen aus Buchstaben, Zahlen, Punkten (.) und Unterstrichen (\_). - beginnen mit einem Buchstaben oder . nicht gefolgt von einer Zahl. - dürfen keine *reserverd words* wie \textcolor{blue}{for}, \textcolor{blue}{if}, \textcolor{blue}{NaN}, usw. sein (siehe `?reserved`). - werden unter `?make.names()` beschrieben. \vspace{1mm} \normalsize \textcolor{darkblue}{Sinnvolle Variablennamen} \small - sind kurz ($\approx$ 1 bis 9 Zeichen) und \textcolor{darkcyan}{aussagekräftig}. - bestehen nur aus Kleinbuchstaben und Unterstrichen. \vfill \footnotesize Anmerkung - R ist *case-sensitive*. Das heißt z.B. x $\neq$ X # Variablenrepräsentation $\vert$ Binding \vspace{3mm} \footnotesize ```{r, echo = T, eval = F} #| label: Wertzuweisung x x <- 1 ``` \setstretch{0.8} \begin{itemize} \item Intuitiv wird eine Variable genannt x mit dem Wert 1 erzeugt. \item De-facto geschehen zwei Dinge: \begin{enumerate} \footnotesize \item R erzeugt ein Objekt (Vektor mit Wert 1) mit Speicheradresse `0x1d888c1a800`. \item R verbindet dieses Objekt mit dem Namen x, der das Objekt im Speicher referenziert. \end{enumerate} \end{itemize} ![](Abbildungen/pds_2_binding_1.pdf){width="22%"} \vspace{2mm} ```{r, echo = T, eval = F} #| label: binding y to x y <- x ``` \begin{itemize} \item Intuitiv wird eine Variable genannt y mit Wert gleich dem Wert von x erzeugt. \item De-facto wird ein neuer Name y erzeugt, der dasselbe Objekt referenziert wie x. \item Das Objekt (Vektor mit Wert 1) wird nicht kopiert, R spart Arbeitsspeicher. \end{itemize} ```{r, echo = T, eval = F} #| label: binding y new y <- 1 ``` \begin{itemize} \item R erzeugt ein \textit{neues} Objekt (Vektor mit Wert 1) mit \textit{eigener} Speicheradresse `0x1da21b17843`. \item De-facto wird ein neuer Name y erzeugt, der ein anderes Objekt referenziert wie x. \end{itemize} ![](Abbildungen/pds_2_binding_2.pdf){width="44%"} \vspace{1mm} # Speicheradressen $\vert$ object adress \setstretch{1.2} \vspace{3mm} \footnotesize - Speicheraddressen können mit der Funktion `lobstr::obj_addr()` angezeigt werden. \tiny ```{r, echo = T, eval = T} #| label: lobstr library(lobstr) # Paket `lobstr` laden x <- 1 obj_addr(x) ``` - \footnotesize y bekommt die Zuweisung x. De-facto refenziert y dieselbe Speicheradresse wie x. \tiny ```{r, echo = T, eval = T} #| label: obj adress y = x y <- x obj_addr(y) ``` - \footnotesize y bekommt die Zuweisung zu einem neuen Objekt (Vektor mit Wert 1). De-facto referenziert y eine andere Speicheradresse wie x. \tiny ```{r, echo = T, eval = T} #| label: obj adress y !=x y <- 1 obj_addr(x) obj_addr(y) ``` \vfill \footnotesize Anmerkungen: - \justifying Ausdrücke der Art `lobstr::obj_addr()` referieren eine Funktion, hier `obj_addr()`, bei gleichzeitiger Angabe des Pakets, hier `lobbstr`. - Bevor Funktionen eines Pakets verwendet werden können, muss es mit `library()` geladen werden. Ausnahmen sind R Standartpakete, die per default geladen werden, z.B. `base` oder `stats`. # Variablenrepräsentation $\vert$ Copy-on-modify \vspace{2mm} \footnotesize ```{r, echo = F, eval = T} #| label: load lobstr library(lobstr) ``` ```{r, echo = T, eval = T} #| label: copy-on-modify x <- 1 # Objekt (0x74b) erzeugt, x referenziert Speicheradresse des Objektes y <- x # Der Variable y wird der selbe Wert wie x zugewiesen obj_addr(y) == obj_addr(x) # Zeigt, dass y dieselbe Speicheradresse (0x74b) wie x referenziert y <- 3 # y modifiziert, modifizierte Kopie (0xcd2) wird gespeichert obj_addr(y) == obj_addr(x) # y und x referenzieren jetzt unterschiedliche Speicheradressen y <- 1 # Auch wenn der Wert der Zuweisung gleich ist... obj_addr(y) == obj_addr(x) # ...referenzieren y und x nicht die selbe Adresse ``` ![](Abbildungen/pds_2_copy_on_modify_1.pdf){width="70%"} - R Objekte sind \textit{immutable}, können also nicht verändert werden. - Bei Modifizierung der Variable \texttt{y} wird das \textquote{Original}-Objekt (0x74b) nicht verändert, sondern eine Kopie (0xcd2) erstellt, welche dann verändert wird. # Variablenrepräsentation $\vert$ Modifications-in-place \vspace{2mm} \small Zur Immutability gibt allerdings zwei Ausnahmen, genannt \textit{Modifications-in-place} 1. Objekte mit nur einem gebundenem Namen werden in-place modifiziert \footnotesize ```{r, echo = T, echo = F} #| label: modifications-in-place x <- c(1,2) # Objekt (0x74b) erzeugt, x referenziert Speicheradresse des Objektes x[1] <- 2 # Objekt (0x74b) veraendert ``` - \footnotesize Dieses Verhalten ist allerdings nur in R, nicht innerhalb VSCode reproduzierbar. 2. \small Environments werden in-place modifiziert. \vfill # Variablenrepräsentation $\vert$ Copy-on-modify \small \setstretch{1.5} Copy-on-modify gilt auch in umgekehrter Reihenfolge \footnotesize ```{r, echo = T, eval = T} #| label: binding umgekehrt x <- 1 # Objekt (0x74b) erzeugt, x referenziert Speicheradresse des Objektes y <- x # Zuweisung y zu gleicher Speicherzelle wie x obj_addr(y) == obj_addr(x) # zeigt, dass y dieselbe Speicheradresse wie x (0x74b) referenziert. x <- 3 # Ein neues Objekt mit Wert 3 wird in Speicherzelle (0x2a08) erzeugt. # x referenziert jetzt Objelkt (0x2a08) # y referenziert weiterhin Objekt (0x74b) obj_addr(y) == obj_addr(x) # zeigt, dass y und x nicht mehr dieselbe Speicherzelle addressieren. ``` ![](Abbildungen/pds_2_copy_on_modify_2.pdf){width="70%"} # Variablenrepräsentation $\vert$ Unbinding und Garbage Collection \setstretch{1.8} \textcolor{darkblue}{Unbinding} \small ```{r, echo = T, echo = F} #| label: unbinding x <- 1 # x referenziert Objekt (0x74b) x <- "a" # x referenziert Objekt (0x2a08), Objekt (0x74b) jetzt ohne Referenz ``` ![](Abbildungen/pds_2_unbinding.pdf){width="70%"} \vspace{2mm} \normalsize \textcolor{darkblue}{Garbage collection} \small - Nicht referenzierte Objekte im Arbeitsspeicher werden automatisch gelöscht. - Das Löschen geschieht meist erst dann, wenn es wirklich nötig ist. - Es ist nicht nötig, aktiv die Garbage Collection Funktion `gc()` zu benutzen. \vfill # Datenstrukturen ======================================= {.plain} \AtBeginSection{} \section{Datenstrukturen} \setstretch{3} \large \vfill Getting started Arithmetik, Logik und Präzedenz Variablen **Datenstrukturen** # Klassische Datenstrukturen einer 3GL Programmiersprache \textcolor{darkblue}{Fundamentale Datenstrukturen} \small - Vordefiniert innerhalb der Programmiersprache - Logische Werte (`logical`): TRUE, FALSE - Ganze Zahlen (`integer`): int8 (-128,...,127), int16 (–32768,..., 32767) - Gleitkommazahlen (`single`, `double`): 1.23456, 12.3456, 123.456, ... - Zeichen (character): "a", "b", "c", "!" - Datentyp-spezifische assoziierte Operationen - \small AND, OR (logical) +, - (integer) +,-,\*, / (single), Zeichenkonkatenation (character) \normalsize \textcolor{darkblue}{Zusammengesetzte Datenstrukturen} \small - Vordefinierte Container zur Zusammenfassung mehrerer Variablen gleichen Datentyps (z.B. Vektoren, Listen, Arrays, Matrizen, ...). - Container-spezifische Operationen (z.B. Vektorindizierung, Matrixmultiplikation, ...). \normalsize \textcolor{darkblue}{Selbstdefinierte Datenstrukturen} \small - Definition eigener Datenstrukturen aus vordefinierten Datenstrukturen und Containern - Definition eigener Operationen # Datenstrukturenkennenlernen beim Erlernen einer Programmiersprache \normalsize \textcolor{darkblue}{Fundamentale Datenstrukturen} \small - Welche fundamentalen Datenstrukturen bietet die Sprache an? - Welche Operationen darauf sind bereits definiert? - Wie lautet die Syntax zur Definition einer Variable eines fundamentalen Datentyps? - Wie lautet die Syntax, um vordefinierte Operationen aufzurufen? \normalsize \textcolor{darkblue}{Zusammengesetzte Datenstrukturen} \small - Welche Container und zugehörige Operationen bietet die Programmiersprache? - Wie lautet die Syntax zum Umgang mit einem Container? \normalsize \textcolor{darkblue}{Selbstdefinierte Datenstrukturen} \small - Wie erzeugt man selbstdefinierte Datenstrukturen und zugehörige Operationen? - Wie lautet die Syntax zum Umgang mit einer selbstdefinierten Datenstruktur? \vfill # Organisation von Daten in R Alles, was in R vorkommt, ist ein **Objekt**. \vspace{1mm} Jedem Objekt kann eindeutig zugeordnet werden: \small - ein **Modus** - \small Atomar $\,\,\vert$ Komponenten sind vom gleichen Datentyp. - Rekursiv $\vert$ Komponenten können von unterschiedlichem Datentyp sein. - eine **Länge** - optional weitere **Attribute** \vfill # Organisation von Daten in R \vspace{1mm} Alles, was in R vorkommt, ist ein **Objekt**. \vspace{5mm} ![](Abbildungen/pds_2_r_objektstruktur.pdf){width="\"80$%"} \vfill # Übersicht der R Datentypen \small \setstretch{1.8} \vspace{5mm} \begin{center} \begin{tabular}{l|l} Datentyp & Erläuterung \\ \hline logical & Die beiden logischen Werte TRUE und FALSE \\ double & Gleitkommazahlen \\ integer & Ganze Zahlen \\ complex & Komplexe Zahlen, hier nicht weiter besprochen \\ character & Zeichen und Zeichenketten (strings), 'x' oder ``Hallo Welt!'' \\ raw & Bytes, hier nicht weiter besprochen \\ \end{tabular} \end{center} \vfill - Double und integer werden zusammen auch als **numeric** bezeichnet. - Viele weitere Typen, hier relevant sind **logical**, **double**, **integer**, **character**. \vfill # Übersicht der R Datentypen \small Automatische Festlegung von Datentypen durch Zuweisung \vspace{1mm} \footnotesize ```{r, echo = T, eval = T} #| label: Automatische Typen b <- TRUE # logical x <- 2.5 # double y <- 1L # (long) integer c <- 'a' # character ``` \small Ausgabe von Datentypen durch `typeof()` \setstretch{0.5} \footnotesize ```{r, echo = T, eval = T} #| label: bool typeof(b) ``` \vspace{1.5mm} ```{r, echo = T, eval = T} #| label: double typeof(x) ``` \vspace{1.5mm} ```{r, echo = T, eval = T} #| label: integer typeof(y) ``` \vspace{1.5mm} ```{r, echo = T, eval = T} #| label: character typeof(c) ``` # Übersicht der R Datentypen \small Testen von Datetypen durch `is.*()` \footnotesize ```{r, echo = T, eval = T} #| label: test type logical is.logical(x) ``` \vspace{1.5mm} ```{r, echo = T, eval = T} #| label: test type double is.double(x) ``` ```{r, echo = T, eval = T} #| label: test type numeric is.numeric(x) ``` ```{r, echo = T, eval = T} #| label: test type double on int is.double(y) ``` ```{r, echo = T, eval = T} #| label: test type numeric on int is.numeric(y) ``` # Übersicht atomare Datenstrukturen in R \vspace{3mm} \setstretch{2.5} \begin{center} \begin{tabular}{l|l} Datenstruktur & Erläuterung \\ \hline Vektor & Container von indizierten Komponenten identischen Typs \\ Matrix & Interpretation eines Vektors als zweidimensionaler Container \\ Array & Interpretation eines Vektors als mehrdimensionaler Container \end{tabular} \end{center} \vspace{3mm} $\Rightarrow$ (4) Vektoren und Matrizen \vfill # Übersicht rekursive Datenstrukturen in R \vspace{3mm} \setstretch{2.5} \begin{center} \begin{tabular}{l|l} Datenstruktur & Erläuterung \\ \hline Liste & Container von indizierten Komponenten beliebigen Datentyps \\ & Insbesondere auch rekursive Struktur, z.B. Liste von Listen \\ Dataframe & Symbiose aus Liste und Matrix \\ & Jede Komponente ist Vektor beliebigen Datentyps identischer Länge \\ \end{tabular} \end{center} \vspace{3mm} $\Rightarrow$ (5) Listen und Dataframes \vfill