├── 1-Grundlagen von R und Datentypen ├── 1-R Grundlagen │ ├── 1-Arithmetik mit R.ipynb │ ├── 10-R Grundlagen Übung - Lösung.ipynb │ ├── 10-R Grundlagen Übung - Lösung.ipynb │ ├── 2-Variablen.ipynb │ ├── 3-R Datentypen.ipynb │ ├── 4-Vektor Grundlagen.ipynb │ ├── 5-Vektor Operationen.ipynb │ ├── 6-Vektor Indexierung und Ausschneiden.ipynb │ ├── 7-Hilfe für R erhalten.ipynb │ ├── 7-Hilfe für R erhalten.ipynb │ ├── 8-Vergleichsoperatoren.ipynb │ ├── 9-R Grundlagen Übung - Aufgaben.ipynb │ └── 9-R Grundlagen Übung - Aufgaben.ipynb ├── 2-R Matrizen │ ├── 1-Eine Matrix erstellen.ipynb │ ├── 2-Matrix Arithmetik.ipynb │ ├── 3-Matrix Operationen.ipynb │ ├── 4-Matrix Auswahl und Indexierung.ipynb │ ├── 5-Faktor und kategorische Matrizen.ipynb │ ├── 6-R Matrizen Übung - Aufgaben.ipynb │ ├── 6-R Matrizen Übung - Aufgaben.ipynb │ ├── 7-R Matrizen Übung - Lösung.ipynb │ └── 7-R Matrizen Übung - Lösung.ipynb ├── 3-R Data Frames │ ├── 1-Data Frame Grundlagen.ipynb │ ├── 2-Data Frame Auswahl und Indexierung.ipynb │ ├── 3-Data Frame Operationen.ipynb │ ├── 4-R Data Frames Übung - Aufgaben.ipynb │ ├── 4-R Data Frames Übung - Aufgaben.ipynb │ ├── 5-R Data Frames Übung - Lösung.ipynb │ └── 5-R Data Frames Übung - Lösung.ipynb └── 4-R Listen │ └── 1-R Listen.ipynb ├── 2-Data Input und Output mit R ├── 1-CSV Input und Output.ipynb ├── 2-Excel Dateien mit R.ipynb ├── 3-SQL mit R.ipynb ├── 4-Web Scraping mit R.ipynb ├── Beispiel-Verkaufs-Daten.xlsx ├── Demo.R ├── beispiel.csv ├── foo.csv └── output.xlsx ├── 3-Programmieren mit R ├── 1-Logische Operatoren.ipynb ├── 2-if, else und else if Anweisungen.ipynb ├── 3-Bedingte Anweisungen Übung - Aufgaben.ipynb ├── 3-Bedingte Anweisungen Übung - Aufgaben.ipynb ├── 4-Bedingte Anweisungen Übung - Lösung.ipynb ├── 4-Bedingte Anweisungen Übung - Lösung.ipynb ├── 5-While Schleifen.ipynb ├── 6-For Schleifen.ipynb ├── 7-Funktionen.ipynb ├── 8-R Funktionen Übung - Aufgaben.ipynb ├── 8-R Funktionen Übung - Aufgaben.ipynb ├── 9-R Funktionen Übung - Lösung.ipynb └── 9-R Funktionen Übung - Lösung.ipynb ├── 4-Fortgeschrittene Programmierung mit R ├── 1-Eingebaute R Features.ipynb ├── 2-Apply.ipynb ├── 3-Mathe mit R.ipynb ├── 4-Regular Expressions.ipynb └── 5-Zeiten und Daten.ipynb ├── 5-Datenmanipulation mit R ├── 1-Guide zur Verwendung von dplyr.ipynb ├── 2-Pipe Operators.ipynb ├── 3-Dplyr Übung - Aufgaben.ipynb ├── 3-Dplyr Übung - Aufgaben.ipynb ├── 4-Dplyr Übung - Lösung.ipynb ├── 4-Dplyr Übung - Lösung.ipynb └── 5-Guide zur Verwendung von tidyr.ipynb ├── 6-Daten Visualisierung mit R ├── 1-Gramatik von Grafiken und ggplot2.ipynb ├── 10-ggplot2 Übung - Lösung.ipynb ├── 10-ggplot2 Übung - Lösung.ipynb ├── 11-Projekt mit ggplot2 - Aufgabe.ipynb ├── 12-Projekt mit ggplot2 - Lösung.ipynb ├── 12-Projekt mit ggplot2 - Lösung.ipynb ├── 2-Histogramme mit ggplot2.ipynb ├── 3-Scatterplots mit ggplot2.ipynb ├── 4-Balkendiagramm mit ggplot2.ipynb ├── 5-Boxplots mit ggplot2.ipynb ├── 6-2 Variablen darstellen mit ggplot2.ipynb ├── 7-Koordinaten und Faceting mit ggplot2.ipynb ├── 8-Themes.ipynb ├── 9-ggplot2 Übung - Aufgaben.ipynb ├── 9-ggplot2 Übung - Aufgaben.ipynb ├── Economist1.png ├── Economist_Assignment_Data.csv ├── ggplot2-cheatsheet.pdf ├── grammar_layers.png └── state_real_estate_data.csv ├── 7-Interaktive Daten Visualisierung mit R und plotly ├── 1-Übersicht von Plotly und R.ipynb └── 1-Übersicht von Plotly und R.ipynb ├── 8-Meilenstein Projekt ├── 1-MoneyBall Projekt - Aufgaben.ipynb ├── 2-MoneyBall Projekt - Lösung.ipynb ├── 2-MoneyBall Projekt - Lösung.ipynb ├── Batting.csv ├── Moneyball.jpg ├── Salaries.csv ├── moneyball_title.jpg ├── readme2013.txt └── salary.png ├── 9-Machine Learning mit R ├── 1-Lineare Regression.ipynb ├── 10-Baum Methoden - Decision Trees und Random Forests.ipynb ├── 11-Baum Methoden Projekt - Aufgaben.ipynb ├── 12-Baum Methoden Projekt - Lösung.ipynb ├── 12-Baum Methoden Projekt - Lösung.ipynb ├── 13-K-means Clustering.ipynb ├── 15-K-means Clustering Projekt - Lösungen.ipynb ├── 15-K-means Clustering Projekt - Lösungen.ipynb ├── 16-Support Vector Machines.ipynb ├── 18-Support Vector Machines Projekt - Lösungen.ipynb ├── 18-Support Vector Machines Projekt - Lösungen.ipynb ├── 19-Natural Language Processing.ipynb ├── 2-Lineare Regression Projekt - Aufgabe.ipynb ├── 20-Neuronale Netze (Neural Nets).ipynb ├── 21-Neuronale Netze Projekt - Aufgaben.ipynb ├── 22-Neuronale Netze Projekt - Lösung.ipynb ├── 22-Neuronale Netze Projekt - Lösung.ipynb ├── 3-Lineare Regression Projekt - Lösung.ipynb ├── 3-Lineare Regression Projekt - Lösung.ipynb ├── 4-Logistische Regression.ipynb ├── 5-Logistische Regression - Aufgabe.ipynb ├── 6-Logistische Regression - Lösung.ipynb ├── 6-Logistische Regression - Lösung.ipynb ├── 7-K Nearest Neighbors.ipynb ├── 8-K Nearest Neighbors Projekt - Aufgaben.ipynb ├── 9-K Nearest Neighbors Projekt - Lösung.ipynb ├── 9-K Nearest Neighbors Projekt - Lösung.ipynb ├── adult_sal.csv ├── anscombe.png ├── bank_note_data.csv ├── bikeshare.csv ├── loan_data.csv ├── student-mat.csv ├── titanic_test.csv ├── titanic_train.csv ├── winequality-red.csv └── winequality-white.csv └── README.md /1-Grundlagen von R und Datentypen/1-R Grundlagen/1-Arithmetik mit R.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Arithmetik mit R\n", 8 | "\n", 9 | "**Addition**" 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": 5, 15 | "metadata": {}, 16 | "outputs": [ 17 | { 18 | "data": { 19 | "text/html": [ 20 | "3" 21 | ], 22 | "text/latex": [ 23 | "3" 24 | ], 25 | "text/markdown": [ 26 | "3" 27 | ], 28 | "text/plain": [ 29 | "[1] 3" 30 | ] 31 | }, 32 | "execution_count": 5, 33 | "metadata": {}, 34 | "output_type": "execute_result" 35 | } 36 | ], 37 | "source": [ 38 | "1+2" 39 | ] 40 | }, 41 | { 42 | "cell_type": "markdown", 43 | "metadata": {}, 44 | "source": [ 45 | "**Subtraktion**" 46 | ] 47 | }, 48 | { 49 | "cell_type": "code", 50 | "execution_count": 7, 51 | "metadata": {}, 52 | "outputs": [ 53 | { 54 | "data": { 55 | "text/html": [ 56 | "2" 57 | ], 58 | "text/latex": [ 59 | "2" 60 | ], 61 | "text/markdown": [ 62 | "2" 63 | ], 64 | "text/plain": [ 65 | "[1] 2" 66 | ] 67 | }, 68 | "execution_count": 7, 69 | "metadata": {}, 70 | "output_type": "execute_result" 71 | } 72 | ], 73 | "source": [ 74 | "5-3" 75 | ] 76 | }, 77 | { 78 | "cell_type": "markdown", 79 | "metadata": {}, 80 | "source": [ 81 | "** Division **" 82 | ] 83 | }, 84 | { 85 | "cell_type": "code", 86 | "execution_count": 8, 87 | "metadata": {}, 88 | "outputs": [ 89 | { 90 | "data": { 91 | "text/html": [ 92 | "0.5" 93 | ], 94 | "text/latex": [ 95 | "0.5" 96 | ], 97 | "text/markdown": [ 98 | "0.5" 99 | ], 100 | "text/plain": [ 101 | "[1] 0.5" 102 | ] 103 | }, 104 | "execution_count": 8, 105 | "metadata": {}, 106 | "output_type": "execute_result" 107 | } 108 | ], 109 | "source": [ 110 | "1/2" 111 | ] 112 | }, 113 | { 114 | "cell_type": "markdown", 115 | "metadata": {}, 116 | "source": [ 117 | "** Exponenten **" 118 | ] 119 | }, 120 | { 121 | "cell_type": "code", 122 | "execution_count": 9, 123 | "metadata": {}, 124 | "outputs": [ 125 | { 126 | "data": { 127 | "text/html": [ 128 | "8" 129 | ], 130 | "text/latex": [ 131 | "8" 132 | ], 133 | "text/markdown": [ 134 | "8" 135 | ], 136 | "text/plain": [ 137 | "[1] 8" 138 | ] 139 | }, 140 | "execution_count": 9, 141 | "metadata": {}, 142 | "output_type": "execute_result" 143 | } 144 | ], 145 | "source": [ 146 | "2^3" 147 | ] 148 | }, 149 | { 150 | "cell_type": "markdown", 151 | "metadata": {}, 152 | "source": [ 153 | "** Modulo **" 154 | ] 155 | }, 156 | { 157 | "cell_type": "code", 158 | "execution_count": 11, 159 | "metadata": {}, 160 | "outputs": [ 161 | { 162 | "data": { 163 | "text/html": [ 164 | "1" 165 | ], 166 | "text/latex": [ 167 | "1" 168 | ], 169 | "text/markdown": [ 170 | "1" 171 | ], 172 | "text/plain": [ 173 | "[1] 1" 174 | ] 175 | }, 176 | "execution_count": 11, 177 | "metadata": {}, 178 | "output_type": "execute_result" 179 | } 180 | ], 181 | "source": [ 182 | "5 %% 2" 183 | ] 184 | }, 185 | { 186 | "cell_type": "markdown", 187 | "metadata": {}, 188 | "source": [ 189 | "**Reihenfolge der Operationen**" 190 | ] 191 | }, 192 | { 193 | "cell_type": "code", 194 | "execution_count": 12, 195 | "metadata": {}, 196 | "outputs": [ 197 | { 198 | "data": { 199 | "text/html": [ 200 | "225" 201 | ], 202 | "text/latex": [ 203 | "225" 204 | ], 205 | "text/markdown": [ 206 | "225" 207 | ], 208 | "text/plain": [ 209 | "[1] 225" 210 | ] 211 | }, 212 | "execution_count": 12, 213 | "metadata": {}, 214 | "output_type": "execute_result" 215 | } 216 | ], 217 | "source": [ 218 | "(100 * 2) + (50 / 2)" 219 | ] 220 | }, 221 | { 222 | "cell_type": "markdown", 223 | "metadata": {}, 224 | "source": [ 225 | "Das war's für die mathematischen Grundlagen!" 226 | ] 227 | } 228 | ], 229 | "metadata": { 230 | "kernelspec": { 231 | "display_name": "R", 232 | "language": "R", 233 | "name": "ir" 234 | }, 235 | "language_info": { 236 | "codemirror_mode": "r", 237 | "file_extension": ".r", 238 | "mimetype": "text/x-r-source", 239 | "name": "R", 240 | "pygments_lexer": "r", 241 | "version": "3.4.2" 242 | } 243 | }, 244 | "nbformat": 4, 245 | "nbformat_minor": 1 246 | } 247 | -------------------------------------------------------------------------------- /1-Grundlagen von R und Datentypen/1-R Grundlagen/10-R Grundlagen Übung - Lösung.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# R Grundlagen Übung - Lösung\n", 8 | "\n", 9 | "Wir werden nun einige Themen überprüfen:\n", 10 | "\n", 11 | "* Grundlegende Datentypen\n", 12 | "* Grundlegende Arithmetik\n", 13 | "* Vektoren\n", 14 | "* Vektor Operationen\n", 15 | "* Vergleichsoperatoren\n", 16 | "* Vektor Auswahl und Indexierung\n", 17 | "\n", 18 | "Die nachfolgende Übung sollte selbsterklärend sein, sofern du die Lektionen angeschaut hast. Erwarte hier nichts besonders herausforderndes, da diese Aufgaben eher als Wiederholung ausgelegt sind. Gehe einfach sicher, dass du alles verstanden hast, da der Kurs auf diesen Grundlagen aufbaut! Später werden die Übungen und Projekte noch viel herausfordernder (und spaßiger!)." 19 | ] 20 | }, 21 | { 22 | "cell_type": "markdown", 23 | "metadata": {}, 24 | "source": [ 25 | "### Löse die folgenden Aufgaben mit R\n", 26 | "** Was ist zwei hoch fünf? **" 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": 1, 32 | "metadata": { 33 | "collapsed": false 34 | }, 35 | "outputs": [ 36 | { 37 | "data": { 38 | "text/html": [ 39 | "32" 40 | ], 41 | "text/latex": [ 42 | "32" 43 | ], 44 | "text/markdown": [ 45 | "32" 46 | ], 47 | "text/plain": [ 48 | "[1] 32" 49 | ] 50 | }, 51 | "metadata": {}, 52 | "output_type": "display_data" 53 | } 54 | ], 55 | "source": [ 56 | "2^5" 57 | ] 58 | }, 59 | { 60 | "cell_type": "markdown", 61 | "metadata": {}, 62 | "source": [ 63 | "** Erstelle einen Vektor namens aktien.preise mit folgenden Datenpunkten: 23,27,23,21,34 **" 64 | ] 65 | }, 66 | { 67 | "cell_type": "code", 68 | "execution_count": 2, 69 | "metadata": { 70 | "collapsed": false 71 | }, 72 | "outputs": [ 73 | { 74 | "data": { 75 | "text/html": [ 76 | "
    \n", 77 | "\t
  1. 23
    2. \n", 78 | "\t
  2. 27
    3. \n", 79 | "\t
  3. 23
    4. \n", 80 | "\t
  4. 21
    5. \n", 81 | "\t
  5. 34
    6. \n", 82 | "
\n" 83 | ], 84 | "text/latex": [ 85 | "\\begin{enumerate*}\n", 86 | "\\item 23\n", 87 | "\\item 27\n", 88 | "\\item 23\n", 89 | "\\item 21\n", 90 | "\\item 34\n", 91 | "\\end{enumerate*}\n" 92 | ], 93 | "text/markdown": [ 94 | "1. 23\n", 95 | "2. 27\n", 96 | "3. 23\n", 97 | "4. 21\n", 98 | "5. 34\n", 99 | "\n", 100 | "\n" 101 | ], 102 | "text/plain": [ 103 | "[1] 23 27 23 21 34" 104 | ] 105 | }, 106 | "metadata": {}, 107 | "output_type": "display_data" 108 | } 109 | ], 110 | "source": [ 111 | "aktien.preise <- c(23,27,23,21,34)\n", 112 | "aktien.preise" 113 | ] 114 | }, 115 | { 116 | "cell_type": "markdown", 117 | "metadata": {}, 118 | "source": [ 119 | "** Weise den Einträgen Namen zu, die bezug auf die Wochentage (Mo, Di, Mi, ...) nehmen**" 120 | ] 121 | }, 122 | { 123 | "cell_type": "code", 124 | "execution_count": 3, 125 | "metadata": { 126 | "collapsed": false 127 | }, 128 | "outputs": [ 129 | { 130 | "data": { 131 | "text/html": [ 132 | "
\n", 133 | "\t
Mo
\n", 134 | "\t\t
23
\n", 135 | "\t
Di
\n", 136 | "\t\t
27
\n", 137 | "\t
Mi
\n", 138 | "\t\t
23
\n", 139 | "\t
Do
\n", 140 | "\t\t
21
\n", 141 | "\t
Fr
\n", 142 | "\t\t
34
\n", 143 | "
\n" 144 | ], 145 | "text/latex": [ 146 | "\\begin{description*}\n", 147 | "\\item[Mo] 23\n", 148 | "\\item[Di] 27\n", 149 | "\\item[Mi] 23\n", 150 | "\\item[Do] 21\n", 151 | "\\item[Fr] 34\n", 152 | "\\end{description*}\n" 153 | ], 154 | "text/markdown": [ 155 | "Mo\n", 156 | ": 23Di\n", 157 | ": 27Mi\n", 158 | ": 23Do\n", 159 | ": 21Fr\n", 160 | ": 34\n", 161 | "\n" 162 | ], 163 | "text/plain": [ 164 | "Mo Di Mi Do Fr \n", 165 | "23 27 23 21 34 " 166 | ] 167 | }, 168 | "metadata": {}, 169 | "output_type": "display_data" 170 | } 171 | ], 172 | "source": [ 173 | "names(aktien.preise) <- c('Mo','Di','Mi','Do','Fr')\n", 174 | "aktien.preise" 175 | ] 176 | }, 177 | { 178 | "cell_type": "markdown", 179 | "metadata": {}, 180 | "source": [ 181 | "**Was ist der durchschnittliche (en. mean) Aktienpreis dieser Woche? (Du könntest dazu eine eingebaute Funktion verwenden)**" 182 | ] 183 | }, 184 | { 185 | "cell_type": "code", 186 | "execution_count": 4, 187 | "metadata": { 188 | "collapsed": false 189 | }, 190 | "outputs": [ 191 | { 192 | "data": { 193 | "text/html": [ 194 | "25.6" 195 | ], 196 | "text/latex": [ 197 | "25.6" 198 | ], 199 | "text/markdown": [ 200 | "25.6" 201 | ], 202 | "text/plain": [ 203 | "[1] 25.6" 204 | ] 205 | }, 206 | "metadata": {}, 207 | "output_type": "display_data" 208 | } 209 | ], 210 | "source": [ 211 | "mean(aktien.preise)" 212 | ] 213 | }, 214 | { 215 | "cell_type": "markdown", 216 | "metadata": {}, 217 | "source": [ 218 | "** Erstelle einen Vektor namens ueber.23, der aus logischen Werten besteht, die beschreiben, ob der Preis an einem Tag über 23 lag**" 219 | ] 220 | }, 221 | { 222 | "cell_type": "code", 223 | "execution_count": 5, 224 | "metadata": { 225 | "collapsed": true 226 | }, 227 | "outputs": [], 228 | "source": [ 229 | "ueber.23 <- aktien.preise>23" 230 | ] 231 | }, 232 | { 233 | "cell_type": "markdown", 234 | "metadata": {}, 235 | "source": [ 236 | "** Nutze nun den ueber.23 Vektor, um aus aktien.preise alle Preise zu filtern, die über 23 lagen**" 237 | ] 238 | }, 239 | { 240 | "cell_type": "code", 241 | "execution_count": 6, 242 | "metadata": { 243 | "collapsed": false 244 | }, 245 | "outputs": [ 246 | { 247 | "data": { 248 | "text/html": [ 249 | "
\n", 250 | "\t
Di
\n", 251 | "\t\t
27
\n", 252 | "\t
Fr
\n", 253 | "\t\t
34
\n", 254 | "
\n" 255 | ], 256 | "text/latex": [ 257 | "\\begin{description*}\n", 258 | "\\item[Di] 27\n", 259 | "\\item[Fr] 34\n", 260 | "\\end{description*}\n" 261 | ], 262 | "text/markdown": [ 263 | "Di\n", 264 | ": 27Fr\n", 265 | ": 34\n", 266 | "\n" 267 | ], 268 | "text/plain": [ 269 | "Di Fr \n", 270 | "27 34 " 271 | ] 272 | }, 273 | "metadata": {}, 274 | "output_type": "display_data" 275 | } 276 | ], 277 | "source": [ 278 | "aktien.preise[ueber.23]" 279 | ] 280 | }, 281 | { 282 | "cell_type": "markdown", 283 | "metadata": {}, 284 | "source": [ 285 | "** Nutze eine eingebaute Funktion, um herauszufinden wann der Aktienpreis am höchsten war**" 286 | ] 287 | }, 288 | { 289 | "cell_type": "code", 290 | "execution_count": 7, 291 | "metadata": { 292 | "collapsed": false 293 | }, 294 | "outputs": [ 295 | { 296 | "data": { 297 | "text/html": [ 298 | "34" 299 | ], 300 | "text/latex": [ 301 | "34" 302 | ], 303 | "text/markdown": [ 304 | "34" 305 | ], 306 | "text/plain": [ 307 | "[1] 34" 308 | ] 309 | }, 310 | "metadata": {}, 311 | "output_type": "display_data" 312 | } 313 | ], 314 | "source": [ 315 | "max(aktien.preise)" 316 | ] 317 | }, 318 | { 319 | "cell_type": "markdown", 320 | "metadata": {}, 321 | "source": [ 322 | "** Das hat uns nicht wirklich den Tag verraten. Lasst uns einen Filter benutzen, um den Wochentag zu erhalten!**" 323 | ] 324 | }, 325 | { 326 | "cell_type": "code", 327 | "execution_count": 8, 328 | "metadata": { 329 | "collapsed": false 330 | }, 331 | "outputs": [ 332 | { 333 | "data": { 334 | "text/html": [ 335 | "
\n", 336 | "\t
Mo
\n", 337 | "\t\t
FALSE
\n", 338 | "\t
Di
\n", 339 | "\t\t
FALSE
\n", 340 | "\t
Mi
\n", 341 | "\t\t
FALSE
\n", 342 | "\t
Do
\n", 343 | "\t\t
FALSE
\n", 344 | "\t
Fr
\n", 345 | "\t\t
TRUE
\n", 346 | "
\n" 347 | ], 348 | "text/latex": [ 349 | "\\begin{description*}\n", 350 | "\\item[Mo] FALSE\n", 351 | "\\item[Di] FALSE\n", 352 | "\\item[Mi] FALSE\n", 353 | "\\item[Do] FALSE\n", 354 | "\\item[Fr] TRUE\n", 355 | "\\end{description*}\n" 356 | ], 357 | "text/markdown": [ 358 | "Mo\n", 359 | ": FALSEDi\n", 360 | ": FALSEMi\n", 361 | ": FALSEDo\n", 362 | ": FALSEFr\n", 363 | ": TRUE\n", 364 | "\n" 365 | ], 366 | "text/plain": [ 367 | " Mo Di Mi Do Fr \n", 368 | "FALSE FALSE FALSE FALSE TRUE " 369 | ] 370 | }, 371 | "metadata": {}, 372 | "output_type": "display_data" 373 | } 374 | ], 375 | "source": [ 376 | "max.preis <- aktien.preise == max(aktien.preise)\n", 377 | "max.preis" 378 | ] 379 | }, 380 | { 381 | "cell_type": "code", 382 | "execution_count": 9, 383 | "metadata": { 384 | "collapsed": false 385 | }, 386 | "outputs": [ 387 | { 388 | "data": { 389 | "text/html": [ 390 | "Fr: 34" 391 | ], 392 | "text/latex": [ 393 | "\\textbf{Fr:} 34" 394 | ], 395 | "text/markdown": [ 396 | "**Fr:** 34" 397 | ], 398 | "text/plain": [ 399 | "Fr \n", 400 | "34 " 401 | ] 402 | }, 403 | "metadata": {}, 404 | "output_type": "display_data" 405 | } 406 | ], 407 | "source": [ 408 | "aktien.preise[max.preis]" 409 | ] 410 | }, 411 | { 412 | "cell_type": "markdown", 413 | "metadata": {}, 414 | "source": [ 415 | "Okay, das wars zur Übung der Grundlagen. Gut gemacht!" 416 | ] 417 | } 418 | ], 419 | "metadata": { 420 | "kernelspec": { 421 | "display_name": "Python 3", 422 | "language": "python", 423 | "name": "python3" 424 | }, 425 | "language_info": { 426 | "codemirror_mode": { 427 | "name": "ipython", 428 | "version": 3 429 | }, 430 | "file_extension": ".py", 431 | "mimetype": "text/x-python", 432 | "name": "python", 433 | "nbconvert_exporter": "python", 434 | "pygments_lexer": "ipython3", 435 | "version": "3.6.0" 436 | } 437 | }, 438 | "nbformat": 4, 439 | "nbformat_minor": 1 440 | } 441 | -------------------------------------------------------------------------------- /1-Grundlagen von R und Datentypen/1-R Grundlagen/10-R Grundlagen Übung - Lösung.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# R Grundlagen Übung - Lösung\n", 8 | "\n", 9 | "Wir werden nun einige Themen überprüfen:\n", 10 | "\n", 11 | "* Grundlegende Datentypen\n", 12 | "* Grundlegende Arithmetik\n", 13 | "* Vektoren\n", 14 | "* Vektor Operationen\n", 15 | "* Vergleichsoperatoren\n", 16 | "* Vektor Auswahl und Indexierung\n", 17 | "\n", 18 | "Die nachfolgende Übung sollte selbsterklärend sein, sofern du die Lektionen angeschaut hast. Erwarte hier nichts besonders herausforderndes, da diese Aufgaben eher als Wiederholung ausgelegt sind. Gehe einfach sicher, dass du alles verstanden hast, da der Kurs auf diesen Grundlagen aufbaut! Später werden die Übungen und Projekte noch viel herausfordernder (und spaßiger!)." 19 | ] 20 | }, 21 | { 22 | "cell_type": "markdown", 23 | "metadata": {}, 24 | "source": [ 25 | "### Löse die folgenden Aufgaben mit R\n", 26 | "** Was ist zwei hoch fünf? **" 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": 1, 32 | "metadata": { 33 | "collapsed": false 34 | }, 35 | "outputs": [ 36 | { 37 | "data": { 38 | "text/html": [ 39 | "32" 40 | ], 41 | "text/latex": [ 42 | "32" 43 | ], 44 | "text/markdown": [ 45 | "32" 46 | ], 47 | "text/plain": [ 48 | "[1] 32" 49 | ] 50 | }, 51 | "metadata": {}, 52 | "output_type": "display_data" 53 | } 54 | ], 55 | "source": [ 56 | "2^5" 57 | ] 58 | }, 59 | { 60 | "cell_type": "markdown", 61 | "metadata": {}, 62 | "source": [ 63 | "** Erstelle einen Vektor namens aktien.preise mit folgenden Datenpunkten: 23,27,23,21,34 **" 64 | ] 65 | }, 66 | { 67 | "cell_type": "code", 68 | "execution_count": 2, 69 | "metadata": { 70 | "collapsed": false 71 | }, 72 | "outputs": [ 73 | { 74 | "data": { 75 | "text/html": [ 76 | "
    \n", 77 | "\t
  1. 23
    2. \n", 78 | "\t
  2. 27
    3. \n", 79 | "\t
  3. 23
    4. \n", 80 | "\t
  4. 21
    5. \n", 81 | "\t
  5. 34
    6. \n", 82 | "
\n" 83 | ], 84 | "text/latex": [ 85 | "\\begin{enumerate*}\n", 86 | "\\item 23\n", 87 | "\\item 27\n", 88 | "\\item 23\n", 89 | "\\item 21\n", 90 | "\\item 34\n", 91 | "\\end{enumerate*}\n" 92 | ], 93 | "text/markdown": [ 94 | "1. 23\n", 95 | "2. 27\n", 96 | "3. 23\n", 97 | "4. 21\n", 98 | "5. 34\n", 99 | "\n", 100 | "\n" 101 | ], 102 | "text/plain": [ 103 | "[1] 23 27 23 21 34" 104 | ] 105 | }, 106 | "metadata": {}, 107 | "output_type": "display_data" 108 | } 109 | ], 110 | "source": [ 111 | "aktien.preise <- c(23,27,23,21,34)\n", 112 | "aktien.preise" 113 | ] 114 | }, 115 | { 116 | "cell_type": "markdown", 117 | "metadata": {}, 118 | "source": [ 119 | "** Weise den Einträgen Namen zu, die bezug auf die Wochentage (Mo, Di, Mi, ...) nehmen**" 120 | ] 121 | }, 122 | { 123 | "cell_type": "code", 124 | "execution_count": 3, 125 | "metadata": { 126 | "collapsed": false 127 | }, 128 | "outputs": [ 129 | { 130 | "data": { 131 | "text/html": [ 132 | "
\n", 133 | "\t
Mo
\n", 134 | "\t\t
23
\n", 135 | "\t
Di
\n", 136 | "\t\t
27
\n", 137 | "\t
Mi
\n", 138 | "\t\t
23
\n", 139 | "\t
Do
\n", 140 | "\t\t
21
\n", 141 | "\t
Fr
\n", 142 | "\t\t
34
\n", 143 | "
\n" 144 | ], 145 | "text/latex": [ 146 | "\\begin{description*}\n", 147 | "\\item[Mo] 23\n", 148 | "\\item[Di] 27\n", 149 | "\\item[Mi] 23\n", 150 | "\\item[Do] 21\n", 151 | "\\item[Fr] 34\n", 152 | "\\end{description*}\n" 153 | ], 154 | "text/markdown": [ 155 | "Mo\n", 156 | ": 23Di\n", 157 | ": 27Mi\n", 158 | ": 23Do\n", 159 | ": 21Fr\n", 160 | ": 34\n", 161 | "\n" 162 | ], 163 | "text/plain": [ 164 | "Mo Di Mi Do Fr \n", 165 | "23 27 23 21 34 " 166 | ] 167 | }, 168 | "metadata": {}, 169 | "output_type": "display_data" 170 | } 171 | ], 172 | "source": [ 173 | "names(aktien.preise) <- c('Mo','Di','Mi','Do','Fr')\n", 174 | "aktien.preise" 175 | ] 176 | }, 177 | { 178 | "cell_type": "markdown", 179 | "metadata": {}, 180 | "source": [ 181 | "**Was ist der durchschnittliche (en. mean) Aktienpreis dieser Woche? (Du könntest dazu eine eingebaute Funktion verwenden)**" 182 | ] 183 | }, 184 | { 185 | "cell_type": "code", 186 | "execution_count": 4, 187 | "metadata": { 188 | "collapsed": false 189 | }, 190 | "outputs": [ 191 | { 192 | "data": { 193 | "text/html": [ 194 | "25.6" 195 | ], 196 | "text/latex": [ 197 | "25.6" 198 | ], 199 | "text/markdown": [ 200 | "25.6" 201 | ], 202 | "text/plain": [ 203 | "[1] 25.6" 204 | ] 205 | }, 206 | "metadata": {}, 207 | "output_type": "display_data" 208 | } 209 | ], 210 | "source": [ 211 | "mean(aktien.preise)" 212 | ] 213 | }, 214 | { 215 | "cell_type": "markdown", 216 | "metadata": {}, 217 | "source": [ 218 | "** Erstelle einen Vektor namens ueber.23, der aus logischen Werten besteht, die beschreiben, ob der Preis an einem Tag über 23 lag**" 219 | ] 220 | }, 221 | { 222 | "cell_type": "code", 223 | "execution_count": 5, 224 | "metadata": { 225 | "collapsed": true 226 | }, 227 | "outputs": [], 228 | "source": [ 229 | "ueber.23 <- aktien.preise>23" 230 | ] 231 | }, 232 | { 233 | "cell_type": "markdown", 234 | "metadata": {}, 235 | "source": [ 236 | "** Nutze nun den ueber.23 Vektor, um aus aktien.preise alle Preise zu filtern, die über 23 lagen**" 237 | ] 238 | }, 239 | { 240 | "cell_type": "code", 241 | "execution_count": 6, 242 | "metadata": { 243 | "collapsed": false 244 | }, 245 | "outputs": [ 246 | { 247 | "data": { 248 | "text/html": [ 249 | "
\n", 250 | "\t
Di
\n", 251 | "\t\t
27
\n", 252 | "\t
Fr
\n", 253 | "\t\t
34
\n", 254 | "
\n" 255 | ], 256 | "text/latex": [ 257 | "\\begin{description*}\n", 258 | "\\item[Di] 27\n", 259 | "\\item[Fr] 34\n", 260 | "\\end{description*}\n" 261 | ], 262 | "text/markdown": [ 263 | "Di\n", 264 | ": 27Fr\n", 265 | ": 34\n", 266 | "\n" 267 | ], 268 | "text/plain": [ 269 | "Di Fr \n", 270 | "27 34 " 271 | ] 272 | }, 273 | "metadata": {}, 274 | "output_type": "display_data" 275 | } 276 | ], 277 | "source": [ 278 | "aktien.preise[ueber.23]" 279 | ] 280 | }, 281 | { 282 | "cell_type": "markdown", 283 | "metadata": {}, 284 | "source": [ 285 | "** Nutze eine eingebaute Funktion, um herauszufinden wann der Aktienpreis am höchsten war**" 286 | ] 287 | }, 288 | { 289 | "cell_type": "code", 290 | "execution_count": 7, 291 | "metadata": { 292 | "collapsed": false 293 | }, 294 | "outputs": [ 295 | { 296 | "data": { 297 | "text/html": [ 298 | "34" 299 | ], 300 | "text/latex": [ 301 | "34" 302 | ], 303 | "text/markdown": [ 304 | "34" 305 | ], 306 | "text/plain": [ 307 | "[1] 34" 308 | ] 309 | }, 310 | "metadata": {}, 311 | "output_type": "display_data" 312 | } 313 | ], 314 | "source": [ 315 | "max(aktien.preise)" 316 | ] 317 | }, 318 | { 319 | "cell_type": "markdown", 320 | "metadata": {}, 321 | "source": [ 322 | "** Das hat uns nicht wirklich den Tag verraten. Lasst uns einen Filter benutzen, um den Wochentag zu erhalten!**" 323 | ] 324 | }, 325 | { 326 | "cell_type": "code", 327 | "execution_count": 8, 328 | "metadata": { 329 | "collapsed": false 330 | }, 331 | "outputs": [ 332 | { 333 | "data": { 334 | "text/html": [ 335 | "
\n", 336 | "\t
Mo
\n", 337 | "\t\t
FALSE
\n", 338 | "\t
Di
\n", 339 | "\t\t
FALSE
\n", 340 | "\t
Mi
\n", 341 | "\t\t
FALSE
\n", 342 | "\t
Do
\n", 343 | "\t\t
FALSE
\n", 344 | "\t
Fr
\n", 345 | "\t\t
TRUE
\n", 346 | "
\n" 347 | ], 348 | "text/latex": [ 349 | "\\begin{description*}\n", 350 | "\\item[Mo] FALSE\n", 351 | "\\item[Di] FALSE\n", 352 | "\\item[Mi] FALSE\n", 353 | "\\item[Do] FALSE\n", 354 | "\\item[Fr] TRUE\n", 355 | "\\end{description*}\n" 356 | ], 357 | "text/markdown": [ 358 | "Mo\n", 359 | ": FALSEDi\n", 360 | ": FALSEMi\n", 361 | ": FALSEDo\n", 362 | ": FALSEFr\n", 363 | ": TRUE\n", 364 | "\n" 365 | ], 366 | "text/plain": [ 367 | " Mo Di Mi Do Fr \n", 368 | "FALSE FALSE FALSE FALSE TRUE " 369 | ] 370 | }, 371 | "metadata": {}, 372 | "output_type": "display_data" 373 | } 374 | ], 375 | "source": [ 376 | "max.preis <- aktien.preise == max(aktien.preise)\n", 377 | "max.preis" 378 | ] 379 | }, 380 | { 381 | "cell_type": "code", 382 | "execution_count": 9, 383 | "metadata": { 384 | "collapsed": false 385 | }, 386 | "outputs": [ 387 | { 388 | "data": { 389 | "text/html": [ 390 | "Fr: 34" 391 | ], 392 | "text/latex": [ 393 | "\\textbf{Fr:} 34" 394 | ], 395 | "text/markdown": [ 396 | "**Fr:** 34" 397 | ], 398 | "text/plain": [ 399 | "Fr \n", 400 | "34 " 401 | ] 402 | }, 403 | "metadata": {}, 404 | "output_type": "display_data" 405 | } 406 | ], 407 | "source": [ 408 | "aktien.preise[max.preis]" 409 | ] 410 | }, 411 | { 412 | "cell_type": "markdown", 413 | "metadata": {}, 414 | "source": [ 415 | "Okay, das wars zur Übung der Grundlagen. Gut gemacht!" 416 | ] 417 | } 418 | ], 419 | "metadata": { 420 | "kernelspec": { 421 | "display_name": "Python 3", 422 | "language": "python", 423 | "name": "python3" 424 | }, 425 | "language_info": { 426 | "codemirror_mode": { 427 | "name": "ipython", 428 | "version": 3 429 | }, 430 | "file_extension": ".py", 431 | "mimetype": "text/x-python", 432 | "name": "python", 433 | "nbconvert_exporter": "python", 434 | "pygments_lexer": "ipython3", 435 | "version": "3.6.0" 436 | } 437 | }, 438 | "nbformat": 4, 439 | "nbformat_minor": 1 440 | } 441 | -------------------------------------------------------------------------------- /1-Grundlagen von R und Datentypen/1-R Grundlagen/2-Variablen.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Variablen\n", 8 | "\n", 9 | "Lasst uns jetzt betrachten, wie wir in R Variablen zuweisen können.\n", 10 | "\n", 11 | "Dazu nutzen wir die **<-** Syntax. Das sieht ein bisschen wie ein Pfeil aus, der vom Objekt auf den Variablennamen zeigt." 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 1, 17 | "metadata": { 18 | "collapsed": true 19 | }, 20 | "outputs": [], 21 | "source": [ 22 | "# Für Kommentare nutzen wir Hastags\n", 23 | "variable.name <- 100" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": 2, 29 | "metadata": {}, 30 | "outputs": [ 31 | { 32 | "data": { 33 | "text/html": [ 34 | "100" 35 | ], 36 | "text/latex": [ 37 | "100" 38 | ], 39 | "text/markdown": [ 40 | "100" 41 | ], 42 | "text/plain": [ 43 | "[1] 100" 44 | ] 45 | }, 46 | "execution_count": 2, 47 | "metadata": {}, 48 | "output_type": "execute_result" 49 | } 50 | ], 51 | "source": [ 52 | "# Und so überprüfen wir den Wert einer Variablen\n", 53 | "variable.name" 54 | ] 55 | }, 56 | { 57 | "cell_type": "markdown", 58 | "metadata": {}, 59 | "source": [ 60 | "## Mit Variablen arbeiten\n", 61 | "\n", 62 | "Wir können Variablen gemeinsam nutzen, um mit ihnen zu arbeiten. Ein Beispiel:" 63 | ] 64 | }, 65 | { 66 | "cell_type": "code", 67 | "execution_count": 3, 68 | "metadata": { 69 | "collapsed": true 70 | }, 71 | "outputs": [], 72 | "source": [ 73 | "bank.konto <- 100" 74 | ] 75 | }, 76 | { 77 | "cell_type": "code", 78 | "execution_count": 5, 79 | "metadata": {}, 80 | "outputs": [], 81 | "source": [ 82 | "einzahlung <- 10" 83 | ] 84 | }, 85 | { 86 | "cell_type": "code", 87 | "execution_count": 6, 88 | "metadata": { 89 | "collapsed": true 90 | }, 91 | "outputs": [], 92 | "source": [ 93 | "bank.konto <- bank.konto + einzahlung" 94 | ] 95 | }, 96 | { 97 | "cell_type": "code", 98 | "execution_count": 7, 99 | "metadata": {}, 100 | "outputs": [ 101 | { 102 | "data": { 103 | "text/html": [ 104 | "110" 105 | ], 106 | "text/latex": [ 107 | "110" 108 | ], 109 | "text/markdown": [ 110 | "110" 111 | ], 112 | "text/plain": [ 113 | "[1] 110" 114 | ] 115 | }, 116 | "execution_count": 7, 117 | "metadata": {}, 118 | "output_type": "execute_result" 119 | } 120 | ], 121 | "source": [ 122 | "bank.konto" 123 | ] 124 | }, 125 | { 126 | "cell_type": "markdown", 127 | "metadata": {}, 128 | "source": [ 129 | "Das ist soweit alles. Schauen wir uns als nächstes die gru ndlegenden Datentypen an!" 130 | ] 131 | } 132 | ], 133 | "metadata": { 134 | "kernelspec": { 135 | "display_name": "R", 136 | "language": "R", 137 | "name": "ir" 138 | }, 139 | "language_info": { 140 | "codemirror_mode": "r", 141 | "file_extension": ".r", 142 | "mimetype": "text/x-r-source", 143 | "name": "R", 144 | "pygments_lexer": "r", 145 | "version": "3.4.2" 146 | } 147 | }, 148 | "nbformat": 4, 149 | "nbformat_minor": 1 150 | } 151 | -------------------------------------------------------------------------------- /1-Grundlagen von R und Datentypen/1-R Grundlagen/3-R Datentypen.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# R Datentypen\n", 8 | "\n", 9 | "Diese Lektion ist den grundlegenden Datentypen in R gewidmet.\n", 10 | "\n", 11 | "# Numerische Daten\n", 12 | "\n", 13 | "Dezimal (floating point values) sind die numerische Klasse in R." 14 | ] 15 | }, 16 | { 17 | "cell_type": "code", 18 | "execution_count": 1, 19 | "metadata": { 20 | "collapsed": true 21 | }, 22 | "outputs": [], 23 | "source": [ 24 | "n <- 2.2" 25 | ] 26 | }, 27 | { 28 | "cell_type": "markdown", 29 | "metadata": {}, 30 | "source": [ 31 | "## Ganzzahlen\n", 32 | "Natürliche (ganze) Zahlen werden als *Integers* bezeichnet und zählen zu der numerischen Klasse." 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": 2, 38 | "metadata": { 39 | "collapsed": true 40 | }, 41 | "outputs": [], 42 | "source": [ 43 | "i <- 5" 44 | ] 45 | }, 46 | { 47 | "cell_type": "markdown", 48 | "metadata": {}, 49 | "source": [ 50 | "## Logische Werte\n", 51 | "\n", 52 | "Boolean Werte (True und Flase (dt. Wahr und Falsch)) sind Teil der logischen Klasse. Diese werden in R KOMPLETT groß geschrieben." 53 | ] 54 | }, 55 | { 56 | "cell_type": "code", 57 | "execution_count": 3, 58 | "metadata": { 59 | "collapsed": true 60 | }, 61 | "outputs": [], 62 | "source": [ 63 | "t <- TRUE\n", 64 | "f <- FALSE" 65 | ] 66 | }, 67 | { 68 | "cell_type": "code", 69 | "execution_count": 4, 70 | "metadata": {}, 71 | "outputs": [ 72 | { 73 | "data": { 74 | "text/html": [ 75 | "TRUE" 76 | ], 77 | "text/latex": [ 78 | "TRUE" 79 | ], 80 | "text/markdown": [ 81 | "TRUE" 82 | ], 83 | "text/plain": [ 84 | "[1] TRUE" 85 | ] 86 | }, 87 | "metadata": {}, 88 | "output_type": "display_data" 89 | } 90 | ], 91 | "source": [ 92 | "t" 93 | ] 94 | }, 95 | { 96 | "cell_type": "code", 97 | "execution_count": 5, 98 | "metadata": {}, 99 | "outputs": [ 100 | { 101 | "data": { 102 | "text/html": [ 103 | "FALSE" 104 | ], 105 | "text/latex": [ 106 | "FALSE" 107 | ], 108 | "text/markdown": [ 109 | "FALSE" 110 | ], 111 | "text/plain": [ 112 | "[1] FALSE" 113 | ] 114 | }, 115 | "metadata": {}, 116 | "output_type": "display_data" 117 | } 118 | ], 119 | "source": [ 120 | "f" 121 | ] 122 | }, 123 | { 124 | "cell_type": "markdown", 125 | "metadata": {}, 126 | "source": [ 127 | "## Zeichen\n", 128 | "\n", 129 | "Text/String Werte sind in R als *Zeichen* bekannt. Wir nutzen Anführungszeichen, um einen String aus Textzeichen zu erstelen:" 130 | ] 131 | }, 132 | { 133 | "cell_type": "code", 134 | "execution_count": 6, 135 | "metadata": { 136 | "collapsed": true 137 | }, 138 | "outputs": [], 139 | "source": [ 140 | "char <- \"Hallo Welt\"" 141 | ] 142 | }, 143 | { 144 | "cell_type": "code", 145 | "execution_count": 7, 146 | "metadata": {}, 147 | "outputs": [ 148 | { 149 | "data": { 150 | "text/html": [ 151 | "'Hallo Welt'" 152 | ], 153 | "text/latex": [ 154 | "'Hallo Welt'" 155 | ], 156 | "text/markdown": [ 157 | "'Hallo Welt'" 158 | ], 159 | "text/plain": [ 160 | "[1] \"Hallo Welt\"" 161 | ] 162 | }, 163 | "metadata": {}, 164 | "output_type": "display_data" 165 | } 166 | ], 167 | "source": [ 168 | "char" 169 | ] 170 | }, 171 | { 172 | "cell_type": "code", 173 | "execution_count": 8, 174 | "metadata": { 175 | "collapsed": true 176 | }, 177 | "outputs": [], 178 | "source": [ 179 | "# Einfache Anführungszeichen gehen auch\n", 180 | "c <- 'Einfache Anführungszeichen'" 181 | ] 182 | }, 183 | { 184 | "cell_type": "code", 185 | "execution_count": 9, 186 | "metadata": {}, 187 | "outputs": [ 188 | { 189 | "data": { 190 | "text/html": [ 191 | "'Einfache Anführungszeichen'" 192 | ], 193 | "text/latex": [ 194 | "'Einfache Anführungszeichen'" 195 | ], 196 | "text/markdown": [ 197 | "'Einfache Anführungszeichen'" 198 | ], 199 | "text/plain": [ 200 | "[1] \"Einfache Anführungszeichen\"" 201 | ] 202 | }, 203 | "metadata": {}, 204 | "output_type": "display_data" 205 | } 206 | ], 207 | "source": [ 208 | "c" 209 | ] 210 | }, 211 | { 212 | "cell_type": "markdown", 213 | "metadata": {}, 214 | "source": [ 215 | "# Datentyp-Klassen überprüfen\n", 216 | "Wir können die `class()` Funktion nutzen, um den Datentype einer Variable zu überprüfen:" 217 | ] 218 | }, 219 | { 220 | "cell_type": "code", 221 | "execution_count": 10, 222 | "metadata": {}, 223 | "outputs": [ 224 | { 225 | "data": { 226 | "text/html": [ 227 | "'logical'" 228 | ], 229 | "text/latex": [ 230 | "'logical'" 231 | ], 232 | "text/markdown": [ 233 | "'logical'" 234 | ], 235 | "text/plain": [ 236 | "[1] \"logical\"" 237 | ] 238 | }, 239 | "metadata": {}, 240 | "output_type": "display_data" 241 | } 242 | ], 243 | "source": [ 244 | "class(t)" 245 | ] 246 | }, 247 | { 248 | "cell_type": "code", 249 | "execution_count": 11, 250 | "metadata": {}, 251 | "outputs": [ 252 | { 253 | "data": { 254 | "text/html": [ 255 | "'logical'" 256 | ], 257 | "text/latex": [ 258 | "'logical'" 259 | ], 260 | "text/markdown": [ 261 | "'logical'" 262 | ], 263 | "text/plain": [ 264 | "[1] \"logical\"" 265 | ] 266 | }, 267 | "metadata": {}, 268 | "output_type": "display_data" 269 | } 270 | ], 271 | "source": [ 272 | "class(f)" 273 | ] 274 | }, 275 | { 276 | "cell_type": "code", 277 | "execution_count": 12, 278 | "metadata": {}, 279 | "outputs": [ 280 | { 281 | "data": { 282 | "text/html": [ 283 | "'character'" 284 | ], 285 | "text/latex": [ 286 | "'character'" 287 | ], 288 | "text/markdown": [ 289 | "'character'" 290 | ], 291 | "text/plain": [ 292 | "[1] \"character\"" 293 | ] 294 | }, 295 | "metadata": {}, 296 | "output_type": "display_data" 297 | } 298 | ], 299 | "source": [ 300 | "class(char)" 301 | ] 302 | }, 303 | { 304 | "cell_type": "code", 305 | "execution_count": 13, 306 | "metadata": {}, 307 | "outputs": [ 308 | { 309 | "data": { 310 | "text/html": [ 311 | "'character'" 312 | ], 313 | "text/latex": [ 314 | "'character'" 315 | ], 316 | "text/markdown": [ 317 | "'character'" 318 | ], 319 | "text/plain": [ 320 | "[1] \"character\"" 321 | ] 322 | }, 323 | "metadata": {}, 324 | "output_type": "display_data" 325 | } 326 | ], 327 | "source": [ 328 | "class(c)" 329 | ] 330 | }, 331 | { 332 | "cell_type": "code", 333 | "execution_count": 14, 334 | "metadata": {}, 335 | "outputs": [ 336 | { 337 | "data": { 338 | "text/html": [ 339 | "'numeric'" 340 | ], 341 | "text/latex": [ 342 | "'numeric'" 343 | ], 344 | "text/markdown": [ 345 | "'numeric'" 346 | ], 347 | "text/plain": [ 348 | "[1] \"numeric\"" 349 | ] 350 | }, 351 | "metadata": {}, 352 | "output_type": "display_data" 353 | } 354 | ], 355 | "source": [ 356 | "class(n)" 357 | ] 358 | }, 359 | { 360 | "cell_type": "code", 361 | "execution_count": 15, 362 | "metadata": {}, 363 | "outputs": [ 364 | { 365 | "data": { 366 | "text/html": [ 367 | "'numeric'" 368 | ], 369 | "text/latex": [ 370 | "'numeric'" 371 | ], 372 | "text/markdown": [ 373 | "'numeric'" 374 | ], 375 | "text/plain": [ 376 | "[1] \"numeric\"" 377 | ] 378 | }, 379 | "metadata": {}, 380 | "output_type": "display_data" 381 | } 382 | ], 383 | "source": [ 384 | "class(i)" 385 | ] 386 | }, 387 | { 388 | "cell_type": "markdown", 389 | "metadata": {}, 390 | "source": [ 391 | "Das sind einige der grundlegenden Datentypen in R. Als nächstes lernen wir mehr über den Hauptbestandteil von R, den Vektor!" 392 | ] 393 | } 394 | ], 395 | "metadata": { 396 | "kernelspec": { 397 | "display_name": "R", 398 | "language": "R", 399 | "name": "ir" 400 | }, 401 | "language_info": { 402 | "codemirror_mode": "r", 403 | "file_extension": ".r", 404 | "mimetype": "text/x-r-source", 405 | "name": "R", 406 | "pygments_lexer": "r", 407 | "version": "3.4.2" 408 | } 409 | }, 410 | "nbformat": 4, 411 | "nbformat_minor": 1 412 | } 413 | -------------------------------------------------------------------------------- /1-Grundlagen von R und Datentypen/1-R Grundlagen/5-Vektor Operationen.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Arbeiten mit Vektoren\n", 8 | "\n", 9 | "Wir können einfache Arithmetik mit Vektoren durchführen. Die Operationen werden Element für Element durchgeführt. Zum Beispiel:" 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": 1, 15 | "metadata": { 16 | "collapsed": true 17 | }, 18 | "outputs": [], 19 | "source": [ 20 | "v1 <- c(1,2,3)\n", 21 | "v2 <- c(5,6,7)" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "metadata": {}, 27 | "source": [ 28 | "### Vektoren addieren" 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": 2, 34 | "metadata": {}, 35 | "outputs": [ 36 | { 37 | "data": { 38 | "text/html": [ 39 | "
    \n", 40 | "\t
  1. 6
    2. \n", 41 | "\t
  2. 8
    3. \n", 42 | "\t
  3. 10
    4. \n", 43 | "
\n" 44 | ], 45 | "text/latex": [ 46 | "\\begin{enumerate*}\n", 47 | "\\item 6\n", 48 | "\\item 8\n", 49 | "\\item 10\n", 50 | "\\end{enumerate*}\n" 51 | ], 52 | "text/markdown": [ 53 | "1. 6\n", 54 | "2. 8\n", 55 | "3. 10\n", 56 | "\n", 57 | "\n" 58 | ], 59 | "text/plain": [ 60 | "[1] 6 8 10" 61 | ] 62 | }, 63 | "metadata": {}, 64 | "output_type": "display_data" 65 | } 66 | ], 67 | "source": [ 68 | "v1+v2" 69 | ] 70 | }, 71 | { 72 | "cell_type": "markdown", 73 | "metadata": {}, 74 | "source": [ 75 | "### Vektoren subtrahieren" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": 3, 81 | "metadata": {}, 82 | "outputs": [ 83 | { 84 | "data": { 85 | "text/html": [ 86 | "
    \n", 87 | "\t
  1. 0
    2. \n", 88 | "\t
  2. 0
    3. \n", 89 | "\t
  3. 0
    4. \n", 90 | "
\n" 91 | ], 92 | "text/latex": [ 93 | "\\begin{enumerate*}\n", 94 | "\\item 0\n", 95 | "\\item 0\n", 96 | "\\item 0\n", 97 | "\\end{enumerate*}\n" 98 | ], 99 | "text/markdown": [ 100 | "1. 0\n", 101 | "2. 0\n", 102 | "3. 0\n", 103 | "\n", 104 | "\n" 105 | ], 106 | "text/plain": [ 107 | "[1] 0 0 0" 108 | ] 109 | }, 110 | "metadata": {}, 111 | "output_type": "display_data" 112 | } 113 | ], 114 | "source": [ 115 | "v1-v1" 116 | ] 117 | }, 118 | { 119 | "cell_type": "code", 120 | "execution_count": 4, 121 | "metadata": {}, 122 | "outputs": [ 123 | { 124 | "data": { 125 | "text/html": [ 126 | "
    \n", 127 | "\t
  1. -4
    2. \n", 128 | "\t
  2. -4
    3. \n", 129 | "\t
  3. -4
    4. \n", 130 | "
\n" 131 | ], 132 | "text/latex": [ 133 | "\\begin{enumerate*}\n", 134 | "\\item -4\n", 135 | "\\item -4\n", 136 | "\\item -4\n", 137 | "\\end{enumerate*}\n" 138 | ], 139 | "text/markdown": [ 140 | "1. -4\n", 141 | "2. -4\n", 142 | "3. -4\n", 143 | "\n", 144 | "\n" 145 | ], 146 | "text/plain": [ 147 | "[1] -4 -4 -4" 148 | ] 149 | }, 150 | "metadata": {}, 151 | "output_type": "display_data" 152 | } 153 | ], 154 | "source": [ 155 | "v1-v2" 156 | ] 157 | }, 158 | { 159 | "cell_type": "markdown", 160 | "metadata": {}, 161 | "source": [ 162 | "### Vektoren multiplizieren" 163 | ] 164 | }, 165 | { 166 | "cell_type": "code", 167 | "execution_count": 5, 168 | "metadata": {}, 169 | "outputs": [ 170 | { 171 | "data": { 172 | "text/html": [ 173 | "
    \n", 174 | "\t
  1. 5
    2. \n", 175 | "\t
  2. 12
    3. \n", 176 | "\t
  3. 21
    4. \n", 177 | "
\n" 178 | ], 179 | "text/latex": [ 180 | "\\begin{enumerate*}\n", 181 | "\\item 5\n", 182 | "\\item 12\n", 183 | "\\item 21\n", 184 | "\\end{enumerate*}\n" 185 | ], 186 | "text/markdown": [ 187 | "1. 5\n", 188 | "2. 12\n", 189 | "3. 21\n", 190 | "\n", 191 | "\n" 192 | ], 193 | "text/plain": [ 194 | "[1] 5 12 21" 195 | ] 196 | }, 197 | "metadata": {}, 198 | "output_type": "display_data" 199 | } 200 | ], 201 | "source": [ 202 | "v1*v2" 203 | ] 204 | }, 205 | { 206 | "cell_type": "markdown", 207 | "metadata": {}, 208 | "source": [ 209 | "### Vektoren dividieren" 210 | ] 211 | }, 212 | { 213 | "cell_type": "code", 214 | "execution_count": 6, 215 | "metadata": {}, 216 | "outputs": [ 217 | { 218 | "data": { 219 | "text/html": [ 220 | "
    \n", 221 | "\t
  1. 0.2
    2. \n", 222 | "\t
  2. 0.333333333333333
    3. \n", 223 | "\t
  3. 0.428571428571429
    4. \n", 224 | "
\n" 225 | ], 226 | "text/latex": [ 227 | "\\begin{enumerate*}\n", 228 | "\\item 0.2\n", 229 | "\\item 0.333333333333333\n", 230 | "\\item 0.428571428571429\n", 231 | "\\end{enumerate*}\n" 232 | ], 233 | "text/markdown": [ 234 | "1. 0.2\n", 235 | "2. 0.333333333333333\n", 236 | "3. 0.428571428571429\n", 237 | "\n", 238 | "\n" 239 | ], 240 | "text/plain": [ 241 | "[1] 0.2000000 0.3333333 0.4285714" 242 | ] 243 | }, 244 | "metadata": {}, 245 | "output_type": "display_data" 246 | } 247 | ], 248 | "source": [ 249 | "v1/v2" 250 | ] 251 | }, 252 | { 253 | "cell_type": "markdown", 254 | "metadata": {}, 255 | "source": [ 256 | "# Funktionen mit Vektoren\n", 257 | "\n", 258 | "Lasst uns als nächstes einige nützliche Funktionen lernen, die wir mit Vektoren nutzen können. Eine Funktion wird die folgende Form haben:\n", 259 | "\n", 260 | " name_der_funktion(input)\n", 261 | " \n", 262 | "Später werden wir außerdem noch lernen, wie wir unsere eigenen Funktionen erstellen. R selbst bietet jedoch viele vorinstallierte (en. build-in) Funktionen, die wir regelmäßig nutzen werden.\n", 263 | "\n", 264 | "Zum Beispiel: Wenn wir alle Elemente eines numerischen Vektors addieren wollen, können wir die `sum()` Funktion verwenden." 265 | ] 266 | }, 267 | { 268 | "cell_type": "code", 269 | "execution_count": 7, 270 | "metadata": {}, 271 | "outputs": [ 272 | { 273 | "data": { 274 | "text/html": [ 275 | "
    \n", 276 | "\t
  1. 1
    2. \n", 277 | "\t
  2. 2
    3. \n", 278 | "\t
  3. 3
    4. \n", 279 | "
\n" 280 | ], 281 | "text/latex": [ 282 | "\\begin{enumerate*}\n", 283 | "\\item 1\n", 284 | "\\item 2\n", 285 | "\\item 3\n", 286 | "\\end{enumerate*}\n" 287 | ], 288 | "text/markdown": [ 289 | "1. 1\n", 290 | "2. 2\n", 291 | "3. 3\n", 292 | "\n", 293 | "\n" 294 | ], 295 | "text/plain": [ 296 | "[1] 1 2 3" 297 | ] 298 | }, 299 | "metadata": {}, 300 | "output_type": "display_data" 301 | } 302 | ], 303 | "source": [ 304 | "v1" 305 | ] 306 | }, 307 | { 308 | "cell_type": "code", 309 | "execution_count": 8, 310 | "metadata": {}, 311 | "outputs": [ 312 | { 313 | "data": { 314 | "text/html": [ 315 | "6" 316 | ], 317 | "text/latex": [ 318 | "6" 319 | ], 320 | "text/markdown": [ 321 | "6" 322 | ], 323 | "text/plain": [ 324 | "[1] 6" 325 | ] 326 | }, 327 | "metadata": {}, 328 | "output_type": "display_data" 329 | } 330 | ], 331 | "source": [ 332 | "sum(v1)" 333 | ] 334 | }, 335 | { 336 | "cell_type": "markdown", 337 | "metadata": {}, 338 | "source": [ 339 | "Wir können außerem Dinge wie die Standardabweichung, Varianz, Maximum, Minimum und Produkt der Elemente abfragen:" 340 | ] 341 | }, 342 | { 343 | "cell_type": "code", 344 | "execution_count": 9, 345 | "metadata": { 346 | "collapsed": true 347 | }, 348 | "outputs": [], 349 | "source": [ 350 | "v <- c(12,45,100,2)" 351 | ] 352 | }, 353 | { 354 | "cell_type": "code", 355 | "execution_count": 10, 356 | "metadata": {}, 357 | "outputs": [ 358 | { 359 | "data": { 360 | "text/html": [ 361 | "44.1691823182937" 362 | ], 363 | "text/latex": [ 364 | "44.1691823182937" 365 | ], 366 | "text/markdown": [ 367 | "44.1691823182937" 368 | ], 369 | "text/plain": [ 370 | "[1] 44.16918" 371 | ] 372 | }, 373 | "metadata": {}, 374 | "output_type": "display_data" 375 | } 376 | ], 377 | "source": [ 378 | "# Standardabweichung\n", 379 | "sd(v)" 380 | ] 381 | }, 382 | { 383 | "cell_type": "code", 384 | "execution_count": 11, 385 | "metadata": {}, 386 | "outputs": [ 387 | { 388 | "data": { 389 | "text/html": [ 390 | "1950.91666666667" 391 | ], 392 | "text/latex": [ 393 | "1950.91666666667" 394 | ], 395 | "text/markdown": [ 396 | "1950.91666666667" 397 | ], 398 | "text/plain": [ 399 | "[1] 1950.917" 400 | ] 401 | }, 402 | "metadata": {}, 403 | "output_type": "display_data" 404 | } 405 | ], 406 | "source": [ 407 | "#Varianz\n", 408 | "var(v)" 409 | ] 410 | }, 411 | { 412 | "cell_type": "code", 413 | "execution_count": 12, 414 | "metadata": {}, 415 | "outputs": [ 416 | { 417 | "data": { 418 | "text/html": [ 419 | "100" 420 | ], 421 | "text/latex": [ 422 | "100" 423 | ], 424 | "text/markdown": [ 425 | "100" 426 | ], 427 | "text/plain": [ 428 | "[1] 100" 429 | ] 430 | }, 431 | "metadata": {}, 432 | "output_type": "display_data" 433 | } 434 | ], 435 | "source": [ 436 | "# Maximum Element\n", 437 | "max(v)" 438 | ] 439 | }, 440 | { 441 | "cell_type": "code", 442 | "execution_count": 13, 443 | "metadata": {}, 444 | "outputs": [ 445 | { 446 | "data": { 447 | "text/html": [ 448 | "2" 449 | ], 450 | "text/latex": [ 451 | "2" 452 | ], 453 | "text/markdown": [ 454 | "2" 455 | ], 456 | "text/plain": [ 457 | "[1] 2" 458 | ] 459 | }, 460 | "metadata": {}, 461 | "output_type": "display_data" 462 | } 463 | ], 464 | "source": [ 465 | "#Minimum Element\n", 466 | "min(v)" 467 | ] 468 | }, 469 | { 470 | "cell_type": "code", 471 | "execution_count": 14, 472 | "metadata": {}, 473 | "outputs": [ 474 | { 475 | "data": { 476 | "text/html": [ 477 | "6" 478 | ], 479 | "text/latex": [ 480 | "6" 481 | ], 482 | "text/markdown": [ 483 | "6" 484 | ], 485 | "text/plain": [ 486 | "[1] 6" 487 | ] 488 | }, 489 | "metadata": {}, 490 | "output_type": "display_data" 491 | }, 492 | { 493 | "data": { 494 | "text/html": [ 495 | "210" 496 | ], 497 | "text/latex": [ 498 | "210" 499 | ], 500 | "text/markdown": [ 501 | "210" 502 | ], 503 | "text/plain": [ 504 | "[1] 210" 505 | ] 506 | }, 507 | "metadata": {}, 508 | "output_type": "display_data" 509 | } 510 | ], 511 | "source": [ 512 | "# Produkt der Elemente\n", 513 | "prod(v1)\n", 514 | "prod(v2)" 515 | ] 516 | }, 517 | { 518 | "cell_type": "markdown", 519 | "metadata": {}, 520 | "source": [ 521 | "Das sind keineswegs alle Funktionen die es bereits vorinstalliert in R gibt! Wir werden sie im Verlauf des Kurses immer wieder verwenden, also müsst ihr sie euch auch noch nicht sofot einprägen. Je häufiger wir sie verwenden, desto leichter wird es uns fallen sie auswendig zu kennen. \n", 522 | "\n", 523 | "Für eine Übersicht aller verfügbaren Funktionen empfehle ich euch die [R Reference Card](https://cran.r-project.org/doc/contrib/Short-refcard.pdf)." 524 | ] 525 | }, 526 | { 527 | "cell_type": "markdown", 528 | "metadata": {}, 529 | "source": [ 530 | "Soweit so gut! Damit schließen wir die Lektion der Vektor Operationen ab." 531 | ] 532 | } 533 | ], 534 | "metadata": { 535 | "kernelspec": { 536 | "display_name": "R", 537 | "language": "R", 538 | "name": "ir" 539 | }, 540 | "language_info": { 541 | "codemirror_mode": "r", 542 | "file_extension": ".r", 543 | "mimetype": "text/x-r-source", 544 | "name": "R", 545 | "pygments_lexer": "r", 546 | "version": "3.4.2" 547 | } 548 | }, 549 | "nbformat": 4, 550 | "nbformat_minor": 1 551 | } 552 | -------------------------------------------------------------------------------- /1-Grundlagen von R und Datentypen/1-R Grundlagen/9-R Grundlagen Übung - Aufgaben.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# R Grundlagen Übung - Aufgaben\n", 8 | "\n", 9 | "Wir werden nun einige Themen überprüfen:\n", 10 | "\n", 11 | "* Grundlegende Datentypen\n", 12 | "* Grundlegende Arithmetik\n", 13 | "* Vektoren\n", 14 | "* Vektor Operationen\n", 15 | "* Vergleichsoperatoren\n", 16 | "* Vektor Auswahl und Indexierung\n", 17 | "\n", 18 | "Die nachfolgende Übung sollte selbsterklärend sein, sofern du die Lektionen angeschaut hast. Erwarte hier nichts besonders herausforderndes, da diese Aufgaben eher als Wiederholung ausgelegt sind. Gehe einfach sicher, dass du alles verstanden hast, da der Kurs auf diesen Grundlagen aufbaut! Später werden die Übungen und Projekte noch viel herausfordernder (und spaßiger!)." 19 | ] 20 | }, 21 | { 22 | "cell_type": "markdown", 23 | "metadata": {}, 24 | "source": [ 25 | "### Löse die folgenden Aufgaben mit R\n", 26 | "** Was ist zwei hoch fünf? **" 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": 1, 32 | "metadata": { 33 | "collapsed": false 34 | }, 35 | "outputs": [ 36 | { 37 | "data": { 38 | "text/html": [ 39 | "32" 40 | ], 41 | "text/latex": [ 42 | "32" 43 | ], 44 | "text/markdown": [ 45 | "32" 46 | ], 47 | "text/plain": [ 48 | "[1] 32" 49 | ] 50 | }, 51 | "metadata": {}, 52 | "output_type": "display_data" 53 | } 54 | ], 55 | "source": [] 56 | }, 57 | { 58 | "cell_type": "markdown", 59 | "metadata": {}, 60 | "source": [ 61 | "** Erstelle einen Vektor namens aktien.preise mit folgenden Datenpunkten: 23,27,23,21,34 **" 62 | ] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "execution_count": 2, 67 | "metadata": { 68 | "collapsed": false 69 | }, 70 | "outputs": [ 71 | { 72 | "data": { 73 | "text/html": [ 74 | "
    \n", 75 | "\t
  1. 23
    2. \n", 76 | "\t
  2. 27
    3. \n", 77 | "\t
  3. 23
    4. \n", 78 | "\t
  4. 21
    5. \n", 79 | "\t
  5. 34
    6. \n", 80 | "
\n" 81 | ], 82 | "text/latex": [ 83 | "\\begin{enumerate*}\n", 84 | "\\item 23\n", 85 | "\\item 27\n", 86 | "\\item 23\n", 87 | "\\item 21\n", 88 | "\\item 34\n", 89 | "\\end{enumerate*}\n" 90 | ], 91 | "text/markdown": [ 92 | "1. 23\n", 93 | "2. 27\n", 94 | "3. 23\n", 95 | "4. 21\n", 96 | "5. 34\n", 97 | "\n", 98 | "\n" 99 | ], 100 | "text/plain": [ 101 | "[1] 23 27 23 21 34" 102 | ] 103 | }, 104 | "metadata": {}, 105 | "output_type": "display_data" 106 | } 107 | ], 108 | "source": [] 109 | }, 110 | { 111 | "cell_type": "markdown", 112 | "metadata": {}, 113 | "source": [ 114 | "** Weise den Einträgen Namen zu, die bezug auf die Wochentage (Mo, Di, Mi, ...) nehmen**" 115 | ] 116 | }, 117 | { 118 | "cell_type": "code", 119 | "execution_count": 3, 120 | "metadata": { 121 | "collapsed": false 122 | }, 123 | "outputs": [ 124 | { 125 | "data": { 126 | "text/html": [ 127 | "
\n", 128 | "\t
Mo
\n", 129 | "\t\t
23
\n", 130 | "\t
Di
\n", 131 | "\t\t
27
\n", 132 | "\t
Mi
\n", 133 | "\t\t
23
\n", 134 | "\t
Do
\n", 135 | "\t\t
21
\n", 136 | "\t
Fr
\n", 137 | "\t\t
34
\n", 138 | "
\n" 139 | ], 140 | "text/latex": [ 141 | "\\begin{description*}\n", 142 | "\\item[Mo] 23\n", 143 | "\\item[Di] 27\n", 144 | "\\item[Mi] 23\n", 145 | "\\item[Do] 21\n", 146 | "\\item[Fr] 34\n", 147 | "\\end{description*}\n" 148 | ], 149 | "text/markdown": [ 150 | "Mo\n", 151 | ": 23Di\n", 152 | ": 27Mi\n", 153 | ": 23Do\n", 154 | ": 21Fr\n", 155 | ": 34\n", 156 | "\n" 157 | ], 158 | "text/plain": [ 159 | "Mo Di Mi Do Fr \n", 160 | "23 27 23 21 34 " 161 | ] 162 | }, 163 | "metadata": {}, 164 | "output_type": "display_data" 165 | } 166 | ], 167 | "source": [] 168 | }, 169 | { 170 | "cell_type": "markdown", 171 | "metadata": {}, 172 | "source": [ 173 | "**Was ist der durchschnittliche (en. mean) Aktienpreis dieser Woche? (Du könntest dazu eine eingebaute Funktion verwenden)**" 174 | ] 175 | }, 176 | { 177 | "cell_type": "code", 178 | "execution_count": 4, 179 | "metadata": { 180 | "collapsed": false 181 | }, 182 | "outputs": [ 183 | { 184 | "data": { 185 | "text/html": [ 186 | "25.6" 187 | ], 188 | "text/latex": [ 189 | "25.6" 190 | ], 191 | "text/markdown": [ 192 | "25.6" 193 | ], 194 | "text/plain": [ 195 | "[1] 25.6" 196 | ] 197 | }, 198 | "metadata": {}, 199 | "output_type": "display_data" 200 | } 201 | ], 202 | "source": [] 203 | }, 204 | { 205 | "cell_type": "markdown", 206 | "metadata": {}, 207 | "source": [ 208 | "** Erstelle einen Vektor namens ueber.23, der aus logischen Werten besteht, die beschreiben, ob der Preis an einem Tag über 23 lag**" 209 | ] 210 | }, 211 | { 212 | "cell_type": "code", 213 | "execution_count": 5, 214 | "metadata": { 215 | "collapsed": true 216 | }, 217 | "outputs": [], 218 | "source": [] 219 | }, 220 | { 221 | "cell_type": "markdown", 222 | "metadata": {}, 223 | "source": [ 224 | "** Nutze nun den ueber.23 Vektor, um aus aktien.preise alle Preise zu filtern, die über 23 lagen**" 225 | ] 226 | }, 227 | { 228 | "cell_type": "code", 229 | "execution_count": 6, 230 | "metadata": { 231 | "collapsed": false 232 | }, 233 | "outputs": [ 234 | { 235 | "data": { 236 | "text/html": [ 237 | "
\n", 238 | "\t
Di
\n", 239 | "\t\t
27
\n", 240 | "\t
Fr
\n", 241 | "\t\t
34
\n", 242 | "
\n" 243 | ], 244 | "text/latex": [ 245 | "\\begin{description*}\n", 246 | "\\item[Di] 27\n", 247 | "\\item[Fr] 34\n", 248 | "\\end{description*}\n" 249 | ], 250 | "text/markdown": [ 251 | "Di\n", 252 | ": 27Fr\n", 253 | ": 34\n", 254 | "\n" 255 | ], 256 | "text/plain": [ 257 | "Di Fr \n", 258 | "27 34 " 259 | ] 260 | }, 261 | "metadata": {}, 262 | "output_type": "display_data" 263 | } 264 | ], 265 | "source": [] 266 | }, 267 | { 268 | "cell_type": "markdown", 269 | "metadata": {}, 270 | "source": [ 271 | "** Nutze eine eingebaute Funktion, um herauszufinden wann der Aktienpreis am höchsten war**" 272 | ] 273 | }, 274 | { 275 | "cell_type": "code", 276 | "execution_count": 7, 277 | "metadata": { 278 | "collapsed": false 279 | }, 280 | "outputs": [ 281 | { 282 | "data": { 283 | "text/html": [ 284 | "34" 285 | ], 286 | "text/latex": [ 287 | "34" 288 | ], 289 | "text/markdown": [ 290 | "34" 291 | ], 292 | "text/plain": [ 293 | "[1] 34" 294 | ] 295 | }, 296 | "metadata": {}, 297 | "output_type": "display_data" 298 | } 299 | ], 300 | "source": [] 301 | }, 302 | { 303 | "cell_type": "markdown", 304 | "metadata": {}, 305 | "source": [ 306 | "** Das hat uns nicht wirklich den Tag verraten. Lasst uns einen Filter benutzen, um den Wochentag zu erhalten!**" 307 | ] 308 | }, 309 | { 310 | "cell_type": "code", 311 | "execution_count": 8, 312 | "metadata": { 313 | "collapsed": false 314 | }, 315 | "outputs": [ 316 | { 317 | "data": { 318 | "text/html": [ 319 | "
\n", 320 | "\t
Mo
\n", 321 | "\t\t
FALSE
\n", 322 | "\t
Di
\n", 323 | "\t\t
FALSE
\n", 324 | "\t
Mi
\n", 325 | "\t\t
FALSE
\n", 326 | "\t
Do
\n", 327 | "\t\t
FALSE
\n", 328 | "\t
Fr
\n", 329 | "\t\t
TRUE
\n", 330 | "
\n" 331 | ], 332 | "text/latex": [ 333 | "\\begin{description*}\n", 334 | "\\item[Mo] FALSE\n", 335 | "\\item[Di] FALSE\n", 336 | "\\item[Mi] FALSE\n", 337 | "\\item[Do] FALSE\n", 338 | "\\item[Fr] TRUE\n", 339 | "\\end{description*}\n" 340 | ], 341 | "text/markdown": [ 342 | "Mo\n", 343 | ": FALSEDi\n", 344 | ": FALSEMi\n", 345 | ": FALSEDo\n", 346 | ": FALSEFr\n", 347 | ": TRUE\n", 348 | "\n" 349 | ], 350 | "text/plain": [ 351 | " Mo Di Mi Do Fr \n", 352 | "FALSE FALSE FALSE FALSE TRUE " 353 | ] 354 | }, 355 | "metadata": {}, 356 | "output_type": "display_data" 357 | } 358 | ], 359 | "source": [] 360 | }, 361 | { 362 | "cell_type": "code", 363 | "execution_count": 9, 364 | "metadata": { 365 | "collapsed": false 366 | }, 367 | "outputs": [ 368 | { 369 | "data": { 370 | "text/html": [ 371 | "Fr: 34" 372 | ], 373 | "text/latex": [ 374 | "\\textbf{Fr:} 34" 375 | ], 376 | "text/markdown": [ 377 | "**Fr:** 34" 378 | ], 379 | "text/plain": [ 380 | "Fr \n", 381 | "34 " 382 | ] 383 | }, 384 | "metadata": {}, 385 | "output_type": "display_data" 386 | } 387 | ], 388 | "source": [] 389 | }, 390 | { 391 | "cell_type": "markdown", 392 | "metadata": {}, 393 | "source": [ 394 | "Okay, das wars zur Übung der Grundlagen. Gut gemacht!" 395 | ] 396 | } 397 | ], 398 | "metadata": { 399 | "kernelspec": { 400 | "display_name": "Python 3", 401 | "language": "python", 402 | "name": "python3" 403 | }, 404 | "language_info": { 405 | "codemirror_mode": { 406 | "name": "ipython", 407 | "version": 3 408 | }, 409 | "file_extension": ".py", 410 | "mimetype": "text/x-python", 411 | "name": "python", 412 | "nbconvert_exporter": "python", 413 | "pygments_lexer": "ipython3", 414 | "version": "3.6.0" 415 | } 416 | }, 417 | "nbformat": 4, 418 | "nbformat_minor": 1 419 | } 420 | -------------------------------------------------------------------------------- /1-Grundlagen von R und Datentypen/1-R Grundlagen/9-R Grundlagen Übung - Aufgaben.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# R Grundlagen Übung - Aufgaben\n", 8 | "\n", 9 | "Wir werden nun einige Themen überprüfen:\n", 10 | "\n", 11 | "* Grundlegende Datentypen\n", 12 | "* Grundlegende Arithmetik\n", 13 | "* Vektoren\n", 14 | "* Vektor Operationen\n", 15 | "* Vergleichsoperatoren\n", 16 | "* Vektor Auswahl und Indexierung\n", 17 | "\n", 18 | "Die nachfolgende Übung sollte selbsterklärend sein, sofern du die Lektionen angeschaut hast. Erwarte hier nichts besonders herausforderndes, da diese Aufgaben eher als Wiederholung ausgelegt sind. Gehe einfach sicher, dass du alles verstanden hast, da der Kurs auf diesen Grundlagen aufbaut! Später werden die Übungen und Projekte noch viel herausfordernder (und spaßiger!)." 19 | ] 20 | }, 21 | { 22 | "cell_type": "markdown", 23 | "metadata": {}, 24 | "source": [ 25 | "### Löse die folgenden Aufgaben mit R\n", 26 | "** Was ist zwei hoch fünf? **" 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": 1, 32 | "metadata": { 33 | "collapsed": false 34 | }, 35 | "outputs": [ 36 | { 37 | "data": { 38 | "text/html": [ 39 | "32" 40 | ], 41 | "text/latex": [ 42 | "32" 43 | ], 44 | "text/markdown": [ 45 | "32" 46 | ], 47 | "text/plain": [ 48 | "[1] 32" 49 | ] 50 | }, 51 | "metadata": {}, 52 | "output_type": "display_data" 53 | } 54 | ], 55 | "source": [] 56 | }, 57 | { 58 | "cell_type": "markdown", 59 | "metadata": {}, 60 | "source": [ 61 | "** Erstelle einen Vektor namens aktien.preise mit folgenden Datenpunkten: 23,27,23,21,34 **" 62 | ] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "execution_count": 2, 67 | "metadata": { 68 | "collapsed": false 69 | }, 70 | "outputs": [ 71 | { 72 | "data": { 73 | "text/html": [ 74 | "
    \n", 75 | "\t
  1. 23
    2. \n", 76 | "\t
  2. 27
    3. \n", 77 | "\t
  3. 23
    4. \n", 78 | "\t
  4. 21
    5. \n", 79 | "\t
  5. 34
    6. \n", 80 | "
\n" 81 | ], 82 | "text/latex": [ 83 | "\\begin{enumerate*}\n", 84 | "\\item 23\n", 85 | "\\item 27\n", 86 | "\\item 23\n", 87 | "\\item 21\n", 88 | "\\item 34\n", 89 | "\\end{enumerate*}\n" 90 | ], 91 | "text/markdown": [ 92 | "1. 23\n", 93 | "2. 27\n", 94 | "3. 23\n", 95 | "4. 21\n", 96 | "5. 34\n", 97 | "\n", 98 | "\n" 99 | ], 100 | "text/plain": [ 101 | "[1] 23 27 23 21 34" 102 | ] 103 | }, 104 | "metadata": {}, 105 | "output_type": "display_data" 106 | } 107 | ], 108 | "source": [] 109 | }, 110 | { 111 | "cell_type": "markdown", 112 | "metadata": {}, 113 | "source": [ 114 | "** Weise den Einträgen Namen zu, die bezug auf die Wochentage (Mo, Di, Mi, ...) nehmen**" 115 | ] 116 | }, 117 | { 118 | "cell_type": "code", 119 | "execution_count": 3, 120 | "metadata": { 121 | "collapsed": false 122 | }, 123 | "outputs": [ 124 | { 125 | "data": { 126 | "text/html": [ 127 | "
\n", 128 | "\t
Mo
\n", 129 | "\t\t
23
\n", 130 | "\t
Di
\n", 131 | "\t\t
27
\n", 132 | "\t
Mi
\n", 133 | "\t\t
23
\n", 134 | "\t
Do
\n", 135 | "\t\t
21
\n", 136 | "\t
Fr
\n", 137 | "\t\t
34
\n", 138 | "
\n" 139 | ], 140 | "text/latex": [ 141 | "\\begin{description*}\n", 142 | "\\item[Mo] 23\n", 143 | "\\item[Di] 27\n", 144 | "\\item[Mi] 23\n", 145 | "\\item[Do] 21\n", 146 | "\\item[Fr] 34\n", 147 | "\\end{description*}\n" 148 | ], 149 | "text/markdown": [ 150 | "Mo\n", 151 | ": 23Di\n", 152 | ": 27Mi\n", 153 | ": 23Do\n", 154 | ": 21Fr\n", 155 | ": 34\n", 156 | "\n" 157 | ], 158 | "text/plain": [ 159 | "Mo Di Mi Do Fr \n", 160 | "23 27 23 21 34 " 161 | ] 162 | }, 163 | "metadata": {}, 164 | "output_type": "display_data" 165 | } 166 | ], 167 | "source": [] 168 | }, 169 | { 170 | "cell_type": "markdown", 171 | "metadata": {}, 172 | "source": [ 173 | "**Was ist der durchschnittliche (en. mean) Aktienpreis dieser Woche? (Du könntest dazu eine eingebaute Funktion verwenden)**" 174 | ] 175 | }, 176 | { 177 | "cell_type": "code", 178 | "execution_count": 4, 179 | "metadata": { 180 | "collapsed": false 181 | }, 182 | "outputs": [ 183 | { 184 | "data": { 185 | "text/html": [ 186 | "25.6" 187 | ], 188 | "text/latex": [ 189 | "25.6" 190 | ], 191 | "text/markdown": [ 192 | "25.6" 193 | ], 194 | "text/plain": [ 195 | "[1] 25.6" 196 | ] 197 | }, 198 | "metadata": {}, 199 | "output_type": "display_data" 200 | } 201 | ], 202 | "source": [] 203 | }, 204 | { 205 | "cell_type": "markdown", 206 | "metadata": {}, 207 | "source": [ 208 | "** Erstelle einen Vektor namens ueber.23, der aus logischen Werten besteht, die beschreiben, ob der Preis an einem Tag über 23 lag**" 209 | ] 210 | }, 211 | { 212 | "cell_type": "code", 213 | "execution_count": 5, 214 | "metadata": { 215 | "collapsed": true 216 | }, 217 | "outputs": [], 218 | "source": [] 219 | }, 220 | { 221 | "cell_type": "markdown", 222 | "metadata": {}, 223 | "source": [ 224 | "** Nutze nun den ueber.23 Vektor, um aus aktien.preise alle Preise zu filtern, die über 23 lagen**" 225 | ] 226 | }, 227 | { 228 | "cell_type": "code", 229 | "execution_count": 6, 230 | "metadata": { 231 | "collapsed": false 232 | }, 233 | "outputs": [ 234 | { 235 | "data": { 236 | "text/html": [ 237 | "
\n", 238 | "\t
Di
\n", 239 | "\t\t
27
\n", 240 | "\t
Fr
\n", 241 | "\t\t
34
\n", 242 | "
\n" 243 | ], 244 | "text/latex": [ 245 | "\\begin{description*}\n", 246 | "\\item[Di] 27\n", 247 | "\\item[Fr] 34\n", 248 | "\\end{description*}\n" 249 | ], 250 | "text/markdown": [ 251 | "Di\n", 252 | ": 27Fr\n", 253 | ": 34\n", 254 | "\n" 255 | ], 256 | "text/plain": [ 257 | "Di Fr \n", 258 | "27 34 " 259 | ] 260 | }, 261 | "metadata": {}, 262 | "output_type": "display_data" 263 | } 264 | ], 265 | "source": [] 266 | }, 267 | { 268 | "cell_type": "markdown", 269 | "metadata": {}, 270 | "source": [ 271 | "** Nutze eine eingebaute Funktion, um herauszufinden wann der Aktienpreis am höchsten war**" 272 | ] 273 | }, 274 | { 275 | "cell_type": "code", 276 | "execution_count": 7, 277 | "metadata": { 278 | "collapsed": false 279 | }, 280 | "outputs": [ 281 | { 282 | "data": { 283 | "text/html": [ 284 | "34" 285 | ], 286 | "text/latex": [ 287 | "34" 288 | ], 289 | "text/markdown": [ 290 | "34" 291 | ], 292 | "text/plain": [ 293 | "[1] 34" 294 | ] 295 | }, 296 | "metadata": {}, 297 | "output_type": "display_data" 298 | } 299 | ], 300 | "source": [] 301 | }, 302 | { 303 | "cell_type": "markdown", 304 | "metadata": {}, 305 | "source": [ 306 | "** Das hat uns nicht wirklich den Tag verraten. Lasst uns einen Filter benutzen, um den Wochentag zu erhalten!**" 307 | ] 308 | }, 309 | { 310 | "cell_type": "code", 311 | "execution_count": 8, 312 | "metadata": { 313 | "collapsed": false 314 | }, 315 | "outputs": [ 316 | { 317 | "data": { 318 | "text/html": [ 319 | "
\n", 320 | "\t
Mo
\n", 321 | "\t\t
FALSE
\n", 322 | "\t
Di
\n", 323 | "\t\t
FALSE
\n", 324 | "\t
Mi
\n", 325 | "\t\t
FALSE
\n", 326 | "\t
Do
\n", 327 | "\t\t
FALSE
\n", 328 | "\t
Fr
\n", 329 | "\t\t
TRUE
\n", 330 | "
\n" 331 | ], 332 | "text/latex": [ 333 | "\\begin{description*}\n", 334 | "\\item[Mo] FALSE\n", 335 | "\\item[Di] FALSE\n", 336 | "\\item[Mi] FALSE\n", 337 | "\\item[Do] FALSE\n", 338 | "\\item[Fr] TRUE\n", 339 | "\\end{description*}\n" 340 | ], 341 | "text/markdown": [ 342 | "Mo\n", 343 | ": FALSEDi\n", 344 | ": FALSEMi\n", 345 | ": FALSEDo\n", 346 | ": FALSEFr\n", 347 | ": TRUE\n", 348 | "\n" 349 | ], 350 | "text/plain": [ 351 | " Mo Di Mi Do Fr \n", 352 | "FALSE FALSE FALSE FALSE TRUE " 353 | ] 354 | }, 355 | "metadata": {}, 356 | "output_type": "display_data" 357 | } 358 | ], 359 | "source": [] 360 | }, 361 | { 362 | "cell_type": "code", 363 | "execution_count": 9, 364 | "metadata": { 365 | "collapsed": false 366 | }, 367 | "outputs": [ 368 | { 369 | "data": { 370 | "text/html": [ 371 | "Fr: 34" 372 | ], 373 | "text/latex": [ 374 | "\\textbf{Fr:} 34" 375 | ], 376 | "text/markdown": [ 377 | "**Fr:** 34" 378 | ], 379 | "text/plain": [ 380 | "Fr \n", 381 | "34 " 382 | ] 383 | }, 384 | "metadata": {}, 385 | "output_type": "display_data" 386 | } 387 | ], 388 | "source": [] 389 | }, 390 | { 391 | "cell_type": "markdown", 392 | "metadata": {}, 393 | "source": [ 394 | "Okay, das wars zur Übung der Grundlagen. Gut gemacht!" 395 | ] 396 | } 397 | ], 398 | "metadata": { 399 | "kernelspec": { 400 | "display_name": "Python 3", 401 | "language": "python", 402 | "name": "python3" 403 | }, 404 | "language_info": { 405 | "codemirror_mode": { 406 | "name": "ipython", 407 | "version": 3 408 | }, 409 | "file_extension": ".py", 410 | "mimetype": "text/x-python", 411 | "name": "python", 412 | "nbconvert_exporter": "python", 413 | "pygments_lexer": "ipython3", 414 | "version": "3.6.0" 415 | } 416 | }, 417 | "nbformat": 4, 418 | "nbformat_minor": 1 419 | } 420 | -------------------------------------------------------------------------------- /1-Grundlagen von R und Datentypen/2-R Matrizen/5-Faktor und kategorische Matrizen.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Faktor und kategorische Matrizen\n", 8 | "\n", 9 | "In dieser Lektion werden wir die `factor()` Funktion besprechen. Sie wird dazu genutzt kategorische Matrizen zu erstellen. Diese spezielle Funktion wird insbesondere dann nützlich sein, wenn wir die Datenanalyse und Machine Learning Techniken auf unsere Daten anwenden. In Zusammenhang damit steht das Konzept der *Dummy Variablen*.\n", 10 | "\n", 11 | "Beginnen wir damit ein Beispiel zu betrachten, wie wir eine solche Matrix erstellen. Stellen wir uns vor, der folgende Vektor gibt uns Informationen über eine jährliche Zählung in einem Tierheim. Jeder Hund (\"h\") und jede Katze (\"k\") wird notiert und hat eine eigene ID, die in einem zweiten Vektor gespeichert ist." 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 4, 17 | "metadata": { 18 | "collapsed": true 19 | }, 20 | "outputs": [], 21 | "source": [ 22 | "tiere <- c('h','k','h','k','k')\n", 23 | "id <- c(1,2,3,4,5)" 24 | ] 25 | }, 26 | { 27 | "cell_type": "markdown", 28 | "metadata": {}, 29 | "source": [ 30 | "Wir wollen nun den Tier-Vektor in eine Form bringen, die ein Algoritmus oder eine Geichung leichter verstehen kann. Dazu beginnen wir mit der Überprüfung, wie viele Kategorien (d.h. Faktor Level) es in unsere Zeichen-Vektor gibt.\n", 31 | "\n", 32 | "Wir können unseren Vektor an die `factor()` Funktion übergeben, um diese Information zu erhalten:" 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": 5, 38 | "metadata": { 39 | "collapsed": true 40 | }, 41 | "outputs": [], 42 | "source": [ 43 | "factor.tiere <- factor(tiere)" 44 | ] 45 | }, 46 | { 47 | "cell_type": "code", 48 | "execution_count": 6, 49 | "metadata": { 50 | "collapsed": false 51 | }, 52 | "outputs": [ 53 | { 54 | "data": { 55 | "text/html": [ 56 | "
    \n", 57 | "\t
  1. h
    2. \n", 58 | "\t
  2. k
    3. \n", 59 | "\t
  3. h
    4. \n", 60 | "\t
  4. k
    5. \n", 61 | "\t
  5. k
    6. \n", 62 | "
\n" 63 | ], 64 | "text/latex": [ 65 | "\\begin{enumerate*}\n", 66 | "\\item h\n", 67 | "\\item k\n", 68 | "\\item h\n", 69 | "\\item k\n", 70 | "\\item k\n", 71 | "\\end{enumerate*}\n" 72 | ], 73 | "text/markdown": [ 74 | "1. h\n", 75 | "2. k\n", 76 | "3. h\n", 77 | "4. k\n", 78 | "5. k\n", 79 | "\n", 80 | "\n" 81 | ], 82 | "text/plain": [ 83 | "[1] h k h k k\n", 84 | "Levels: h k" 85 | ] 86 | }, 87 | "metadata": {}, 88 | "output_type": "display_data" 89 | } 90 | ], 91 | "source": [ 92 | "# Zeigt in RStudio sowie der R Konsole die Level an\n", 93 | "factor.tiere" 94 | ] 95 | }, 96 | { 97 | "cell_type": "markdown", 98 | "metadata": {}, 99 | "source": [ 100 | "Wir sehen, dass es zwei Level gibt: \"h\" und \"k\". In R gibt es zwei unterschiedliche Typen von kategorischen Variablen: **Ordinal kategorische Variablen** und **nominal kategorische Variablen**.\n", 101 | "\n", 102 | "Nominal kategorische Variablen haben keine bestimmte Reihenfolge (so wie unsere Hunde und Katzen). Ordinal kategorische Variablen auf der anderen Seite weisen eine bestimmte Reihenfolge auf. So wie folgendes Beispiel:" 103 | ] 104 | }, 105 | { 106 | "cell_type": "code", 107 | "execution_count": 7, 108 | "metadata": { 109 | "collapsed": true 110 | }, 111 | "outputs": [], 112 | "source": [ 113 | "ord.kat <- c('kalt','lau','warm')" 114 | ] 115 | }, 116 | { 117 | "cell_type": "markdown", 118 | "metadata": {}, 119 | "source": [ 120 | "Wir können nun damit beginnen die Reihenfolge wie folgt festzulegen:\n", 121 | "\n", 122 | " kalt < lau < warm\n", 123 | " \n", 124 | "Sofern wir die Reihenfolge direkt mit der `factor()` Funktion kombinieren wollen, können wir das Argument `ordered=True` übergeben. Zusätzlich benötigen wir dann das `leves=` Argument sowie einen Vektor, der die Reihenfolge korrekt abbildet." 125 | ] 126 | }, 127 | { 128 | "cell_type": "code", 129 | "execution_count": 8, 130 | "metadata": { 131 | "collapsed": false 132 | }, 133 | "outputs": [ 134 | { 135 | "data": { 136 | "text/html": [ 137 | "
    \n", 138 | "\t
  1. kalt
    2. \n", 139 | "\t
  2. lau
    3. \n", 140 | "\t
  3. warm
    4. \n", 141 | "\t
  4. lau
    5. \n", 142 | "\t
  5. warm
    6. \n", 143 | "\t
  6. warm
    7. \n", 144 | "\t
  7. kalt
    8. \n", 145 | "
\n" 146 | ], 147 | "text/latex": [ 148 | "\\begin{enumerate*}\n", 149 | "\\item kalt\n", 150 | "\\item lau\n", 151 | "\\item warm\n", 152 | "\\item lau\n", 153 | "\\item warm\n", 154 | "\\item warm\n", 155 | "\\item kalt\n", 156 | "\\end{enumerate*}\n" 157 | ], 158 | "text/markdown": [ 159 | "1. kalt\n", 160 | "2. lau\n", 161 | "3. warm\n", 162 | "4. lau\n", 163 | "5. warm\n", 164 | "6. warm\n", 165 | "7. kalt\n", 166 | "\n", 167 | "\n" 168 | ], 169 | "text/plain": [ 170 | "[1] kalt lau warm lau warm warm kalt\n", 171 | "Levels: kalt < lau < warm" 172 | ] 173 | }, 174 | "metadata": {}, 175 | "output_type": "display_data" 176 | } 177 | ], 178 | "source": [ 179 | "temp <- c('kalt','lau','warm','lau','warm','warm','kalt')\n", 180 | "fact.temp <- factor(temp,ordered=TRUE,levels=c('kalt','lau','warm'))\n", 181 | "fact.temp" 182 | ] 183 | }, 184 | { 185 | "cell_type": "markdown", 186 | "metadata": {}, 187 | "source": [ 188 | "Diese zusätzliche Information ist beispielsweise in Kombination mit der `summary()` Funktion nützlich. Diese Funktion wird häufig eingesetzt, um einen schnellen ersten Eindruck einer Matrix oder eiens Vektors zu erhalten." 189 | ] 190 | }, 191 | { 192 | "cell_type": "code", 193 | "execution_count": 9, 194 | "metadata": { 195 | "collapsed": false 196 | }, 197 | "outputs": [ 198 | { 199 | "data": { 200 | "text/plain": [ 201 | " Length Class Mode \n", 202 | " 7 character character " 203 | ] 204 | }, 205 | "metadata": {}, 206 | "output_type": "display_data" 207 | } 208 | ], 209 | "source": [ 210 | "summary(fact.temp)" 211 | ] 212 | }, 213 | { 214 | "cell_type": "code", 215 | "execution_count": 10, 216 | "metadata": { 217 | "collapsed": false 218 | }, 219 | "outputs": [ 220 | { 221 | "data": { 222 | "text/html": [ 223 | "
\n", 224 | "\t
kalt
\n", 225 | "\t\t
2
\n", 226 | "\t
lau
\n", 227 | "\t\t
2
\n", 228 | "\t
warm
\n", 229 | "\t\t
3
\n", 230 | "
\n" 231 | ], 232 | "text/latex": [ 233 | "\\begin{description*}\n", 234 | "\\item[kalt] 2\n", 235 | "\\item[lau] 2\n", 236 | "\\item[warm] 3\n", 237 | "\\end{description*}\n" 238 | ], 239 | "text/markdown": [ 240 | "kalt\n", 241 | ": 2lau\n", 242 | ": 2warm\n", 243 | ": 3\n", 244 | "\n" 245 | ], 246 | "text/plain": [ 247 | "kalt lau warm \n", 248 | " 2 2 3 " 249 | ] 250 | }, 251 | "metadata": {}, 252 | "output_type": "display_data" 253 | } 254 | ], 255 | "source": [ 256 | "summary(fact.temp)" 257 | ] 258 | }, 259 | { 260 | "cell_type": "markdown", 261 | "metadata": {}, 262 | "source": [ 263 | "Später werden wir auf die `factor()` Funktion on Kombination mit `ordered` zurückkommen. Soweit ist das alles, was wir wissen müssen." 264 | ] 265 | } 266 | ], 267 | "metadata": { 268 | "kernelspec": { 269 | "display_name": "Python 3", 270 | "language": "python", 271 | "name": "python3" 272 | }, 273 | "language_info": { 274 | "codemirror_mode": { 275 | "name": "ipython", 276 | "version": 3 277 | }, 278 | "file_extension": ".py", 279 | "mimetype": "text/x-python", 280 | "name": "python", 281 | "nbconvert_exporter": "python", 282 | "pygments_lexer": "ipython3", 283 | "version": "3.6.0" 284 | } 285 | }, 286 | "nbformat": 4, 287 | "nbformat_minor": 1 288 | } 289 | -------------------------------------------------------------------------------- /1-Grundlagen von R und Datentypen/2-R Matrizen/6-R Matrizen Übung - Aufgaben.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# R Matrizen Übung - Aufgaben\n", 8 | "\n", 9 | "Im Verlauf dieser Übung werden wir die Datenstruktur \"Matrix\" wiederholen. Als kleinen Bonus wird es außerdem etwas zum selbst entdecken geben." 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "**Erstelle 2 Vektoren A und B. A soll die Werte (1,2,3) beinhalten und B die Werte (4,5,6). Mit diesen Vektoren verwende entweder `cbind()` oder `rbind()`, um eine Matrix im Format 2 mal 3 zu erstellen. Nur eine der Verknüpfungsfunktionen ist hier richtig!**" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 1, 22 | "metadata": { 23 | "collapsed": false 24 | }, 25 | "outputs": [ 26 | { 27 | "data": { 28 | "text/html": [ 29 | "\n", 30 | "\n", 31 | "\t\n", 32 | "\t\n", 33 | "\n", 34 | "
A123
B456
\n" 35 | ], 36 | "text/latex": [ 37 | "\\begin{tabular}{r|lll}\n", 38 | "\tA & 1 & 2 & 3\\\\\n", 39 | "\tB & 4 & 5 & 6\\\\\n", 40 | "\\end{tabular}\n" 41 | ], 42 | "text/markdown": [ 43 | "\n", 44 | "| A | 1 | 2 | 3 | \n", 45 | "| B | 4 | 5 | 6 | \n", 46 | "\n", 47 | "\n" 48 | ], 49 | "text/plain": [ 50 | " [,1] [,2] [,3]\n", 51 | "A 1 2 3 \n", 52 | "B 4 5 6 " 53 | ] 54 | }, 55 | "metadata": {}, 56 | "output_type": "display_data" 57 | } 58 | ], 59 | "source": [] 60 | }, 61 | { 62 | "cell_type": "markdown", 63 | "metadata": {}, 64 | "source": [ 65 | "**Erstelle eine 3 mal 3 Matrix, die die Zahlen 1 bis 9 beinhaltet. Diese Matrix soll durch das Kürzel 1:9 erstellt werden und durch Definition des nrow Parametwers in der matrix() Funktion. Weise diese Matrix der Varaiblen *mat* zu.**" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": 2, 71 | "metadata": { 72 | "collapsed": true 73 | }, 74 | "outputs": [], 75 | "source": [] 76 | }, 77 | { 78 | "cell_type": "markdown", 79 | "metadata": {}, 80 | "source": [ 81 | "**Überprüfe, ob *mat* wirklich eine Matrix ist. Tipp: is.matrix() **" 82 | ] 83 | }, 84 | { 85 | "cell_type": "code", 86 | "execution_count": 3, 87 | "metadata": { 88 | "collapsed": false 89 | }, 90 | "outputs": [ 91 | { 92 | "data": { 93 | "text/html": [ 94 | "TRUE" 95 | ], 96 | "text/latex": [ 97 | "TRUE" 98 | ], 99 | "text/markdown": [ 100 | "TRUE" 101 | ], 102 | "text/plain": [ 103 | "[1] TRUE" 104 | ] 105 | }, 106 | "metadata": {}, 107 | "output_type": "display_data" 108 | } 109 | ], 110 | "source": [] 111 | }, 112 | { 113 | "cell_type": "markdown", 114 | "metadata": {}, 115 | "source": [ 116 | "** Erstelle eine 5 mal 5 Matrix, die die Zahlen 1 bis 25 enthält. Diese soll den Namen *mat2* haben. Die oberste Zeile soll außerdem die Werte 1 bis 5 beinhalten.**" 117 | ] 118 | }, 119 | { 120 | "cell_type": "code", 121 | "execution_count": 4, 122 | "metadata": { 123 | "collapsed": false 124 | }, 125 | "outputs": [ 126 | { 127 | "data": { 128 | "text/html": [ 129 | "\n", 130 | "\n", 131 | "\t\n", 132 | "\t\n", 133 | "\t\n", 134 | "\t\n", 135 | "\t\n", 136 | "\n", 137 | "
1 2 3 4 5
6 7 8 910
1112131415
1617181920
2122232425
\n" 138 | ], 139 | "text/latex": [ 140 | "\\begin{tabular}{lllll}\n", 141 | "\t 1 & 2 & 3 & 4 & 5\\\\\n", 142 | "\t 6 & 7 & 8 & 9 & 10\\\\\n", 143 | "\t 11 & 12 & 13 & 14 & 15\\\\\n", 144 | "\t 16 & 17 & 18 & 19 & 20\\\\\n", 145 | "\t 21 & 22 & 23 & 24 & 25\\\\\n", 146 | "\\end{tabular}\n" 147 | ], 148 | "text/markdown": [ 149 | "\n", 150 | "| 1 | 2 | 3 | 4 | 5 | \n", 151 | "| 6 | 7 | 8 | 9 | 10 | \n", 152 | "| 11 | 12 | 13 | 14 | 15 | \n", 153 | "| 16 | 17 | 18 | 19 | 20 | \n", 154 | "| 21 | 22 | 23 | 24 | 25 | \n", 155 | "\n", 156 | "\n" 157 | ], 158 | "text/plain": [ 159 | " [,1] [,2] [,3] [,4] [,5]\n", 160 | "[1,] 1 2 3 4 5 \n", 161 | "[2,] 6 7 8 9 10 \n", 162 | "[3,] 11 12 13 14 15 \n", 163 | "[4,] 16 17 18 19 20 \n", 164 | "[5,] 21 22 23 24 25 " 165 | ] 166 | }, 167 | "metadata": {}, 168 | "output_type": "display_data" 169 | } 170 | ], 171 | "source": [] 172 | }, 173 | { 174 | "cell_type": "markdown", 175 | "metadata": {}, 176 | "source": [ 177 | "** Nutze die Index Notation, um einen Ausschnitt von *mat2* auszuwählen. Dieser soll wie folgt aussehen:**\n", 178 | "\n", 179 | " [7,8]\n", 180 | " [12,13]" 181 | ] 182 | }, 183 | { 184 | "cell_type": "code", 185 | "execution_count": 5, 186 | "metadata": { 187 | "collapsed": false 188 | }, 189 | "outputs": [ 190 | { 191 | "data": { 192 | "text/html": [ 193 | "\n", 194 | "\n", 195 | "\t\n", 196 | "\t\n", 197 | "\n", 198 | "
7 8
1213
\n" 199 | ], 200 | "text/latex": [ 201 | "\\begin{tabular}{ll}\n", 202 | "\t 7 & 8\\\\\n", 203 | "\t 12 & 13\\\\\n", 204 | "\\end{tabular}\n" 205 | ], 206 | "text/markdown": [ 207 | "\n", 208 | "| 7 | 8 | \n", 209 | "| 12 | 13 | \n", 210 | "\n", 211 | "\n" 212 | ], 213 | "text/plain": [ 214 | " [,1] [,2]\n", 215 | "[1,] 7 8 \n", 216 | "[2,] 12 13 " 217 | ] 218 | }, 219 | "metadata": {}, 220 | "output_type": "display_data" 221 | } 222 | ], 223 | "source": [] 224 | }, 225 | { 226 | "cell_type": "markdown", 227 | "metadata": {}, 228 | "source": [ 229 | "** Nutze die Index Notation, um einen Ausschnitt von *mat2* auszuwählen. Dieser soll wie folgt aussehen:**\n", 230 | "\n", 231 | " [19,20]\n", 232 | " [24,25]" 233 | ] 234 | }, 235 | { 236 | "cell_type": "code", 237 | "execution_count": 6, 238 | "metadata": { 239 | "collapsed": false 240 | }, 241 | "outputs": [ 242 | { 243 | "data": { 244 | "text/html": [ 245 | "\n", 246 | "\n", 247 | "\t\n", 248 | "\t\n", 249 | "\n", 250 | "
1920
2425
\n" 251 | ], 252 | "text/latex": [ 253 | "\\begin{tabular}{ll}\n", 254 | "\t 19 & 20\\\\\n", 255 | "\t 24 & 25\\\\\n", 256 | "\\end{tabular}\n" 257 | ], 258 | "text/markdown": [ 259 | "\n", 260 | "| 19 | 20 | \n", 261 | "| 24 | 25 | \n", 262 | "\n", 263 | "\n" 264 | ], 265 | "text/plain": [ 266 | " [,1] [,2]\n", 267 | "[1,] 19 20 \n", 268 | "[2,] 24 25 " 269 | ] 270 | }, 271 | "metadata": {}, 272 | "output_type": "display_data" 273 | } 274 | ], 275 | "source": [] 276 | }, 277 | { 278 | "cell_type": "markdown", 279 | "metadata": {}, 280 | "source": [ 281 | "**Wie lautet die Summe aller Elemente in *mat2*?**" 282 | ] 283 | }, 284 | { 285 | "cell_type": "code", 286 | "execution_count": 7, 287 | "metadata": { 288 | "collapsed": false 289 | }, 290 | "outputs": [ 291 | { 292 | "data": { 293 | "text/html": [ 294 | "325" 295 | ], 296 | "text/latex": [ 297 | "325" 298 | ], 299 | "text/markdown": [ 300 | "325" 301 | ], 302 | "text/plain": [ 303 | "[1] 325" 304 | ] 305 | }, 306 | "metadata": {}, 307 | "output_type": "display_data" 308 | } 309 | ], 310 | "source": [] 311 | }, 312 | { 313 | "cell_type": "markdown", 314 | "metadata": {}, 315 | "source": [ 316 | "** Ok, Zeit für unsere letzte Aufgabe! Finde heraus, wie man `runif()` nutzt, um eine 4 mal 5 Matrix zu erstellen, die aus 20 zufällig ausgewählten Zahlen besteht.**" 317 | ] 318 | }, 319 | { 320 | "cell_type": "code", 321 | "execution_count": 8, 322 | "metadata": { 323 | "collapsed": false 324 | }, 325 | "outputs": [ 326 | { 327 | "data": { 328 | "text/html": [ 329 | "\n", 330 | "\n", 331 | "\t\n", 332 | "\t\n", 333 | "\t\n", 334 | "\t\n", 335 | "\n", 336 | "
58.7755155.3818329.3553672.3630925.23232
67.7379551.9166723.3331540.9706318.66102
43.7700135.9247841.0831375.1995577.06942
62.6342393.6965679.3035666.3992663.25485
\n" 337 | ], 338 | "text/latex": [ 339 | "\\begin{tabular}{lllll}\n", 340 | "\t 58.77551 & 55.38183 & 29.35536 & 72.36309 & 25.23232\\\\\n", 341 | "\t 67.73795 & 51.91667 & 23.33315 & 40.97063 & 18.66102\\\\\n", 342 | "\t 43.77001 & 35.92478 & 41.08313 & 75.19955 & 77.06942\\\\\n", 343 | "\t 62.63423 & 93.69656 & 79.30356 & 66.39926 & 63.25485\\\\\n", 344 | "\\end{tabular}\n" 345 | ], 346 | "text/markdown": [ 347 | "\n", 348 | "| 58.77551 | 55.38183 | 29.35536 | 72.36309 | 25.23232 | \n", 349 | "| 67.73795 | 51.91667 | 23.33315 | 40.97063 | 18.66102 | \n", 350 | "| 43.77001 | 35.92478 | 41.08313 | 75.19955 | 77.06942 | \n", 351 | "| 62.63423 | 93.69656 | 79.30356 | 66.39926 | 63.25485 | \n", 352 | "\n", 353 | "\n" 354 | ], 355 | "text/plain": [ 356 | " [,1] [,2] [,3] [,4] [,5] \n", 357 | "[1,] 58.77551 55.38183 29.35536 72.36309 25.23232\n", 358 | "[2,] 67.73795 51.91667 23.33315 40.97063 18.66102\n", 359 | "[3,] 43.77001 35.92478 41.08313 75.19955 77.06942\n", 360 | "[4,] 62.63423 93.69656 79.30356 66.39926 63.25485" 361 | ] 362 | }, 363 | "metadata": {}, 364 | "output_type": "display_data" 365 | } 366 | ], 367 | "source": [] 368 | }, 369 | { 370 | "cell_type": "code", 371 | "execution_count": 9, 372 | "metadata": { 373 | "collapsed": true 374 | }, 375 | "outputs": [], 376 | "source": [ 377 | "# help(runif)" 378 | ] 379 | }, 380 | { 381 | "cell_type": "markdown", 382 | "metadata": {}, 383 | "source": [ 384 | "# Gut gemacht!" 385 | ] 386 | } 387 | ], 388 | "metadata": { 389 | "kernelspec": { 390 | "display_name": "Python 3", 391 | "language": "python", 392 | "name": "python3" 393 | }, 394 | "language_info": { 395 | "codemirror_mode": { 396 | "name": "ipython", 397 | "version": 3 398 | }, 399 | "file_extension": ".py", 400 | "mimetype": "text/x-python", 401 | "name": "python", 402 | "nbconvert_exporter": "python", 403 | "pygments_lexer": "ipython3", 404 | "version": "3.6.0" 405 | } 406 | }, 407 | "nbformat": 4, 408 | "nbformat_minor": 1 409 | } 410 | -------------------------------------------------------------------------------- /1-Grundlagen von R und Datentypen/2-R Matrizen/6-R Matrizen Übung - Aufgaben.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# R Matrizen Übung - Aufgaben\n", 8 | "\n", 9 | "Im Verlauf dieser Übung werden wir die Datenstruktur \"Matrix\" wiederholen. Als kleinen Bonus wird es außerdem etwas zum selbst entdecken geben." 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "**Erstelle 2 Vektoren A und B. A soll die Werte (1,2,3) beinhalten und B die Werte (4,5,6). Mit diesen Vektoren verwende entweder `cbind()` oder `rbind()`, um eine Matrix im Format 2 mal 3 zu erstellen. Nur eine der Verknüpfungsfunktionen ist hier richtig!**" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 1, 22 | "metadata": { 23 | "collapsed": false 24 | }, 25 | "outputs": [ 26 | { 27 | "data": { 28 | "text/html": [ 29 | "\n", 30 | "\n", 31 | "\t\n", 32 | "\t\n", 33 | "\n", 34 | "
A123
B456
\n" 35 | ], 36 | "text/latex": [ 37 | "\\begin{tabular}{r|lll}\n", 38 | "\tA & 1 & 2 & 3\\\\\n", 39 | "\tB & 4 & 5 & 6\\\\\n", 40 | "\\end{tabular}\n" 41 | ], 42 | "text/markdown": [ 43 | "\n", 44 | "| A | 1 | 2 | 3 | \n", 45 | "| B | 4 | 5 | 6 | \n", 46 | "\n", 47 | "\n" 48 | ], 49 | "text/plain": [ 50 | " [,1] [,2] [,3]\n", 51 | "A 1 2 3 \n", 52 | "B 4 5 6 " 53 | ] 54 | }, 55 | "metadata": {}, 56 | "output_type": "display_data" 57 | } 58 | ], 59 | "source": [] 60 | }, 61 | { 62 | "cell_type": "markdown", 63 | "metadata": {}, 64 | "source": [ 65 | "**Erstelle eine 3 mal 3 Matrix, die die Zahlen 1 bis 9 beinhaltet. Diese Matrix soll durch das Kürzel 1:9 erstellt werden und durch Definition des nrow Parametwers in der matrix() Funktion. Weise diese Matrix der Varaiblen *mat* zu.**" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": 2, 71 | "metadata": { 72 | "collapsed": true 73 | }, 74 | "outputs": [], 75 | "source": [] 76 | }, 77 | { 78 | "cell_type": "markdown", 79 | "metadata": {}, 80 | "source": [ 81 | "**Überprüfe, ob *mat* wirklich eine Matrix ist. Tipp: is.matrix() **" 82 | ] 83 | }, 84 | { 85 | "cell_type": "code", 86 | "execution_count": 3, 87 | "metadata": { 88 | "collapsed": false 89 | }, 90 | "outputs": [ 91 | { 92 | "data": { 93 | "text/html": [ 94 | "TRUE" 95 | ], 96 | "text/latex": [ 97 | "TRUE" 98 | ], 99 | "text/markdown": [ 100 | "TRUE" 101 | ], 102 | "text/plain": [ 103 | "[1] TRUE" 104 | ] 105 | }, 106 | "metadata": {}, 107 | "output_type": "display_data" 108 | } 109 | ], 110 | "source": [] 111 | }, 112 | { 113 | "cell_type": "markdown", 114 | "metadata": {}, 115 | "source": [ 116 | "** Erstelle eine 5 mal 5 Matrix, die die Zahlen 1 bis 25 enthält. Diese soll den Namen *mat2* haben. Die oberste Zeile soll außerdem die Werte 1 bis 5 beinhalten.**" 117 | ] 118 | }, 119 | { 120 | "cell_type": "code", 121 | "execution_count": 4, 122 | "metadata": { 123 | "collapsed": false 124 | }, 125 | "outputs": [ 126 | { 127 | "data": { 128 | "text/html": [ 129 | "\n", 130 | "\n", 131 | "\t\n", 132 | "\t\n", 133 | "\t\n", 134 | "\t\n", 135 | "\t\n", 136 | "\n", 137 | "
1 2 3 4 5
6 7 8 910
1112131415
1617181920
2122232425
\n" 138 | ], 139 | "text/latex": [ 140 | "\\begin{tabular}{lllll}\n", 141 | "\t 1 & 2 & 3 & 4 & 5\\\\\n", 142 | "\t 6 & 7 & 8 & 9 & 10\\\\\n", 143 | "\t 11 & 12 & 13 & 14 & 15\\\\\n", 144 | "\t 16 & 17 & 18 & 19 & 20\\\\\n", 145 | "\t 21 & 22 & 23 & 24 & 25\\\\\n", 146 | "\\end{tabular}\n" 147 | ], 148 | "text/markdown": [ 149 | "\n", 150 | "| 1 | 2 | 3 | 4 | 5 | \n", 151 | "| 6 | 7 | 8 | 9 | 10 | \n", 152 | "| 11 | 12 | 13 | 14 | 15 | \n", 153 | "| 16 | 17 | 18 | 19 | 20 | \n", 154 | "| 21 | 22 | 23 | 24 | 25 | \n", 155 | "\n", 156 | "\n" 157 | ], 158 | "text/plain": [ 159 | " [,1] [,2] [,3] [,4] [,5]\n", 160 | "[1,] 1 2 3 4 5 \n", 161 | "[2,] 6 7 8 9 10 \n", 162 | "[3,] 11 12 13 14 15 \n", 163 | "[4,] 16 17 18 19 20 \n", 164 | "[5,] 21 22 23 24 25 " 165 | ] 166 | }, 167 | "metadata": {}, 168 | "output_type": "display_data" 169 | } 170 | ], 171 | "source": [] 172 | }, 173 | { 174 | "cell_type": "markdown", 175 | "metadata": {}, 176 | "source": [ 177 | "** Nutze die Index Notation, um einen Ausschnitt von *mat2* auszuwählen. Dieser soll wie folgt aussehen:**\n", 178 | "\n", 179 | " [7,8]\n", 180 | " [12,13]" 181 | ] 182 | }, 183 | { 184 | "cell_type": "code", 185 | "execution_count": 5, 186 | "metadata": { 187 | "collapsed": false 188 | }, 189 | "outputs": [ 190 | { 191 | "data": { 192 | "text/html": [ 193 | "\n", 194 | "\n", 195 | "\t\n", 196 | "\t\n", 197 | "\n", 198 | "
7 8
1213
\n" 199 | ], 200 | "text/latex": [ 201 | "\\begin{tabular}{ll}\n", 202 | "\t 7 & 8\\\\\n", 203 | "\t 12 & 13\\\\\n", 204 | "\\end{tabular}\n" 205 | ], 206 | "text/markdown": [ 207 | "\n", 208 | "| 7 | 8 | \n", 209 | "| 12 | 13 | \n", 210 | "\n", 211 | "\n" 212 | ], 213 | "text/plain": [ 214 | " [,1] [,2]\n", 215 | "[1,] 7 8 \n", 216 | "[2,] 12 13 " 217 | ] 218 | }, 219 | "metadata": {}, 220 | "output_type": "display_data" 221 | } 222 | ], 223 | "source": [] 224 | }, 225 | { 226 | "cell_type": "markdown", 227 | "metadata": {}, 228 | "source": [ 229 | "** Nutze die Index Notation, um einen Ausschnitt von *mat2* auszuwählen. Dieser soll wie folgt aussehen:**\n", 230 | "\n", 231 | " [19,20]\n", 232 | " [24,25]" 233 | ] 234 | }, 235 | { 236 | "cell_type": "code", 237 | "execution_count": 6, 238 | "metadata": { 239 | "collapsed": false 240 | }, 241 | "outputs": [ 242 | { 243 | "data": { 244 | "text/html": [ 245 | "\n", 246 | "\n", 247 | "\t\n", 248 | "\t\n", 249 | "\n", 250 | "
1920
2425
\n" 251 | ], 252 | "text/latex": [ 253 | "\\begin{tabular}{ll}\n", 254 | "\t 19 & 20\\\\\n", 255 | "\t 24 & 25\\\\\n", 256 | "\\end{tabular}\n" 257 | ], 258 | "text/markdown": [ 259 | "\n", 260 | "| 19 | 20 | \n", 261 | "| 24 | 25 | \n", 262 | "\n", 263 | "\n" 264 | ], 265 | "text/plain": [ 266 | " [,1] [,2]\n", 267 | "[1,] 19 20 \n", 268 | "[2,] 24 25 " 269 | ] 270 | }, 271 | "metadata": {}, 272 | "output_type": "display_data" 273 | } 274 | ], 275 | "source": [] 276 | }, 277 | { 278 | "cell_type": "markdown", 279 | "metadata": {}, 280 | "source": [ 281 | "**Wie lautet die Summe aller Elemente in *mat2*?**" 282 | ] 283 | }, 284 | { 285 | "cell_type": "code", 286 | "execution_count": 7, 287 | "metadata": { 288 | "collapsed": false 289 | }, 290 | "outputs": [ 291 | { 292 | "data": { 293 | "text/html": [ 294 | "325" 295 | ], 296 | "text/latex": [ 297 | "325" 298 | ], 299 | "text/markdown": [ 300 | "325" 301 | ], 302 | "text/plain": [ 303 | "[1] 325" 304 | ] 305 | }, 306 | "metadata": {}, 307 | "output_type": "display_data" 308 | } 309 | ], 310 | "source": [] 311 | }, 312 | { 313 | "cell_type": "markdown", 314 | "metadata": {}, 315 | "source": [ 316 | "** Ok, Zeit für unsere letzte Aufgabe! Finde heraus, wie man `runif()` nutzt, um eine 4 mal 5 Matrix zu erstellen, die aus 20 zufällig ausgewählten Zahlen besteht.**" 317 | ] 318 | }, 319 | { 320 | "cell_type": "code", 321 | "execution_count": 8, 322 | "metadata": { 323 | "collapsed": false 324 | }, 325 | "outputs": [ 326 | { 327 | "data": { 328 | "text/html": [ 329 | "\n", 330 | "\n", 331 | "\t\n", 332 | "\t\n", 333 | "\t\n", 334 | "\t\n", 335 | "\n", 336 | "
58.7755155.3818329.3553672.3630925.23232
67.7379551.9166723.3331540.9706318.66102
43.7700135.9247841.0831375.1995577.06942
62.6342393.6965679.3035666.3992663.25485
\n" 337 | ], 338 | "text/latex": [ 339 | "\\begin{tabular}{lllll}\n", 340 | "\t 58.77551 & 55.38183 & 29.35536 & 72.36309 & 25.23232\\\\\n", 341 | "\t 67.73795 & 51.91667 & 23.33315 & 40.97063 & 18.66102\\\\\n", 342 | "\t 43.77001 & 35.92478 & 41.08313 & 75.19955 & 77.06942\\\\\n", 343 | "\t 62.63423 & 93.69656 & 79.30356 & 66.39926 & 63.25485\\\\\n", 344 | "\\end{tabular}\n" 345 | ], 346 | "text/markdown": [ 347 | "\n", 348 | "| 58.77551 | 55.38183 | 29.35536 | 72.36309 | 25.23232 | \n", 349 | "| 67.73795 | 51.91667 | 23.33315 | 40.97063 | 18.66102 | \n", 350 | "| 43.77001 | 35.92478 | 41.08313 | 75.19955 | 77.06942 | \n", 351 | "| 62.63423 | 93.69656 | 79.30356 | 66.39926 | 63.25485 | \n", 352 | "\n", 353 | "\n" 354 | ], 355 | "text/plain": [ 356 | " [,1] [,2] [,3] [,4] [,5] \n", 357 | "[1,] 58.77551 55.38183 29.35536 72.36309 25.23232\n", 358 | "[2,] 67.73795 51.91667 23.33315 40.97063 18.66102\n", 359 | "[3,] 43.77001 35.92478 41.08313 75.19955 77.06942\n", 360 | "[4,] 62.63423 93.69656 79.30356 66.39926 63.25485" 361 | ] 362 | }, 363 | "metadata": {}, 364 | "output_type": "display_data" 365 | } 366 | ], 367 | "source": [] 368 | }, 369 | { 370 | "cell_type": "code", 371 | "execution_count": 9, 372 | "metadata": { 373 | "collapsed": true 374 | }, 375 | "outputs": [], 376 | "source": [ 377 | "# help(runif)" 378 | ] 379 | }, 380 | { 381 | "cell_type": "markdown", 382 | "metadata": {}, 383 | "source": [ 384 | "# Gut gemacht!" 385 | ] 386 | } 387 | ], 388 | "metadata": { 389 | "kernelspec": { 390 | "display_name": "Python 3", 391 | "language": "python", 392 | "name": "python3" 393 | }, 394 | "language_info": { 395 | "codemirror_mode": { 396 | "name": "ipython", 397 | "version": 3 398 | }, 399 | "file_extension": ".py", 400 | "mimetype": "text/x-python", 401 | "name": "python", 402 | "nbconvert_exporter": "python", 403 | "pygments_lexer": "ipython3", 404 | "version": "3.6.0" 405 | } 406 | }, 407 | "nbformat": 4, 408 | "nbformat_minor": 1 409 | } 410 | -------------------------------------------------------------------------------- /1-Grundlagen von R und Datentypen/2-R Matrizen/7-R Matrizen Übung - Lösung.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# R Matrizen Übung - Lösung\n", 8 | "\n", 9 | "Im Verlauf dieser Übung werden wir die Datenstruktur \"Matrix\" wiederholen. Als kleinen Bonus wird es außerdem etwas zum selbst entdecken geben." 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "**Erstelle 2 Vektoren A und B. A soll die Werte (1,2,3) beinhalten und B die Werte (4,5,6). Mit diesen Vektoren verwende entweder `cbind()` oder `rbind()`, um eine Matrix im Format 2 mal 3 zu erstellen. Nur eine der Verknüpfungsfunktionen ist hier richtig!**" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 1, 22 | "metadata": { 23 | "collapsed": false 24 | }, 25 | "outputs": [ 26 | { 27 | "data": { 28 | "text/html": [ 29 | "\n", 30 | "\n", 31 | "\t\n", 32 | "\t\n", 33 | "\n", 34 | "
A123
B456
\n" 35 | ], 36 | "text/latex": [ 37 | "\\begin{tabular}{r|lll}\n", 38 | "\tA & 1 & 2 & 3\\\\\n", 39 | "\tB & 4 & 5 & 6\\\\\n", 40 | "\\end{tabular}\n" 41 | ], 42 | "text/markdown": [ 43 | "\n", 44 | "| A | 1 | 2 | 3 | \n", 45 | "| B | 4 | 5 | 6 | \n", 46 | "\n", 47 | "\n" 48 | ], 49 | "text/plain": [ 50 | " [,1] [,2] [,3]\n", 51 | "A 1 2 3 \n", 52 | "B 4 5 6 " 53 | ] 54 | }, 55 | "metadata": {}, 56 | "output_type": "display_data" 57 | } 58 | ], 59 | "source": [ 60 | "A <- c(1,2,3)\n", 61 | "B <- c(4,5,6)\n", 62 | "rbind(A,B)" 63 | ] 64 | }, 65 | { 66 | "cell_type": "markdown", 67 | "metadata": {}, 68 | "source": [ 69 | "**Erstelle eine 3 mal 3 Matrix, die die Zahlen 1 bis 9 beinhaltet. Diese Matrix soll durch das Kürzel 1:9 erstellt werden und durch Definition des nrow Parameters in der matrix() Funktion. Weise diese Matrix der Varaiblen *mat* zu.**" 70 | ] 71 | }, 72 | { 73 | "cell_type": "code", 74 | "execution_count": 2, 75 | "metadata": { 76 | "collapsed": true 77 | }, 78 | "outputs": [], 79 | "source": [ 80 | "mat <- matrix(1:9,byrow=TRUE,nrow = 3)" 81 | ] 82 | }, 83 | { 84 | "cell_type": "markdown", 85 | "metadata": {}, 86 | "source": [ 87 | "**Überprüfe, ob *mat* wirklich eine Matrix ist. Tipp: is.matrix() **" 88 | ] 89 | }, 90 | { 91 | "cell_type": "code", 92 | "execution_count": 3, 93 | "metadata": { 94 | "collapsed": false 95 | }, 96 | "outputs": [ 97 | { 98 | "data": { 99 | "text/html": [ 100 | "TRUE" 101 | ], 102 | "text/latex": [ 103 | "TRUE" 104 | ], 105 | "text/markdown": [ 106 | "TRUE" 107 | ], 108 | "text/plain": [ 109 | "[1] TRUE" 110 | ] 111 | }, 112 | "metadata": {}, 113 | "output_type": "display_data" 114 | } 115 | ], 116 | "source": [ 117 | "is.matrix(mat)" 118 | ] 119 | }, 120 | { 121 | "cell_type": "markdown", 122 | "metadata": {}, 123 | "source": [ 124 | "** Erstelle eine 5 mal 5 Matrix, die die Zahlen 1 bis 25 enthält. Diese soll den Namen *mat2* haben. Die oberste Zeile soll außerdem die Werte 1 bis 5 beinhalten.**" 125 | ] 126 | }, 127 | { 128 | "cell_type": "code", 129 | "execution_count": 4, 130 | "metadata": { 131 | "collapsed": false 132 | }, 133 | "outputs": [ 134 | { 135 | "data": { 136 | "text/html": [ 137 | "\n", 138 | "\n", 139 | "\t\n", 140 | "\t\n", 141 | "\t\n", 142 | "\t\n", 143 | "\t\n", 144 | "\n", 145 | "
1 2 3 4 5
6 7 8 910
1112131415
1617181920
2122232425
\n" 146 | ], 147 | "text/latex": [ 148 | "\\begin{tabular}{lllll}\n", 149 | "\t 1 & 2 & 3 & 4 & 5\\\\\n", 150 | "\t 6 & 7 & 8 & 9 & 10\\\\\n", 151 | "\t 11 & 12 & 13 & 14 & 15\\\\\n", 152 | "\t 16 & 17 & 18 & 19 & 20\\\\\n", 153 | "\t 21 & 22 & 23 & 24 & 25\\\\\n", 154 | "\\end{tabular}\n" 155 | ], 156 | "text/markdown": [ 157 | "\n", 158 | "| 1 | 2 | 3 | 4 | 5 | \n", 159 | "| 6 | 7 | 8 | 9 | 10 | \n", 160 | "| 11 | 12 | 13 | 14 | 15 | \n", 161 | "| 16 | 17 | 18 | 19 | 20 | \n", 162 | "| 21 | 22 | 23 | 24 | 25 | \n", 163 | "\n", 164 | "\n" 165 | ], 166 | "text/plain": [ 167 | " [,1] [,2] [,3] [,4] [,5]\n", 168 | "[1,] 1 2 3 4 5 \n", 169 | "[2,] 6 7 8 9 10 \n", 170 | "[3,] 11 12 13 14 15 \n", 171 | "[4,] 16 17 18 19 20 \n", 172 | "[5,] 21 22 23 24 25 " 173 | ] 174 | }, 175 | "metadata": {}, 176 | "output_type": "display_data" 177 | } 178 | ], 179 | "source": [ 180 | "mat2 <- matrix(1:25,byrow = TRUE,nrow = 5)\n", 181 | "mat2" 182 | ] 183 | }, 184 | { 185 | "cell_type": "markdown", 186 | "metadata": {}, 187 | "source": [ 188 | "** Nutze die Index Notation, um einen Ausschnitt von *mat2* auszuwählen. Dieser soll wie folgt aussehen:**\n", 189 | "\n", 190 | " [7,8]\n", 191 | " [12,13]" 192 | ] 193 | }, 194 | { 195 | "cell_type": "code", 196 | "execution_count": 5, 197 | "metadata": { 198 | "collapsed": false 199 | }, 200 | "outputs": [ 201 | { 202 | "data": { 203 | "text/html": [ 204 | "\n", 205 | "\n", 206 | "\t\n", 207 | "\t\n", 208 | "\n", 209 | "
7 8
1213
\n" 210 | ], 211 | "text/latex": [ 212 | "\\begin{tabular}{ll}\n", 213 | "\t 7 & 8\\\\\n", 214 | "\t 12 & 13\\\\\n", 215 | "\\end{tabular}\n" 216 | ], 217 | "text/markdown": [ 218 | "\n", 219 | "| 7 | 8 | \n", 220 | "| 12 | 13 | \n", 221 | "\n", 222 | "\n" 223 | ], 224 | "text/plain": [ 225 | " [,1] [,2]\n", 226 | "[1,] 7 8 \n", 227 | "[2,] 12 13 " 228 | ] 229 | }, 230 | "metadata": {}, 231 | "output_type": "display_data" 232 | } 233 | ], 234 | "source": [ 235 | "mat2[2:3,2:3]" 236 | ] 237 | }, 238 | { 239 | "cell_type": "markdown", 240 | "metadata": {}, 241 | "source": [ 242 | "** Nutze die Index Notation, um einen Ausschnitt von *mat2* auszuwählen. Dieser soll wie folgt aussehen:**\n", 243 | "\n", 244 | " [19,20]\n", 245 | " [24,25]" 246 | ] 247 | }, 248 | { 249 | "cell_type": "code", 250 | "execution_count": 6, 251 | "metadata": { 252 | "collapsed": false 253 | }, 254 | "outputs": [ 255 | { 256 | "data": { 257 | "text/html": [ 258 | "\n", 259 | "\n", 260 | "\t\n", 261 | "\t\n", 262 | "\n", 263 | "
1920
2425
\n" 264 | ], 265 | "text/latex": [ 266 | "\\begin{tabular}{ll}\n", 267 | "\t 19 & 20\\\\\n", 268 | "\t 24 & 25\\\\\n", 269 | "\\end{tabular}\n" 270 | ], 271 | "text/markdown": [ 272 | "\n", 273 | "| 19 | 20 | \n", 274 | "| 24 | 25 | \n", 275 | "\n", 276 | "\n" 277 | ], 278 | "text/plain": [ 279 | " [,1] [,2]\n", 280 | "[1,] 19 20 \n", 281 | "[2,] 24 25 " 282 | ] 283 | }, 284 | "metadata": {}, 285 | "output_type": "display_data" 286 | } 287 | ], 288 | "source": [ 289 | "mat2[4:5,4:5]" 290 | ] 291 | }, 292 | { 293 | "cell_type": "markdown", 294 | "metadata": {}, 295 | "source": [ 296 | "**Wie lautet die Summe aller Elemente in *mat2*?**" 297 | ] 298 | }, 299 | { 300 | "cell_type": "code", 301 | "execution_count": 7, 302 | "metadata": { 303 | "collapsed": false 304 | }, 305 | "outputs": [ 306 | { 307 | "data": { 308 | "text/html": [ 309 | "325" 310 | ], 311 | "text/latex": [ 312 | "325" 313 | ], 314 | "text/markdown": [ 315 | "325" 316 | ], 317 | "text/plain": [ 318 | "[1] 325" 319 | ] 320 | }, 321 | "metadata": {}, 322 | "output_type": "display_data" 323 | } 324 | ], 325 | "source": [ 326 | "sum(mat2)" 327 | ] 328 | }, 329 | { 330 | "cell_type": "markdown", 331 | "metadata": {}, 332 | "source": [ 333 | "** Ok, Zeit für unsere letzte Aufgabe! Finde heraus, wie man `runif()` nutzt, um eine 4 mal 5 Matrix zu erstellen, die aus 20 zufällig ausgewählten Zahlen besteht.**" 334 | ] 335 | }, 336 | { 337 | "cell_type": "code", 338 | "execution_count": 8, 339 | "metadata": { 340 | "collapsed": false 341 | }, 342 | "outputs": [ 343 | { 344 | "data": { 345 | "text/html": [ 346 | "\n", 347 | "\n", 348 | "\t\n", 349 | "\t\n", 350 | "\t\n", 351 | "\t\n", 352 | "\n", 353 | "
58.7755155.3818329.3553672.3630925.23232
67.7379551.9166723.3331540.9706318.66102
43.7700135.9247841.0831375.1995577.06942
62.6342393.6965679.3035666.3992663.25485
\n" 354 | ], 355 | "text/latex": [ 356 | "\\begin{tabular}{lllll}\n", 357 | "\t 58.77551 & 55.38183 & 29.35536 & 72.36309 & 25.23232\\\\\n", 358 | "\t 67.73795 & 51.91667 & 23.33315 & 40.97063 & 18.66102\\\\\n", 359 | "\t 43.77001 & 35.92478 & 41.08313 & 75.19955 & 77.06942\\\\\n", 360 | "\t 62.63423 & 93.69656 & 79.30356 & 66.39926 & 63.25485\\\\\n", 361 | "\\end{tabular}\n" 362 | ], 363 | "text/markdown": [ 364 | "\n", 365 | "| 58.77551 | 55.38183 | 29.35536 | 72.36309 | 25.23232 | \n", 366 | "| 67.73795 | 51.91667 | 23.33315 | 40.97063 | 18.66102 | \n", 367 | "| 43.77001 | 35.92478 | 41.08313 | 75.19955 | 77.06942 | \n", 368 | "| 62.63423 | 93.69656 | 79.30356 | 66.39926 | 63.25485 | \n", 369 | "\n", 370 | "\n" 371 | ], 372 | "text/plain": [ 373 | " [,1] [,2] [,3] [,4] [,5] \n", 374 | "[1,] 58.77551 55.38183 29.35536 72.36309 25.23232\n", 375 | "[2,] 67.73795 51.91667 23.33315 40.97063 18.66102\n", 376 | "[3,] 43.77001 35.92478 41.08313 75.19955 77.06942\n", 377 | "[4,] 62.63423 93.69656 79.30356 66.39926 63.25485" 378 | ] 379 | }, 380 | "metadata": {}, 381 | "output_type": "display_data" 382 | } 383 | ], 384 | "source": [ 385 | "zufmat <- matrix(runif(20,min=0,max=100),nrow = 4)\n", 386 | "zufmat" 387 | ] 388 | }, 389 | { 390 | "cell_type": "code", 391 | "execution_count": 9, 392 | "metadata": { 393 | "collapsed": true 394 | }, 395 | "outputs": [], 396 | "source": [ 397 | "# help(runif)" 398 | ] 399 | }, 400 | { 401 | "cell_type": "markdown", 402 | "metadata": {}, 403 | "source": [ 404 | "# Gut gemacht!" 405 | ] 406 | } 407 | ], 408 | "metadata": { 409 | "kernelspec": { 410 | "display_name": "Python 3", 411 | "language": "python", 412 | "name": "python3" 413 | }, 414 | "language_info": { 415 | "codemirror_mode": { 416 | "name": "ipython", 417 | "version": 3 418 | }, 419 | "file_extension": ".py", 420 | "mimetype": "text/x-python", 421 | "name": "python", 422 | "nbconvert_exporter": "python", 423 | "pygments_lexer": "ipython3", 424 | "version": "3.6.0" 425 | } 426 | }, 427 | "nbformat": 4, 428 | "nbformat_minor": 1 429 | } 430 | -------------------------------------------------------------------------------- /1-Grundlagen von R und Datentypen/2-R Matrizen/7-R Matrizen Übung - Lösung.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# R Matrizen Übung - Lösung\n", 8 | "\n", 9 | "Im Verlauf dieser Übung werden wir die Datenstruktur \"Matrix\" wiederholen. Als kleinen Bonus wird es außerdem etwas zum selbst entdecken geben." 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "**Erstelle 2 Vektoren A und B. A soll die Werte (1,2,3) beinhalten und B die Werte (4,5,6). Mit diesen Vektoren verwende entweder `cbind()` oder `rbind()`, um eine Matrix im Format 2 mal 3 zu erstellen. Nur eine der Verknüpfungsfunktionen ist hier richtig!**" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 1, 22 | "metadata": { 23 | "collapsed": false 24 | }, 25 | "outputs": [ 26 | { 27 | "data": { 28 | "text/html": [ 29 | "\n", 30 | "\n", 31 | "\t\n", 32 | "\t\n", 33 | "\n", 34 | "
A123
B456
\n" 35 | ], 36 | "text/latex": [ 37 | "\\begin{tabular}{r|lll}\n", 38 | "\tA & 1 & 2 & 3\\\\\n", 39 | "\tB & 4 & 5 & 6\\\\\n", 40 | "\\end{tabular}\n" 41 | ], 42 | "text/markdown": [ 43 | "\n", 44 | "| A | 1 | 2 | 3 | \n", 45 | "| B | 4 | 5 | 6 | \n", 46 | "\n", 47 | "\n" 48 | ], 49 | "text/plain": [ 50 | " [,1] [,2] [,3]\n", 51 | "A 1 2 3 \n", 52 | "B 4 5 6 " 53 | ] 54 | }, 55 | "metadata": {}, 56 | "output_type": "display_data" 57 | } 58 | ], 59 | "source": [ 60 | "A <- c(1,2,3)\n", 61 | "B <- c(4,5,6)\n", 62 | "rbind(A,B)" 63 | ] 64 | }, 65 | { 66 | "cell_type": "markdown", 67 | "metadata": {}, 68 | "source": [ 69 | "**Erstelle eine 3 mal 3 Matrix, die die Zahlen 1 bis 9 beinhaltet. Diese Matrix soll durch das Kürzel 1:9 erstellt werden und durch Definition des nrow Parameters in der matrix() Funktion. Weise diese Matrix der Varaiblen *mat* zu.**" 70 | ] 71 | }, 72 | { 73 | "cell_type": "code", 74 | "execution_count": 2, 75 | "metadata": { 76 | "collapsed": true 77 | }, 78 | "outputs": [], 79 | "source": [ 80 | "mat <- matrix(1:9,byrow=TRUE,nrow = 3)" 81 | ] 82 | }, 83 | { 84 | "cell_type": "markdown", 85 | "metadata": {}, 86 | "source": [ 87 | "**Überprüfe, ob *mat* wirklich eine Matrix ist. Tipp: is.matrix() **" 88 | ] 89 | }, 90 | { 91 | "cell_type": "code", 92 | "execution_count": 3, 93 | "metadata": { 94 | "collapsed": false 95 | }, 96 | "outputs": [ 97 | { 98 | "data": { 99 | "text/html": [ 100 | "TRUE" 101 | ], 102 | "text/latex": [ 103 | "TRUE" 104 | ], 105 | "text/markdown": [ 106 | "TRUE" 107 | ], 108 | "text/plain": [ 109 | "[1] TRUE" 110 | ] 111 | }, 112 | "metadata": {}, 113 | "output_type": "display_data" 114 | } 115 | ], 116 | "source": [ 117 | "is.matrix(mat)" 118 | ] 119 | }, 120 | { 121 | "cell_type": "markdown", 122 | "metadata": {}, 123 | "source": [ 124 | "** Erstelle eine 5 mal 5 Matrix, die die Zahlen 1 bis 25 enthält. Diese soll den Namen *mat2* haben. Die oberste Zeile soll außerdem die Werte 1 bis 5 beinhalten.**" 125 | ] 126 | }, 127 | { 128 | "cell_type": "code", 129 | "execution_count": 4, 130 | "metadata": { 131 | "collapsed": false 132 | }, 133 | "outputs": [ 134 | { 135 | "data": { 136 | "text/html": [ 137 | "\n", 138 | "\n", 139 | "\t\n", 140 | "\t\n", 141 | "\t\n", 142 | "\t\n", 143 | "\t\n", 144 | "\n", 145 | "
1 2 3 4 5
6 7 8 910
1112131415
1617181920
2122232425
\n" 146 | ], 147 | "text/latex": [ 148 | "\\begin{tabular}{lllll}\n", 149 | "\t 1 & 2 & 3 & 4 & 5\\\\\n", 150 | "\t 6 & 7 & 8 & 9 & 10\\\\\n", 151 | "\t 11 & 12 & 13 & 14 & 15\\\\\n", 152 | "\t 16 & 17 & 18 & 19 & 20\\\\\n", 153 | "\t 21 & 22 & 23 & 24 & 25\\\\\n", 154 | "\\end{tabular}\n" 155 | ], 156 | "text/markdown": [ 157 | "\n", 158 | "| 1 | 2 | 3 | 4 | 5 | \n", 159 | "| 6 | 7 | 8 | 9 | 10 | \n", 160 | "| 11 | 12 | 13 | 14 | 15 | \n", 161 | "| 16 | 17 | 18 | 19 | 20 | \n", 162 | "| 21 | 22 | 23 | 24 | 25 | \n", 163 | "\n", 164 | "\n" 165 | ], 166 | "text/plain": [ 167 | " [,1] [,2] [,3] [,4] [,5]\n", 168 | "[1,] 1 2 3 4 5 \n", 169 | "[2,] 6 7 8 9 10 \n", 170 | "[3,] 11 12 13 14 15 \n", 171 | "[4,] 16 17 18 19 20 \n", 172 | "[5,] 21 22 23 24 25 " 173 | ] 174 | }, 175 | "metadata": {}, 176 | "output_type": "display_data" 177 | } 178 | ], 179 | "source": [ 180 | "mat2 <- matrix(1:25,byrow = TRUE,nrow = 5)\n", 181 | "mat2" 182 | ] 183 | }, 184 | { 185 | "cell_type": "markdown", 186 | "metadata": {}, 187 | "source": [ 188 | "** Nutze die Index Notation, um einen Ausschnitt von *mat2* auszuwählen. Dieser soll wie folgt aussehen:**\n", 189 | "\n", 190 | " [7,8]\n", 191 | " [12,13]" 192 | ] 193 | }, 194 | { 195 | "cell_type": "code", 196 | "execution_count": 5, 197 | "metadata": { 198 | "collapsed": false 199 | }, 200 | "outputs": [ 201 | { 202 | "data": { 203 | "text/html": [ 204 | "\n", 205 | "\n", 206 | "\t\n", 207 | "\t\n", 208 | "\n", 209 | "
7 8
1213
\n" 210 | ], 211 | "text/latex": [ 212 | "\\begin{tabular}{ll}\n", 213 | "\t 7 & 8\\\\\n", 214 | "\t 12 & 13\\\\\n", 215 | "\\end{tabular}\n" 216 | ], 217 | "text/markdown": [ 218 | "\n", 219 | "| 7 | 8 | \n", 220 | "| 12 | 13 | \n", 221 | "\n", 222 | "\n" 223 | ], 224 | "text/plain": [ 225 | " [,1] [,2]\n", 226 | "[1,] 7 8 \n", 227 | "[2,] 12 13 " 228 | ] 229 | }, 230 | "metadata": {}, 231 | "output_type": "display_data" 232 | } 233 | ], 234 | "source": [ 235 | "mat2[2:3,2:3]" 236 | ] 237 | }, 238 | { 239 | "cell_type": "markdown", 240 | "metadata": {}, 241 | "source": [ 242 | "** Nutze die Index Notation, um einen Ausschnitt von *mat2* auszuwählen. Dieser soll wie folgt aussehen:**\n", 243 | "\n", 244 | " [19,20]\n", 245 | " [24,25]" 246 | ] 247 | }, 248 | { 249 | "cell_type": "code", 250 | "execution_count": 6, 251 | "metadata": { 252 | "collapsed": false 253 | }, 254 | "outputs": [ 255 | { 256 | "data": { 257 | "text/html": [ 258 | "\n", 259 | "\n", 260 | "\t\n", 261 | "\t\n", 262 | "\n", 263 | "
1920
2425
\n" 264 | ], 265 | "text/latex": [ 266 | "\\begin{tabular}{ll}\n", 267 | "\t 19 & 20\\\\\n", 268 | "\t 24 & 25\\\\\n", 269 | "\\end{tabular}\n" 270 | ], 271 | "text/markdown": [ 272 | "\n", 273 | "| 19 | 20 | \n", 274 | "| 24 | 25 | \n", 275 | "\n", 276 | "\n" 277 | ], 278 | "text/plain": [ 279 | " [,1] [,2]\n", 280 | "[1,] 19 20 \n", 281 | "[2,] 24 25 " 282 | ] 283 | }, 284 | "metadata": {}, 285 | "output_type": "display_data" 286 | } 287 | ], 288 | "source": [ 289 | "mat2[4:5,4:5]" 290 | ] 291 | }, 292 | { 293 | "cell_type": "markdown", 294 | "metadata": {}, 295 | "source": [ 296 | "**Wie lautet die Summe aller Elemente in *mat2*?**" 297 | ] 298 | }, 299 | { 300 | "cell_type": "code", 301 | "execution_count": 7, 302 | "metadata": { 303 | "collapsed": false 304 | }, 305 | "outputs": [ 306 | { 307 | "data": { 308 | "text/html": [ 309 | "325" 310 | ], 311 | "text/latex": [ 312 | "325" 313 | ], 314 | "text/markdown": [ 315 | "325" 316 | ], 317 | "text/plain": [ 318 | "[1] 325" 319 | ] 320 | }, 321 | "metadata": {}, 322 | "output_type": "display_data" 323 | } 324 | ], 325 | "source": [ 326 | "sum(mat2)" 327 | ] 328 | }, 329 | { 330 | "cell_type": "markdown", 331 | "metadata": {}, 332 | "source": [ 333 | "** Ok, Zeit für unsere letzte Aufgabe! Finde heraus, wie man `runif()` nutzt, um eine 4 mal 5 Matrix zu erstellen, die aus 20 zufällig ausgewählten Zahlen besteht.**" 334 | ] 335 | }, 336 | { 337 | "cell_type": "code", 338 | "execution_count": 8, 339 | "metadata": { 340 | "collapsed": false 341 | }, 342 | "outputs": [ 343 | { 344 | "data": { 345 | "text/html": [ 346 | "\n", 347 | "\n", 348 | "\t\n", 349 | "\t\n", 350 | "\t\n", 351 | "\t\n", 352 | "\n", 353 | "
58.7755155.3818329.3553672.3630925.23232
67.7379551.9166723.3331540.9706318.66102
43.7700135.9247841.0831375.1995577.06942
62.6342393.6965679.3035666.3992663.25485
\n" 354 | ], 355 | "text/latex": [ 356 | "\\begin{tabular}{lllll}\n", 357 | "\t 58.77551 & 55.38183 & 29.35536 & 72.36309 & 25.23232\\\\\n", 358 | "\t 67.73795 & 51.91667 & 23.33315 & 40.97063 & 18.66102\\\\\n", 359 | "\t 43.77001 & 35.92478 & 41.08313 & 75.19955 & 77.06942\\\\\n", 360 | "\t 62.63423 & 93.69656 & 79.30356 & 66.39926 & 63.25485\\\\\n", 361 | "\\end{tabular}\n" 362 | ], 363 | "text/markdown": [ 364 | "\n", 365 | "| 58.77551 | 55.38183 | 29.35536 | 72.36309 | 25.23232 | \n", 366 | "| 67.73795 | 51.91667 | 23.33315 | 40.97063 | 18.66102 | \n", 367 | "| 43.77001 | 35.92478 | 41.08313 | 75.19955 | 77.06942 | \n", 368 | "| 62.63423 | 93.69656 | 79.30356 | 66.39926 | 63.25485 | \n", 369 | "\n", 370 | "\n" 371 | ], 372 | "text/plain": [ 373 | " [,1] [,2] [,3] [,4] [,5] \n", 374 | "[1,] 58.77551 55.38183 29.35536 72.36309 25.23232\n", 375 | "[2,] 67.73795 51.91667 23.33315 40.97063 18.66102\n", 376 | "[3,] 43.77001 35.92478 41.08313 75.19955 77.06942\n", 377 | "[4,] 62.63423 93.69656 79.30356 66.39926 63.25485" 378 | ] 379 | }, 380 | "metadata": {}, 381 | "output_type": "display_data" 382 | } 383 | ], 384 | "source": [ 385 | "zufmat <- matrix(runif(20,min=0,max=100),nrow = 4)\n", 386 | "zufmat" 387 | ] 388 | }, 389 | { 390 | "cell_type": "code", 391 | "execution_count": 9, 392 | "metadata": { 393 | "collapsed": true 394 | }, 395 | "outputs": [], 396 | "source": [ 397 | "# help(runif)" 398 | ] 399 | }, 400 | { 401 | "cell_type": "markdown", 402 | "metadata": {}, 403 | "source": [ 404 | "# Gut gemacht!" 405 | ] 406 | } 407 | ], 408 | "metadata": { 409 | "kernelspec": { 410 | "display_name": "Python 3", 411 | "language": "python", 412 | "name": "python3" 413 | }, 414 | "language_info": { 415 | "codemirror_mode": { 416 | "name": "ipython", 417 | "version": 3 418 | }, 419 | "file_extension": ".py", 420 | "mimetype": "text/x-python", 421 | "name": "python", 422 | "nbconvert_exporter": "python", 423 | "pygments_lexer": "ipython3", 424 | "version": "3.6.0" 425 | } 426 | }, 427 | "nbformat": 4, 428 | "nbformat_minor": 1 429 | } 430 | -------------------------------------------------------------------------------- /2-Data Input und Output mit R/3-SQL mit R.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# SQL mit R\n", 8 | "\n", 9 | "Das wird tatsächlich nur eine sehr kurze Lektion werden, da die Verbindung von R zu einer SQL Datenbank komplett von der Art der Datenbank (MySQL, Oracle, etc.) abhängig ist. \n", 10 | "\n", 11 | "Anstatt also alle Arten von SQL-Datenbanken abzudecken (da jedes ein anderes Paket benötigt), werden wir diese Lektion dazu nutzen, um jeden an die richtige Stelle zu verweisen. Sobald wir die korrekte Library gedownloaded haben ist die tatsächliche Verbindung wirklich einfach. Und dann geht es nur noch darum SQL-Abfragen mit R durchzuführen. \n", 12 | "\n", 13 | "Wir schauen uns nun einmal eine allgemeine Lösung in Form des DBI Pakets an.\n", 14 | "\n", 15 | "## RODBC - Allgemeine Nutzung\n", 16 | "\n", 17 | "Die [RODBC](https://cran.r-project.org/web/packages/DBI/DBI.pdf) Library ist eine Möglichkeit, um sich mit Datenbanken zu verbinden. Ganz unabhängig davon wofür ihr euch entscheidet empfehle ich eine Google-Suche nach eurer Datenbank und R. Dort gibt es viele Erfahrungsberichte und Anleitungen." 18 | ] 19 | }, 20 | { 21 | "cell_type": "code", 22 | "execution_count": null, 23 | "metadata": { 24 | "collapsed": true 25 | }, 26 | "outputs": [], 27 | "source": [ 28 | "install.packages(\"RODBC\") \n", 29 | "# RODBC Syntax Beispiel\n", 30 | "library(RODBC)\n", 31 | "\n", 32 | "myconn <-odbcConnect(\"Database_Name\", uid=\"User_ID\", pwd=\"password\")\n", 33 | "dat <- sqlFetch(myconn, \"Table_Name\")\n", 34 | "querydat <- sqlQuery(myconn, \"SELECT * FROM table\")\n", 35 | "close(myconn)" 36 | ] 37 | }, 38 | { 39 | "cell_type": "markdown", 40 | "metadata": {}, 41 | "source": [ 42 | "### MySQL\n", 43 | "Das [RMySQL](https://cran.r-project.org/web/packages/RMySQL/index.html) Paket bietet ein Interface zu MySQL.\n", 44 | "\n", 45 | "### Oracle\n", 46 | "Das [ROracle](https://cran.r-project.org/web/packages/ROracle/index.html) Paket bietet ein Interface zu Oracle.\n", 47 | "\n", 48 | "### JDBC\n", 49 | "Das [RJDBC](https://cran.r-project.org/web/packages/RJDBC/index.html) Paket bietet Zugang zu Datenbanken durch ein JDBC Interface." 50 | ] 51 | }, 52 | { 53 | "cell_type": "markdown", 54 | "metadata": {}, 55 | "source": [ 56 | "Noch einmal der Hinweis: Google wird euch unter Verwendung von \"Datenbank + R\" zur besten Lösung führen." 57 | ] 58 | } 59 | ], 60 | "metadata": { 61 | "kernelspec": { 62 | "display_name": "Python 3", 63 | "language": "python", 64 | "name": "python3" 65 | }, 66 | "language_info": { 67 | "codemirror_mode": { 68 | "name": "ipython", 69 | "version": 3 70 | }, 71 | "file_extension": ".py", 72 | "mimetype": "text/x-python", 73 | "name": "python", 74 | "nbconvert_exporter": "python", 75 | "pygments_lexer": "ipython3", 76 | "version": "3.6.0" 77 | } 78 | }, 79 | "nbformat": 4, 80 | "nbformat_minor": 1 81 | } 82 | -------------------------------------------------------------------------------- /2-Data Input und Output mit R/4-Web Scraping mit R.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Web Scraping mit R\n", 8 | "\n", 9 | "*Hinweis: Um diese Lektion vollständig zu verstehen sind Kenntnisse von HTML und CSS notwendig. Außerdem solltest du den Pipe Operator in R (%>%) kennen. Komme ggf. zu dieser Lektion zurück, sobald du das Material kennst.*\n", 10 | "\n", 11 | "Web Scraping ist generell immer sehr vom einzelnen Use Case abhängig. Das liegt daran, dass jede Webseite indiviudell aufgebaut und gestalltet ist, Updates durchgeführt werden und sich Dinge verändern. Um Web Scraping mit R komplett zu verstehen ist ein Grundwissen von HTML und CSS notwendig. Dadurch können wir verstehen, was wir uns von der Webseite holen wollen.\n", 12 | "\n", 13 | "Falls ihr HTML und CSS nicht kennt, könnt ihr ein Auto-Web-Scrape Tool wie [import.io](https://www.import.io/) nutzen.\n", 14 | "\n", 15 | "## rvest library\n", 16 | "\n", 17 | "Hier findet ihr ein Beispiel der nutzung von `rvest`. Der beste Weg zum Lernen ist die Nutzung der bereitgestellten Demos, auf die man wie folgt zugreift:" 18 | ] 19 | }, 20 | { 21 | "cell_type": "code", 22 | "execution_count": null, 23 | "metadata": { 24 | "collapsed": true 25 | }, 26 | "outputs": [], 27 | "source": [ 28 | "demo(package='rvest')" 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "metadata": {}, 34 | "source": [ 35 | "Sofern du mit HTML und CSS vertraut bist ist `rvest` eine sehr nützliche Library. Wir gehen jetzt ein Beispiel aus dem R Studio durch:" 36 | ] 37 | }, 38 | { 39 | "cell_type": "code", 40 | "execution_count": 1, 41 | "metadata": { 42 | "collapsed": false 43 | }, 44 | "outputs": [ 45 | { 46 | "name": "stderr", 47 | "output_type": "stream", 48 | "text": [ 49 | "also installing the dependencies ‘BH’, ‘xml2’, ‘selectr’\n", 50 | "\n" 51 | ] 52 | }, 53 | { 54 | "name": "stdout", 55 | "output_type": "stream", 56 | "text": [ 57 | "\n", 58 | "The downloaded binary packages are in\n", 59 | "\t/var/folders/l_/ph09zg211515zffvzrp3bb680000gn/T//RtmpNsECYb/downloaded_packages\n" 60 | ] 61 | } 62 | ], 63 | "source": [ 64 | "# Will also install dependencies\n", 65 | "install.packages('rvest')" 66 | ] 67 | }, 68 | { 69 | "cell_type": "markdown", 70 | "metadata": {}, 71 | "source": [ 72 | "Stellen wir uns vor, wir würden Informationen über den Lego Film von IMDB auslesen wollen. Wir beginnen dazu mit dem Download der HTML-Datei mit `html()`:" 73 | ] 74 | }, 75 | { 76 | "cell_type": "code", 77 | "execution_count": null, 78 | "metadata": { 79 | "collapsed": true 80 | }, 81 | "outputs": [], 82 | "source": [ 83 | "library(rvest)\n", 84 | "lego_film <- read_html(\"http://www.imdb.com/title/tt1490017/\")" 85 | ] 86 | }, 87 | { 88 | "cell_type": "markdown", 89 | "metadata": {}, 90 | "source": [ 91 | "Um im nächsten Schritt die Bewertung zu erhalten nutzen wir das \"Selector Gadget\". Dadurch finden wir heraus welcher CSS-Selektor mit den Daten übereinstimmt, die wir möchten. Falls ihr das Gadget nicht kennt, dann lest euch [\"SelectorGadget\"](https://cran.r-project.org/web/packages/rvest/vignettes/selectorgadget.html) durch – es ist der einfachste Weg, um zu bestimmen, welcher Selektor die Daten extrahiert, die uns interesieren. Wir nutzen `html_node()` um den ersten Node zu finden, der mit dem Selektor übereinstimmt. Dann extrahieren wir seinen Inhalt mit `html_text()` und konvertiren den Inhalt mit `as.numeric()`:" 92 | ] 93 | }, 94 | { 95 | "cell_type": "code", 96 | "execution_count": null, 97 | "metadata": { 98 | "collapsed": true 99 | }, 100 | "outputs": [], 101 | "source": [ 102 | "lego_film %>% \n", 103 | " html_node(\"strong span\") %>%\n", 104 | " html_text() %>%\n", 105 | " as.numeric()" 106 | ] 107 | }, 108 | { 109 | "cell_type": "markdown", 110 | "metadata": {}, 111 | "source": [ 112 | "Wir nutzen einen ähnlichen Prozess um den Cast zu extrahieren:" 113 | ] 114 | }, 115 | { 116 | "cell_type": "code", 117 | "execution_count": null, 118 | "metadata": { 119 | "collapsed": true 120 | }, 121 | "outputs": [], 122 | "source": [ 123 | "lego_film %>%\n", 124 | " html_nodes(\"#titleCast .itemprop span\") %>%\n", 125 | " html_text()" 126 | ] 127 | }, 128 | { 129 | "cell_type": "markdown", 130 | "metadata": {}, 131 | "source": [ 132 | "Die Titel und Autoren von neuen Posts sind in einer dritten Tabelle auf der Seite gespeichert. Wir können `html_nodes()` und [[ ]] nutzen, um sie zu finden. Anschließend wandeln wir es in einen Data Frame um, indem wir `html_table()` nutzen:" 133 | ] 134 | }, 135 | { 136 | "cell_type": "code", 137 | "execution_count": null, 138 | "metadata": { 139 | "collapsed": true 140 | }, 141 | "outputs": [], 142 | "source": [ 143 | "lego_film %>%\n", 144 | " html_nodes(\"table\") %>%\n", 145 | " .[[3]] %>%\n", 146 | " html_table()" 147 | ] 148 | }, 149 | { 150 | "cell_type": "markdown", 151 | "metadata": {}, 152 | "source": [ 153 | "Soweit so gut! Hoffentlich konntet ihr einen ersten Eindruck des Web Scrapings mit R gewinnen." 154 | ] 155 | } 156 | ], 157 | "metadata": { 158 | "kernelspec": { 159 | "display_name": "Python 3", 160 | "language": "python", 161 | "name": "python3" 162 | }, 163 | "language_info": { 164 | "codemirror_mode": { 165 | "name": "ipython", 166 | "version": 3 167 | }, 168 | "file_extension": ".py", 169 | "mimetype": "text/x-python", 170 | "name": "python", 171 | "nbconvert_exporter": "python", 172 | "pygments_lexer": "ipython3", 173 | "version": "3.6.0" 174 | } 175 | }, 176 | "nbformat": 4, 177 | "nbformat_minor": 1 178 | } 179 | -------------------------------------------------------------------------------- /2-Data Input und Output mit R/Beispiel-Verkaufs-Daten.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/datamics/R-DataScience-MachineLearning/f36bd24e6155a5a05ad96d7d00d14c52a620f4a0/2-Data Input und Output mit R/Beispiel-Verkaufs-Daten.xlsx -------------------------------------------------------------------------------- /2-Data Input und Output mit R/Demo.R: -------------------------------------------------------------------------------- 1 | temp <- 5 2 | heiss <- FALSE 3 | 4 | if (temp > 35 ) { 5 | print("heiss") 6 | } else if (temp < 35 & temp >20){ 7 | print("Schön draußen") 8 | } else if (temp < 20 & temp >10){ 9 | print("Kühl") 10 | } else { 11 | print("Kalt") 12 | } 13 | -------------------------------------------------------------------------------- /2-Data Input und Output mit R/beispiel.csv: -------------------------------------------------------------------------------- 1 | Name,Orders,Date 2 | John,12,12/05/2016 3 | Charlie,11,12/06/2016 4 | Matilda,10,12/07/2016 5 | -------------------------------------------------------------------------------- /2-Data Input und Output mit R/foo.csv: -------------------------------------------------------------------------------- 1 | "Name","Orders","Date" 2 | "John",12,"12/05/2016" 3 | "Charlie",11,"12/06/2016" 4 | "Matilda",10,"12/07/2016" 5 | -------------------------------------------------------------------------------- /2-Data Input und Output mit R/output.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/datamics/R-DataScience-MachineLearning/f36bd24e6155a5a05ad96d7d00d14c52a620f4a0/2-Data Input und Output mit R/output.xlsx -------------------------------------------------------------------------------- /3-Programmieren mit R/2-if, else und else if Anweisungen.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# if, else und else if Anweisungen\n", 8 | "\n", 9 | "Es ist jetzt endlich Zeit eine zumindest kleine Logik mit R zu programmieren! Unser erster Schritt dieser Lernkurve wird sein if, else und else if Anweisungen zu verstehen.\n", 10 | "\n", 11 | "Die Syntax einer `if` Anweisung in R lautet:\n", 12 | "\n", 13 | " if (Bedingung){\n", 14 | " # Führe Code aus\n", 15 | " }\n", 16 | "\n", 17 | "Was heißt das denn überhaupt fragt man möglicherweise, wenn man noch nie eine if Anweisung gesehen hat. Es bedeutet, dass wir eine eifnache Logik zu unserem Code hinzufügen können. Wir sagen if (dt. falls) eine gewisse Bedingung erfüllt (d.h. TRUE) ist, dann soll der Code innerhalb der geschwungenen Klammern ausgeführt werden.\n", 18 | "\n", 19 | "Zum Beispiel können wir uns die zwei Variablen **heiss** und **temp** vorstellen. Nun ist **heiss** zunächst als FALSE definiert. Falls (en. if) die **temp** nun über 35°C liegt, dann wird **heiss** zu TRUE.\n", 20 | "\n", 21 | "Schauen wir uns den Code dazu an:" 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": 1, 27 | "metadata": { 28 | "collapsed": true 29 | }, 30 | "outputs": [], 31 | "source": [ 32 | "heiss <- FALSE\n", 33 | "temp <- 28" 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": 3, 39 | "metadata": { 40 | "collapsed": false 41 | }, 42 | "outputs": [ 43 | { 44 | "data": { 45 | "text/html": [ 46 | "FALSE" 47 | ], 48 | "text/latex": [ 49 | "FALSE" 50 | ], 51 | "text/markdown": [ 52 | "FALSE" 53 | ], 54 | "text/plain": [ 55 | "[1] FALSE" 56 | ] 57 | }, 58 | "metadata": {}, 59 | "output_type": "display_data" 60 | } 61 | ], 62 | "source": [ 63 | "if (temp > 35){\n", 64 | " heiss <- TRUE\n", 65 | " \n", 66 | "}\n", 67 | "heiss" 68 | ] 69 | }, 70 | { 71 | "cell_type": "code", 72 | "execution_count": 4, 73 | "metadata": { 74 | "collapsed": false 75 | }, 76 | "outputs": [ 77 | { 78 | "data": { 79 | "text/html": [ 80 | "TRUE" 81 | ], 82 | "text/latex": [ 83 | "TRUE" 84 | ], 85 | "text/markdown": [ 86 | "TRUE" 87 | ], 88 | "text/plain": [ 89 | "[1] TRUE" 90 | ] 91 | }, 92 | "metadata": {}, 93 | "output_type": "display_data" 94 | } 95 | ], 96 | "source": [ 97 | "# temp neu definieren\n", 98 | "temp <- 37\n", 99 | "\n", 100 | "if (temp > 35){\n", 101 | " heiss <- TRUE\n", 102 | " \n", 103 | "}\n", 104 | "\n", 105 | "heiss" 106 | ] 107 | }, 108 | { 109 | "cell_type": "markdown", 110 | "metadata": {}, 111 | "source": [ 112 | "Dabei sollten wir daran denken den Code so zu formatieren, dass wir ihn später einfach wieder öffnen und lesen können. Üblicherweise richten wir die abschließende Klammer an der if Anweisung aus, zu der sie gehört. Nichtsdestotrotz könnten wir auch unordentlich vorgehen und der Code würde dank der Klammern immernoch funktionieren:" 113 | ] 114 | }, 115 | { 116 | "cell_type": "code", 117 | "execution_count": 5, 118 | "metadata": { 119 | "collapsed": false 120 | }, 121 | "outputs": [ 122 | { 123 | "name": "stdout", 124 | "output_type": "stream", 125 | "text": [ 126 | "[1] \"Hi\"\n" 127 | ] 128 | } 129 | ], 130 | "source": [ 131 | "if( 1 == 1){ print('Hi')}" 132 | ] 133 | }, 134 | { 135 | "cell_type": "code", 136 | "execution_count": 6, 137 | "metadata": { 138 | "collapsed": false 139 | }, 140 | "outputs": [ 141 | { 142 | "name": "stdout", 143 | "output_type": "stream", 144 | "text": [ 145 | "[1] \"Hi\"\n" 146 | ] 147 | } 148 | ], 149 | "source": [ 150 | "if(1 == 1)\n", 151 | "\n", 152 | "{\n", 153 | "\n", 154 | " print('Hi')\n", 155 | "\n", 156 | " }\n", 157 | "\n", 158 | "# Funktioniert...lässt sich aber schlecht lesen!" 159 | ] 160 | }, 161 | { 162 | "cell_type": "markdown", 163 | "metadata": {}, 164 | "source": [ 165 | "Ein guter Editor wie R Studio wird uns dabei helfen alles angemessen auszurichten.\n", 166 | "\n", 167 | "## else\n", 168 | "\n", 169 | "Falls wir einen anderen Codeblock ausführen wollen, sofern die if Anweisung nicht erfüllt ist, können wir die **else** Anweisung dazu verwenden. Es ergibt sich folgende Syntax:\n", 170 | "\n", 171 | " if (Bedingung) {\n", 172 | " # Code sofern die Bedingung zu TRUE führt\n", 173 | " } else {\n", 174 | " # Code sofern die Bedingung zu FALSE führt\n", 175 | " }\n", 176 | "\n", 177 | "Achtet hier exemplarisch auf die Platzierung der Klammern und des *else* Stichworts." 178 | ] 179 | }, 180 | { 181 | "cell_type": "code", 182 | "execution_count": 7, 183 | "metadata": { 184 | "collapsed": false 185 | }, 186 | "outputs": [ 187 | { 188 | "name": "stdout", 189 | "output_type": "stream", 190 | "text": [ 191 | "[1] \"Es ist heute nicht zu heiß!\"\n" 192 | ] 193 | } 194 | ], 195 | "source": [ 196 | "temp <- 30\n", 197 | "\n", 198 | "if (temp > 35){\n", 199 | " print(\"Heiß draußen!\")\n", 200 | "} else{\n", 201 | " print(\"Es ist heute nicht zu heiß!\")\n", 202 | "}" 203 | ] 204 | }, 205 | { 206 | "cell_type": "markdown", 207 | "metadata": {}, 208 | "source": [ 209 | "# else if\n", 210 | "\n", 211 | "Was ist nun, falls wir mehrere Optionen angeben und überprüfen möchten? Dann fügen wir jede weitere Überprüfung bzw. Bedingung über die **else if** Anweisung hinzu. Am Ende verwenden wir **else** um festzulegen, was passiert, wenn keine Überprüfung als Ergebnis TRUE hatte." 212 | ] 213 | }, 214 | { 215 | "cell_type": "code", 216 | "execution_count": 8, 217 | "metadata": { 218 | "collapsed": false 219 | }, 220 | "outputs": [ 221 | { 222 | "name": "stdout", 223 | "output_type": "stream", 224 | "text": [ 225 | "[1] \"Draußen ist es kalt!\"\n" 226 | ] 227 | } 228 | ], 229 | "source": [ 230 | "temp <- 5\n", 231 | "\n", 232 | "if (temp > 35){\n", 233 | " print(\"Heiß draußen!\")\n", 234 | "} else if(temp<35 & temp>20){\n", 235 | " print('Schön draußen!')\n", 236 | "} else if(temp <20 & temp > 10){\n", 237 | " print(\"Es ist etwas kühler!\")\n", 238 | "} else{\n", 239 | " print(\"Draußen ist es kalt!\")\n", 240 | "}" 241 | ] 242 | }, 243 | { 244 | "cell_type": "code", 245 | "execution_count": 9, 246 | "metadata": { 247 | "collapsed": false 248 | }, 249 | "outputs": [ 250 | { 251 | "name": "stdout", 252 | "output_type": "stream", 253 | "text": [ 254 | "[1] \"Schön draußen!\"\n" 255 | ] 256 | } 257 | ], 258 | "source": [ 259 | "temp <- 27\n", 260 | "\n", 261 | "if (temp > 35){\n", 262 | " print(\"Heiß draußen!\")\n", 263 | "} else if(temp<35 & temp>20){\n", 264 | " print('Schön draußen!')\n", 265 | "} else if(temp <20 & temp > 10){\n", 266 | " print(\"Es ist etwas kühler!\")\n", 267 | "} else{\n", 268 | " print(\"Draußen ist es kalt!\")\n", 269 | "}" 270 | ] 271 | }, 272 | { 273 | "cell_type": "markdown", 274 | "metadata": {}, 275 | "source": [ 276 | "## Abschließendes Beispiel\n", 277 | "\n", 278 | "Schauen wir uns ein etwas ausgearbeiteteres Beispiel von if, else if und else an. Stellen wir uns vor wir haben einen Laden mit zwei Produkten: Schinken und Käse. Wir würden gerne einen automatisierten Bericht erstellen, der zur verwaltung geschickt werden kann. Er soll berichten, wie viel wir verkaufen:" 279 | ] 280 | }, 281 | { 282 | "cell_type": "code", 283 | "execution_count": 10, 284 | "metadata": { 285 | "collapsed": false 286 | }, 287 | "outputs": [ 288 | { 289 | "name": "stdout", 290 | "output_type": "stream", 291 | "text": [ 292 | "[1] \"Beide Produkte wurden gut verkauft.\"\n" 293 | ] 294 | } 295 | ], 296 | "source": [ 297 | "# Produkte, die heute verkauft wurden\n", 298 | "schinken <- 10\n", 299 | "kaese <- 10\n", 300 | "\n", 301 | "# Bericht für die Verwaltung\n", 302 | "bericht <- 'leer'\n", 303 | "\n", 304 | "\n", 305 | "if(schinken >= 10 & kaese >= 10){\n", 306 | " bericht <- \"Beide Produkte wurden gut verkauft.\"\n", 307 | " \n", 308 | "}else if(schinken == 0 & kaese == 0){\n", 309 | " bericht <- \"Gar nichts verkauft!\"\n", 310 | "}else{\n", 311 | " bericht <- 'Wir hatten ein paar Verkäufe.'\n", 312 | "}\n", 313 | "print(bericht) " 314 | ] 315 | }, 316 | { 317 | "cell_type": "markdown", 318 | "metadata": {}, 319 | "source": [ 320 | "Selbst dieses Beispiel war noch relativ simpel. Die Funktionalität lässt sich aber sehr weit ausbauen und vielseitig einsetzen. Wir werden nach und nach komplexere Aufgaben lösen!" 321 | ] 322 | } 323 | ], 324 | "metadata": { 325 | "kernelspec": { 326 | "display_name": "Python 3", 327 | "language": "python", 328 | "name": "python3" 329 | }, 330 | "language_info": { 331 | "codemirror_mode": { 332 | "name": "ipython", 333 | "version": 3 334 | }, 335 | "file_extension": ".py", 336 | "mimetype": "text/x-python", 337 | "name": "python", 338 | "nbconvert_exporter": "python", 339 | "pygments_lexer": "ipython3", 340 | "version": "3.6.0" 341 | } 342 | }, 343 | "nbformat": 4, 344 | "nbformat_minor": 1 345 | } 346 | -------------------------------------------------------------------------------- /3-Programmieren mit R/3-Bedingte Anweisungen Übung - Aufgaben.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Bedingte Anweisungen Übung - Aufgaben\n", 8 | "\n", 9 | "Für diese Übung wollen wir anwenden, was wir über if, else if und else Anweisungen gelernt haben! Die erste Aufgabe ist dabei exemplarisch gelöst:\n", 10 | "\n", 11 | "**Schreibe ein Skript, das \"Hallo\" ausgibt (->print), wenn die Variable x gleich 1 ist:**" 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 1, 17 | "metadata": { 18 | "collapsed": false 19 | }, 20 | "outputs": [ 21 | { 22 | "name": "stdout", 23 | "output_type": "stream", 24 | "text": [ 25 | "[1] \"Hallo\"\n" 26 | ] 27 | } 28 | ], 29 | "source": [ 30 | "x <- 1\n", 31 | "\n", 32 | "if (x ==1){\n", 33 | " print(\"Hallo\")\n", 34 | "}" 35 | ] 36 | }, 37 | { 38 | "cell_type": "markdown", 39 | "metadata": {}, 40 | "source": [ 41 | "**Schreibe ein Skript das \"Gerade Zahl\" ausgibt, wenn die Variable x eine gerade Zahl ist. Andernfalls wollen wir \"Ungerade\" ausgeben.**" 42 | ] 43 | }, 44 | { 45 | "cell_type": "code", 46 | "execution_count": 2, 47 | "metadata": { 48 | "collapsed": false 49 | }, 50 | "outputs": [ 51 | { 52 | "name": "stdout", 53 | "output_type": "stream", 54 | "text": [ 55 | "[1] \"Ungerade\"\n" 56 | ] 57 | } 58 | ], 59 | "source": [] 60 | }, 61 | { 62 | "cell_type": "markdown", 63 | "metadata": {}, 64 | "source": [ 65 | "**Schreibe ein Skript, das \"Ist eine Matrix\" ausgibt, falls die Variable x eine Matrix beinhaltet. Andernfalls soll das Ergebnis \"Keine Matrix\" lauten.**" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": 3, 71 | "metadata": { 72 | "collapsed": false 73 | }, 74 | "outputs": [ 75 | { 76 | "name": "stdout", 77 | "output_type": "stream", 78 | "text": [ 79 | "[1] \"Ist eine Matrix\"\n" 80 | ] 81 | } 82 | ], 83 | "source": [] 84 | }, 85 | { 86 | "cell_type": "markdown", 87 | "metadata": {}, 88 | "source": [ 89 | "**Erstelle ein Skript, dass einen numerischen Vektor mit 3 Werten als Eingabe aufnimmt und die Elemente darin von groß nach klein sortiert ausgibt. Dazu musst du if, else if und else für deine Logik verwenden.**" 90 | ] 91 | }, 92 | { 93 | "cell_type": "code", 94 | "execution_count": 5, 95 | "metadata": { 96 | "collapsed": false 97 | }, 98 | "outputs": [ 99 | { 100 | "name": "stdout", 101 | "output_type": "stream", 102 | "text": [ 103 | "[1] \"8 4 3\"\n" 104 | ] 105 | } 106 | ], 107 | "source": [] 108 | }, 109 | { 110 | "cell_type": "markdown", 111 | "metadata": {}, 112 | "source": [ 113 | "**Schreibe unter Verwendung von if, else if und else Anweisungen ein Skript, das den höchsten von drei Werten in einem numerischen Vektor ausgibt.**" 114 | ] 115 | }, 116 | { 117 | "cell_type": "code", 118 | "execution_count": 6, 119 | "metadata": { 120 | "collapsed": false 121 | }, 122 | "outputs": [ 123 | { 124 | "name": "stdout", 125 | "output_type": "stream", 126 | "text": [ 127 | "[1] 20\n" 128 | ] 129 | } 130 | ], 131 | "source": [] 132 | }, 133 | { 134 | "cell_type": "markdown", 135 | "metadata": {}, 136 | "source": [ 137 | "## Great Job!" 138 | ] 139 | } 140 | ], 141 | "metadata": { 142 | "kernelspec": { 143 | "display_name": "Python 3", 144 | "language": "python", 145 | "name": "python3" 146 | }, 147 | "language_info": { 148 | "codemirror_mode": { 149 | "name": "ipython", 150 | "version": 3 151 | }, 152 | "file_extension": ".py", 153 | "mimetype": "text/x-python", 154 | "name": "python", 155 | "nbconvert_exporter": "python", 156 | "pygments_lexer": "ipython3", 157 | "version": "3.6.0" 158 | } 159 | }, 160 | "nbformat": 4, 161 | "nbformat_minor": 1 162 | } 163 | -------------------------------------------------------------------------------- /3-Programmieren mit R/3-Bedingte Anweisungen Übung - Aufgaben.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Bedingte Anweisungen Übung - Aufgaben\n", 8 | "\n", 9 | "Für diese Übung wollen wir anwenden, was wir über if, else if und else Anweisungen gelernt haben! Die erste Aufgabe ist dabei exemplarisch gelöst:\n", 10 | "\n", 11 | "**Schreibe ein Skript, das \"Hallo\" ausgibt (->print), wenn die Variable x gleich 1 ist:**" 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 1, 17 | "metadata": { 18 | "collapsed": false 19 | }, 20 | "outputs": [ 21 | { 22 | "name": "stdout", 23 | "output_type": "stream", 24 | "text": [ 25 | "[1] \"Hallo\"\n" 26 | ] 27 | } 28 | ], 29 | "source": [ 30 | "x <- 1\n", 31 | "\n", 32 | "if (x ==1){\n", 33 | " print(\"Hallo\")\n", 34 | "}" 35 | ] 36 | }, 37 | { 38 | "cell_type": "markdown", 39 | "metadata": {}, 40 | "source": [ 41 | "**Schreibe ein Skript das \"Gerade Zahl\" ausgibt, wenn die Variable x eine gerade Zahl ist. Andernfalls wollen wir \"Ungerade\" ausgeben.**" 42 | ] 43 | }, 44 | { 45 | "cell_type": "code", 46 | "execution_count": 2, 47 | "metadata": { 48 | "collapsed": false 49 | }, 50 | "outputs": [ 51 | { 52 | "name": "stdout", 53 | "output_type": "stream", 54 | "text": [ 55 | "[1] \"Ungerade\"\n" 56 | ] 57 | } 58 | ], 59 | "source": [] 60 | }, 61 | { 62 | "cell_type": "markdown", 63 | "metadata": {}, 64 | "source": [ 65 | "**Schreibe ein Skript, das \"Ist eine Matrix\" ausgibt, falls die Variable x eine Matrix beinhaltet. Andernfalls soll das Ergebnis \"Keine Matrix\" lauten.**" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": 3, 71 | "metadata": { 72 | "collapsed": false 73 | }, 74 | "outputs": [ 75 | { 76 | "name": "stdout", 77 | "output_type": "stream", 78 | "text": [ 79 | "[1] \"Ist eine Matrix\"\n" 80 | ] 81 | } 82 | ], 83 | "source": [] 84 | }, 85 | { 86 | "cell_type": "markdown", 87 | "metadata": {}, 88 | "source": [ 89 | "**Erstelle ein Skript, dass einen numerischen Vektor mit 3 Werten als Eingabe aufnimmt und die Elemente darin von groß nach klein sortiert ausgibt. Dazu musst du if, else if und else für deine Logik verwenden.**" 90 | ] 91 | }, 92 | { 93 | "cell_type": "code", 94 | "execution_count": 5, 95 | "metadata": { 96 | "collapsed": false 97 | }, 98 | "outputs": [ 99 | { 100 | "name": "stdout", 101 | "output_type": "stream", 102 | "text": [ 103 | "[1] \"8 4 3\"\n" 104 | ] 105 | } 106 | ], 107 | "source": [] 108 | }, 109 | { 110 | "cell_type": "markdown", 111 | "metadata": {}, 112 | "source": [ 113 | "**Schreibe unter Verwendung von if, else if und else Anweisungen ein Skript, das den höchsten von drei Werten in einem numerischen Vektor ausgibt.**" 114 | ] 115 | }, 116 | { 117 | "cell_type": "code", 118 | "execution_count": 6, 119 | "metadata": { 120 | "collapsed": false 121 | }, 122 | "outputs": [ 123 | { 124 | "name": "stdout", 125 | "output_type": "stream", 126 | "text": [ 127 | "[1] 20\n" 128 | ] 129 | } 130 | ], 131 | "source": [] 132 | }, 133 | { 134 | "cell_type": "markdown", 135 | "metadata": {}, 136 | "source": [ 137 | "## Great Job!" 138 | ] 139 | } 140 | ], 141 | "metadata": { 142 | "kernelspec": { 143 | "display_name": "Python 3", 144 | "language": "python", 145 | "name": "python3" 146 | }, 147 | "language_info": { 148 | "codemirror_mode": { 149 | "name": "ipython", 150 | "version": 3 151 | }, 152 | "file_extension": ".py", 153 | "mimetype": "text/x-python", 154 | "name": "python", 155 | "nbconvert_exporter": "python", 156 | "pygments_lexer": "ipython3", 157 | "version": "3.6.0" 158 | } 159 | }, 160 | "nbformat": 4, 161 | "nbformat_minor": 1 162 | } 163 | -------------------------------------------------------------------------------- /3-Programmieren mit R/4-Bedingte Anweisungen Übung - Lösung.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Bedingte Anweisungen Übung - Lösung\n", 8 | "\n", 9 | "Für diese Übung wollen wir anwenden, was wir über if, else if und else Anweisungen gelernt haben! Die erste Aufgabe ist dabei exemplarisch gelöst:\n", 10 | "\n", 11 | "**Schreibe ein Skript, das \"Hallo\" ausgibt (->print), wenn die Variable x gleich 1 ist:**" 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 1, 17 | "metadata": { 18 | "collapsed": false 19 | }, 20 | "outputs": [ 21 | { 22 | "name": "stdout", 23 | "output_type": "stream", 24 | "text": [ 25 | "[1] \"Hallo\"\n" 26 | ] 27 | } 28 | ], 29 | "source": [ 30 | "x <- 1\n", 31 | "\n", 32 | "if (x ==1){\n", 33 | " print(\"Hallo\")\n", 34 | "}" 35 | ] 36 | }, 37 | { 38 | "cell_type": "markdown", 39 | "metadata": {}, 40 | "source": [ 41 | "**Schreibe ein Skript das \"Gerade Zahl\" ausgibt, wenn die Variable x eine gerade Zahl ist. Andernfalls wollen wir \"Ungerade\" ausgeben.**" 42 | ] 43 | }, 44 | { 45 | "cell_type": "code", 46 | "execution_count": 2, 47 | "metadata": { 48 | "collapsed": false 49 | }, 50 | "outputs": [ 51 | { 52 | "name": "stdout", 53 | "output_type": "stream", 54 | "text": [ 55 | "[1] \"Ungerade\"\n" 56 | ] 57 | } 58 | ], 59 | "source": [ 60 | "x <- 3 # Ändere x zum Testen\n", 61 | "\n", 62 | "if (x%%2 == 0){\n", 63 | " print('Gerade Zahl')\n", 64 | "}else{\n", 65 | " print('Ungerade')\n", 66 | "}" 67 | ] 68 | }, 69 | { 70 | "cell_type": "markdown", 71 | "metadata": {}, 72 | "source": [ 73 | "**Schreibe ein Skript, das \"Ist eine Matrix\" ausgibt, falls die Variable x eine Matrix beinhaltet. Andernfalls soll das Ergebnis \"Keine Matrix\" lauten.**" 74 | ] 75 | }, 76 | { 77 | "cell_type": "code", 78 | "execution_count": 3, 79 | "metadata": { 80 | "collapsed": false 81 | }, 82 | "outputs": [ 83 | { 84 | "name": "stdout", 85 | "output_type": "stream", 86 | "text": [ 87 | "[1] \"Ist eine Matrix\"\n" 88 | ] 89 | } 90 | ], 91 | "source": [ 92 | "x <- matrix()\n", 93 | "\n", 94 | "if (is.matrix(x)){\n", 95 | " print('Ist eine Matrix')\n", 96 | "}else{\n", 97 | " print(\"Keine Matrix\")\n", 98 | "}" 99 | ] 100 | }, 101 | { 102 | "cell_type": "markdown", 103 | "metadata": {}, 104 | "source": [ 105 | "**Erstelle ein Skript, dass einen numerischen Vektor mit 3 Werten als Eingabe aufnimmt und die Elemente darin von groß nach klein sortiert ausgibt. Dazu musst du if, else if und else für deine Logik verwenden.**" 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": 5, 111 | "metadata": { 112 | "collapsed": false 113 | }, 114 | "outputs": [ 115 | { 116 | "name": "stdout", 117 | "output_type": "stream", 118 | "text": [ 119 | "[1] \"8 4 3\"\n" 120 | ] 121 | } 122 | ], 123 | "source": [ 124 | "x <- c(4,3,8)\n", 125 | "\n", 126 | "if (x[1] > x[2]){\n", 127 | " erstes <- x[1]\n", 128 | " zweites <- x[2]\n", 129 | "} else {\n", 130 | " erstes <- x[2]\n", 131 | " zweites <- x[1]\n", 132 | "}\n", 133 | "if ( x[3] > erstes & x[3] > zweites ) {\n", 134 | " drittes <- zweites\n", 135 | " zweites <- erstes\n", 136 | " erstes <- x[3]\n", 137 | "} else if ( x[3] < erstes & x[3] < zweites ) {\n", 138 | " drittes <- x[3]\n", 139 | "} else {\n", 140 | " drittes <- zweites\n", 141 | " zweites <- x[3]\n", 142 | "}\n", 143 | "\n", 144 | "print(paste(erstes, zweites, drittes))" 145 | ] 146 | }, 147 | { 148 | "cell_type": "markdown", 149 | "metadata": {}, 150 | "source": [ 151 | "**Schreibe unter Verwendung von if, else if und else Anweisungen ein Skript, das den höchsten von drei Werten in einem numerischen Vektor ausgibt.**" 152 | ] 153 | }, 154 | { 155 | "cell_type": "code", 156 | "execution_count": 6, 157 | "metadata": { 158 | "collapsed": false 159 | }, 160 | "outputs": [ 161 | { 162 | "name": "stdout", 163 | "output_type": "stream", 164 | "text": [ 165 | "[1] 20\n" 166 | ] 167 | } 168 | ], 169 | "source": [ 170 | "x <- c(20, 10, 1)\n", 171 | "\n", 172 | "if (x[1] > x[2] & x[1] > x[3] ) {\n", 173 | " print(x[1] )\n", 174 | "} else if (x[2] > x[3] ) {\n", 175 | " print(x[2])\n", 176 | "} else {\n", 177 | " print(x[3])\n", 178 | "}" 179 | ] 180 | }, 181 | { 182 | "cell_type": "markdown", 183 | "metadata": {}, 184 | "source": [ 185 | "## Great Job!" 186 | ] 187 | } 188 | ], 189 | "metadata": { 190 | "kernelspec": { 191 | "display_name": "Python 3", 192 | "language": "python", 193 | "name": "python3" 194 | }, 195 | "language_info": { 196 | "codemirror_mode": { 197 | "name": "ipython", 198 | "version": 3 199 | }, 200 | "file_extension": ".py", 201 | "mimetype": "text/x-python", 202 | "name": "python", 203 | "nbconvert_exporter": "python", 204 | "pygments_lexer": "ipython3", 205 | "version": "3.6.0" 206 | } 207 | }, 208 | "nbformat": 4, 209 | "nbformat_minor": 1 210 | } 211 | -------------------------------------------------------------------------------- /3-Programmieren mit R/4-Bedingte Anweisungen Übung - Lösung.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Bedingte Anweisungen Übung - Lösung\n", 8 | "\n", 9 | "Für diese Übung wollen wir anwenden, was wir über if, else if und else Anweisungen gelernt haben! Die erste Aufgabe ist dabei exemplarisch gelöst:\n", 10 | "\n", 11 | "**Schreibe ein Skript, das \"Hallo\" ausgibt (->print), wenn die Variable x gleich 1 ist:**" 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 1, 17 | "metadata": { 18 | "collapsed": false 19 | }, 20 | "outputs": [ 21 | { 22 | "name": "stdout", 23 | "output_type": "stream", 24 | "text": [ 25 | "[1] \"Hallo\"\n" 26 | ] 27 | } 28 | ], 29 | "source": [ 30 | "x <- 1\n", 31 | "\n", 32 | "if (x ==1){\n", 33 | " print(\"Hallo\")\n", 34 | "}" 35 | ] 36 | }, 37 | { 38 | "cell_type": "markdown", 39 | "metadata": {}, 40 | "source": [ 41 | "**Schreibe ein Skript das \"Gerade Zahl\" ausgibt, wenn die Variable x eine gerade Zahl ist. Andernfalls wollen wir \"Ungerade\" ausgeben.**" 42 | ] 43 | }, 44 | { 45 | "cell_type": "code", 46 | "execution_count": 2, 47 | "metadata": { 48 | "collapsed": false 49 | }, 50 | "outputs": [ 51 | { 52 | "name": "stdout", 53 | "output_type": "stream", 54 | "text": [ 55 | "[1] \"Ungerade\"\n" 56 | ] 57 | } 58 | ], 59 | "source": [ 60 | "x <- 3 # Ändere x zum Testen\n", 61 | "\n", 62 | "if (x%%2 == 0){\n", 63 | " print('Gerade Zahl')\n", 64 | "}else{\n", 65 | " print('Ungerade')\n", 66 | "}" 67 | ] 68 | }, 69 | { 70 | "cell_type": "markdown", 71 | "metadata": {}, 72 | "source": [ 73 | "**Schreibe ein Skript, das \"Ist eine Matrix\" ausgibt, falls die Variable x eine Matrix beinhaltet. Andernfalls soll das Ergebnis \"Keine Matrix\" lauten.**" 74 | ] 75 | }, 76 | { 77 | "cell_type": "code", 78 | "execution_count": 3, 79 | "metadata": { 80 | "collapsed": false 81 | }, 82 | "outputs": [ 83 | { 84 | "name": "stdout", 85 | "output_type": "stream", 86 | "text": [ 87 | "[1] \"Ist eine Matrix\"\n" 88 | ] 89 | } 90 | ], 91 | "source": [ 92 | "x <- matrix()\n", 93 | "\n", 94 | "if (is.matrix(x)){\n", 95 | " print('Ist eine Matrix')\n", 96 | "}else{\n", 97 | " print(\"Keine Matrix\")\n", 98 | "}" 99 | ] 100 | }, 101 | { 102 | "cell_type": "markdown", 103 | "metadata": {}, 104 | "source": [ 105 | "**Erstelle ein Skript, dass einen numerischen Vektor mit 3 Werten als Eingabe aufnimmt und die Elemente darin von groß nach klein sortiert ausgibt. Dazu musst du if, else if und else für deine Logik verwenden.**" 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": 5, 111 | "metadata": { 112 | "collapsed": false 113 | }, 114 | "outputs": [ 115 | { 116 | "name": "stdout", 117 | "output_type": "stream", 118 | "text": [ 119 | "[1] \"8 4 3\"\n" 120 | ] 121 | } 122 | ], 123 | "source": [ 124 | "x <- c(4,3,8)\n", 125 | "\n", 126 | "if (x[1] > x[2]){\n", 127 | " erstes <- x[1]\n", 128 | " zweites <- x[2]\n", 129 | "} else {\n", 130 | " erstes <- x[2]\n", 131 | " zweites <- x[1]\n", 132 | "}\n", 133 | "if ( x[3] > erstes & x[3] > zweites ) {\n", 134 | " drittes <- zweites\n", 135 | " zweites <- erstes\n", 136 | " erstes <- x[3]\n", 137 | "} else if ( x[3] < erstes & x[3] < zweites ) {\n", 138 | " drittes <- x[3]\n", 139 | "} else {\n", 140 | " drittes <- zweites\n", 141 | " zweites <- x[3]\n", 142 | "}\n", 143 | "\n", 144 | "print(paste(erstes, zweites, drittes))" 145 | ] 146 | }, 147 | { 148 | "cell_type": "markdown", 149 | "metadata": {}, 150 | "source": [ 151 | "**Schreibe unter Verwendung von if, else if und else Anweisungen ein Skript, das den höchsten von drei Werten in einem numerischen Vektor ausgibt.**" 152 | ] 153 | }, 154 | { 155 | "cell_type": "code", 156 | "execution_count": 6, 157 | "metadata": { 158 | "collapsed": false 159 | }, 160 | "outputs": [ 161 | { 162 | "name": "stdout", 163 | "output_type": "stream", 164 | "text": [ 165 | "[1] 20\n" 166 | ] 167 | } 168 | ], 169 | "source": [ 170 | "x <- c(20, 10, 1)\n", 171 | "\n", 172 | "if (x[1] > x[2] & x[1] > x[3] ) {\n", 173 | " print(x[1] )\n", 174 | "} else if (x[2] > x[3] ) {\n", 175 | " print(x[2])\n", 176 | "} else {\n", 177 | " print(x[3])\n", 178 | "}" 179 | ] 180 | }, 181 | { 182 | "cell_type": "markdown", 183 | "metadata": {}, 184 | "source": [ 185 | "## Great Job!" 186 | ] 187 | } 188 | ], 189 | "metadata": { 190 | "kernelspec": { 191 | "display_name": "Python 3", 192 | "language": "python", 193 | "name": "python3" 194 | }, 195 | "language_info": { 196 | "codemirror_mode": { 197 | "name": "ipython", 198 | "version": 3 199 | }, 200 | "file_extension": ".py", 201 | "mimetype": "text/x-python", 202 | "name": "python", 203 | "nbconvert_exporter": "python", 204 | "pygments_lexer": "ipython3", 205 | "version": "3.6.0" 206 | } 207 | }, 208 | "nbformat": 4, 209 | "nbformat_minor": 1 210 | } 211 | -------------------------------------------------------------------------------- /3-Programmieren mit R/5-While Schleifen.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# While Schleifen\n", 8 | "\n", 9 | "`while` Schleifen sind eine Möglichkeit unsere Programm so lange laufen zu lassen, solange eine bestimmte Bedingung erfüllt ist (d.h. TRUE ergibt). Die Syntax lautet:\n", 10 | "\n", 11 | " while (Bedingung){\n", 12 | " # Führe diesen Code aus\n", 13 | " # Solange die Bedingung erfüllt ist\n", 14 | " }\n", 15 | "\n", 16 | "Einer der wichtigsten Aspekte bei der Arbeit mit while Schleifen ist, darauf zu achten, dass die Bedingungn zu irgendeinem Zeitpunkt wirklich nicht mehr erfüllt wird. Andernfalls würden wir in einer unendlichen Schleife landen. Deshab der **Hinweis**: In R Studio können wir Prozesse mit Strg + C beenden (Cmd + C für MAC).\n", 17 | "\n", 18 | "Hier noch ein kurzer Exkurs dazu Variablen gemeinsam mit Strings auszugeben:" 19 | ] 20 | }, 21 | { 22 | "cell_type": "code", 23 | "execution_count": 1, 24 | "metadata": { 25 | "collapsed": false 26 | }, 27 | "outputs": [ 28 | { 29 | "name": "stdout", 30 | "output_type": "stream", 31 | "text": [ 32 | "[1] \"Nur ein String\"\n" 33 | ] 34 | } 35 | ], 36 | "source": [ 37 | "print('Nur ein String')" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": 4, 43 | "metadata": { 44 | "collapsed": false 45 | }, 46 | "outputs": [ 47 | { 48 | "name": "stdout", 49 | "output_type": "stream", 50 | "text": [ 51 | "Meine Variable ist: Eine Variable" 52 | ] 53 | } 54 | ], 55 | "source": [ 56 | "var <- 'Eine Variable'\n", 57 | "cat('Meine Variable ist:',var)" 58 | ] 59 | }, 60 | { 61 | "cell_type": "code", 62 | "execution_count": 5, 63 | "metadata": { 64 | "collapsed": false 65 | }, 66 | "outputs": [ 67 | { 68 | "name": "stdout", 69 | "output_type": "stream", 70 | "text": [ 71 | "Meine Nummer ist: 25" 72 | ] 73 | } 74 | ], 75 | "source": [ 76 | "var <- 25\n", 77 | "cat('Meine Nummer ist:',var)" 78 | ] 79 | }, 80 | { 81 | "cell_type": "code", 82 | "execution_count": 7, 83 | "metadata": { 84 | "collapsed": false 85 | }, 86 | "outputs": [ 87 | { 88 | "name": "stdout", 89 | "output_type": "stream", 90 | "text": [ 91 | "[1] \"Variable ist: 25\"\n" 92 | ] 93 | } 94 | ], 95 | "source": [ 96 | "# Alternativer Weg\n", 97 | "print(paste0(\"Variable ist: \", var))" 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "metadata": {}, 103 | "source": [ 104 | "Im folgenden Beispiel werden wir die `cat` Funktion verwenden und eine erste while-Schleife programmieren:" 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": 8, 110 | "metadata": { 111 | "collapsed": false 112 | }, 113 | "outputs": [ 114 | { 115 | "name": "stdout", 116 | "output_type": "stream", 117 | "text": [ 118 | "x ist aktuell: 0[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 119 | "x ist aktuell: 1[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 120 | "x ist aktuell: 2[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 121 | "x ist aktuell: 3[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 122 | "x ist aktuell: 4[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 123 | "x ist aktuell: 5[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 124 | "x ist aktuell: 6[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 125 | "x ist aktuell: 7[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 126 | "x ist aktuell: 8[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 127 | "x ist aktuell: 9[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n" 128 | ] 129 | } 130 | ], 131 | "source": [ 132 | "x <- 0\n", 133 | "\n", 134 | "while(x < 10){\n", 135 | " \n", 136 | " cat('x ist aktuell:',x)\n", 137 | " print(' x liegt immer noch unter 10, füge 1 zu x hinzu')\n", 138 | " \n", 139 | " # x um eins erhöhen\n", 140 | " x <- x+1\n", 141 | "}\n" 142 | ] 143 | }, 144 | { 145 | "cell_type": "markdown", 146 | "metadata": {}, 147 | "source": [ 148 | "Ergänzen wir diese Logik um eine if-Anweisung:" 149 | ] 150 | }, 151 | { 152 | "cell_type": "code", 153 | "execution_count": 9, 154 | "metadata": { 155 | "collapsed": false 156 | }, 157 | "outputs": [ 158 | { 159 | "name": "stdout", 160 | "output_type": "stream", 161 | "text": [ 162 | "x ist aktuell: 0[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 163 | "x ist aktuell: 1[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 164 | "x ist aktuell: 2[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 165 | "x ist aktuell: 3[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 166 | "x ist aktuell: 4[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 167 | "x ist aktuell: 5[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 168 | "x ist aktuell: 6[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 169 | "x ist aktuell: 7[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 170 | "x ist aktuell: 8[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 171 | "x ist aktuell: 9[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 172 | "[1] \"x ist jetzt 10! Schleife beenden\"\n" 173 | ] 174 | } 175 | ], 176 | "source": [ 177 | "x <- 0\n", 178 | "\n", 179 | "while(x < 10){\n", 180 | " \n", 181 | " cat('x ist aktuell:',x)\n", 182 | " print(' x liegt immer noch unter 10, füge 1 zu x hinzu')\n", 183 | " \n", 184 | " # x um eins erhöhen\n", 185 | " x <- x+1\n", 186 | " if(x==10){\n", 187 | " print(\"x ist jetzt 10! Schleife beenden\")\n", 188 | " }\n", 189 | "}\n" 190 | ] 191 | }, 192 | { 193 | "cell_type": "markdown", 194 | "metadata": {}, 195 | "source": [ 196 | "## break\n", 197 | "\n", 198 | "Wir können `break` benutzen, um aus einer Schleife auszubrechen. Zuvor haben wir eine if-Anweisung genutzt, um zu überprüfen, ob x bereits den Wert 10 hat. Diese hat die Schleife aber nicht tatsächlich beendet. Die Bedingung der while-Schleife wurde beim nächsten Durchlauf ganz einfach nicht mehr erfüllt. Schauen wir uns jetzt ein Beispiel an, in dem wir `break` nutzen, um die Schleife tatsächlich zu beenden:" 199 | ] 200 | }, 201 | { 202 | "cell_type": "code", 203 | "execution_count": 10, 204 | "metadata": { 205 | "collapsed": false 206 | }, 207 | "outputs": [ 208 | { 209 | "name": "stdout", 210 | "output_type": "stream", 211 | "text": [ 212 | "x ist aktuell: 0[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 213 | "x ist aktuell: 1[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 214 | "x ist aktuell: 2[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 215 | "x ist aktuell: 3[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 216 | "x ist aktuell: 4[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 217 | "x ist aktuell: 5[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 218 | "x ist aktuell: 6[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 219 | "x ist aktuell: 7[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 220 | "x ist aktuell: 8[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 221 | "x ist aktuell: 9[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 222 | "[1] \"x ist jetzt 10!\"\n", 223 | "[1] \"Yeah, ich werde auch ausgegeben!\"\n" 224 | ] 225 | } 226 | ], 227 | "source": [ 228 | "x <- 0\n", 229 | "\n", 230 | "while(x < 10){\n", 231 | " \n", 232 | " cat('x ist aktuell:',x)\n", 233 | " print(' x liegt immer noch unter 10, füge 1 zu x hinzu')\n", 234 | " \n", 235 | " # x um eins erhöhen\n", 236 | " x <- x+1\n", 237 | " if(x==10){\n", 238 | " print(\"x ist jetzt 10!\")\n", 239 | " print(\"Yeah, ich werde auch ausgegeben!\")\n", 240 | " }\n", 241 | "}" 242 | ] 243 | }, 244 | { 245 | "cell_type": "code", 246 | "execution_count": 11, 247 | "metadata": { 248 | "collapsed": false 249 | }, 250 | "outputs": [ 251 | { 252 | "name": "stdout", 253 | "output_type": "stream", 254 | "text": [ 255 | "x ist aktuell: 0[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 256 | "x ist aktuell: 1[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 257 | "x ist aktuell: 2[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 258 | "x ist aktuell: 3[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 259 | "x ist aktuell: 4[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 260 | "x ist aktuell: 5[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 261 | "x ist aktuell: 6[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 262 | "x ist aktuell: 7[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 263 | "x ist aktuell: 8[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 264 | "x ist aktuell: 9[1] \" x liegt immer noch unter 10, füge 1 zu x hinzu\"\n", 265 | "[1] \"x ist jetzt 10!\"\n" 266 | ] 267 | } 268 | ], 269 | "source": [ 270 | "x <- 0\n", 271 | "\n", 272 | "while(x < 10){\n", 273 | " \n", 274 | " cat('x ist aktuell:',x)\n", 275 | " print(' x liegt immer noch unter 10, füge 1 zu x hinzu')\n", 276 | " \n", 277 | " # x um eins erhöhen\n", 278 | " x <- x+1\n", 279 | " if(x==10){\n", 280 | " print(\"x ist jetzt 10!\")\n", 281 | " break\n", 282 | " print(\"Yeah, ich werde auch ausgegeben!\")\n", 283 | " }\n", 284 | "}" 285 | ] 286 | }, 287 | { 288 | "cell_type": "markdown", 289 | "metadata": {}, 290 | "source": [ 291 | "Achtet darauf, wie `break` die Schleife beendet hat und \"Yeah, ich werde auch ausgegeben!\" nicht mehr ausgegeben wurde! So können wir `break` auch als weitere Kontrolle innerhalb der Schleife benutzen und weitere Bedingungen überprüfen. \n", 292 | "\n", 293 | "Als nächstes schauen wir uns die verwandten for-Schleifen an!" 294 | ] 295 | } 296 | ], 297 | "metadata": { 298 | "kernelspec": { 299 | "display_name": "Python 3", 300 | "language": "python", 301 | "name": "python3" 302 | }, 303 | "language_info": { 304 | "codemirror_mode": { 305 | "name": "ipython", 306 | "version": 3 307 | }, 308 | "file_extension": ".py", 309 | "mimetype": "text/x-python", 310 | "name": "python", 311 | "nbconvert_exporter": "python", 312 | "pygments_lexer": "ipython3", 313 | "version": "3.6.0" 314 | } 315 | }, 316 | "nbformat": 4, 317 | "nbformat_minor": 1 318 | } 319 | -------------------------------------------------------------------------------- /3-Programmieren mit R/6-For Schleifen.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# For Schleifen\n", 8 | "\n", 9 | "Eine **for-Schleife** erlaubt es uns über ein Objekt (wie z.B. einen Vektor) zu iterieren und dann Code-Blöcke für (en. for) jeden Durchlauf auszuführen. Die Syntax lautet:\n", 10 | "\n", 11 | " for (temporäre_variable in Objekt){\n", 12 | " # Führe für jeden Durchgang diesen Code aus\n", 13 | " }\n", 14 | "\n", 15 | "Starten wir nun mit einer for-Schleife für einen Vektor:" 16 | ] 17 | }, 18 | { 19 | "cell_type": "markdown", 20 | "metadata": {}, 21 | "source": [ 22 | "## For Schleife über einen Vektor\n", 23 | "\n", 24 | "Wir können uns die Schleifen über einen Vektor in zwei Varianten vorstellen. Der erste Weg wäre der, eine temporäre Variable zu erstellen und diese mit dem `in` Keyword zu kombinieren:" 25 | ] 26 | }, 27 | { 28 | "cell_type": "code", 29 | "execution_count": 2, 30 | "metadata": { 31 | "collapsed": true 32 | }, 33 | "outputs": [], 34 | "source": [ 35 | "vec <- c(1,2,3,4,5)" 36 | ] 37 | }, 38 | { 39 | "cell_type": "code", 40 | "execution_count": 3, 41 | "metadata": { 42 | "collapsed": false 43 | }, 44 | "outputs": [ 45 | { 46 | "name": "stdout", 47 | "output_type": "stream", 48 | "text": [ 49 | "[1] 1\n", 50 | "[1] 2\n", 51 | "[1] 3\n", 52 | "[1] 4\n", 53 | "[1] 5\n" 54 | ] 55 | } 56 | ], 57 | "source": [ 58 | "for (temp_var in vec){\n", 59 | " print(temp_var)\n", 60 | "}" 61 | ] 62 | }, 63 | { 64 | "cell_type": "markdown", 65 | "metadata": {}, 66 | "source": [ 67 | "Der andere Weg wäre die Schleifen durch eine abgezählte Anzahl an Durchläufen zu definieren und dann fortlaufend den Index der Vektorelemente zu bestimmen:" 68 | ] 69 | }, 70 | { 71 | "cell_type": "code", 72 | "execution_count": 4, 73 | "metadata": { 74 | "collapsed": false 75 | }, 76 | "outputs": [ 77 | { 78 | "name": "stdout", 79 | "output_type": "stream", 80 | "text": [ 81 | "[1] 1\n", 82 | "[1] 2\n", 83 | "[1] 3\n", 84 | "[1] 4\n", 85 | "[1] 5\n" 86 | ] 87 | } 88 | ], 89 | "source": [ 90 | "for (i in 1:length(vec)){\n", 91 | " print(vec[i])\n", 92 | "}" 93 | ] 94 | }, 95 | { 96 | "cell_type": "markdown", 97 | "metadata": {}, 98 | "source": [ 99 | "## For Schleife über eine Liste\n", 100 | "\n", 101 | "Wir können das selbe für eine Liste anwenden:" 102 | ] 103 | }, 104 | { 105 | "cell_type": "code", 106 | "execution_count": 5, 107 | "metadata": { 108 | "collapsed": true 109 | }, 110 | "outputs": [], 111 | "source": [ 112 | "li <- list(1,2,3,4,5)" 113 | ] 114 | }, 115 | { 116 | "cell_type": "code", 117 | "execution_count": 6, 118 | "metadata": { 119 | "collapsed": false 120 | }, 121 | "outputs": [ 122 | { 123 | "name": "stdout", 124 | "output_type": "stream", 125 | "text": [ 126 | "[1] 1\n", 127 | "[1] 2\n", 128 | "[1] 3\n", 129 | "[1] 4\n", 130 | "[1] 5\n" 131 | ] 132 | } 133 | ], 134 | "source": [ 135 | "for (temp_var in li){\n", 136 | " print(temp_var)\n", 137 | "}" 138 | ] 139 | }, 140 | { 141 | "cell_type": "code", 142 | "execution_count": 7, 143 | "metadata": { 144 | "collapsed": false 145 | }, 146 | "outputs": [ 147 | { 148 | "name": "stdout", 149 | "output_type": "stream", 150 | "text": [ 151 | "[1] 1\n", 152 | "[1] 2\n", 153 | "[1] 3\n", 154 | "[1] 4\n", 155 | "[1] 5\n" 156 | ] 157 | } 158 | ], 159 | "source": [ 160 | "for (i in 1:length(li)){\n", 161 | " print(li[[i]]) # Hier müssen wir an die doppelten Klammern denken!\n", 162 | "}" 163 | ] 164 | }, 165 | { 166 | "cell_type": "markdown", 167 | "metadata": {}, 168 | "source": [ 169 | "## For Schleife mit einer Matrix\n", 170 | "\n", 171 | "Genauso können wir Durchläufe über jedes Element in einer Matrix durchführen:" 172 | ] 173 | }, 174 | { 175 | "cell_type": "code", 176 | "execution_count": 8, 177 | "metadata": { 178 | "collapsed": false 179 | }, 180 | "outputs": [ 181 | { 182 | "data": { 183 | "text/html": [ 184 | "\n", 185 | "\n", 186 | "\t\n", 187 | "\t\n", 188 | "\t\n", 189 | "\t\n", 190 | "\t\n", 191 | "\n", 192 | "
1 6111621
2 7121722
3 8131823
4 9141924
5 10152025
\n" 193 | ], 194 | "text/latex": [ 195 | "\\begin{tabular}{lllll}\n", 196 | "\t 1 & 6 & 11 & 16 & 21\\\\\n", 197 | "\t 2 & 7 & 12 & 17 & 22\\\\\n", 198 | "\t 3 & 8 & 13 & 18 & 23\\\\\n", 199 | "\t 4 & 9 & 14 & 19 & 24\\\\\n", 200 | "\t 5 & 10 & 15 & 20 & 25\\\\\n", 201 | "\\end{tabular}\n" 202 | ], 203 | "text/markdown": [ 204 | "\n", 205 | "| 1 | 6 | 11 | 16 | 21 | \n", 206 | "| 2 | 7 | 12 | 17 | 22 | \n", 207 | "| 3 | 8 | 13 | 18 | 23 | \n", 208 | "| 4 | 9 | 14 | 19 | 24 | \n", 209 | "| 5 | 10 | 15 | 20 | 25 | \n", 210 | "\n", 211 | "\n" 212 | ], 213 | "text/plain": [ 214 | " [,1] [,2] [,3] [,4] [,5]\n", 215 | "[1,] 1 6 11 16 21 \n", 216 | "[2,] 2 7 12 17 22 \n", 217 | "[3,] 3 8 13 18 23 \n", 218 | "[4,] 4 9 14 19 24 \n", 219 | "[5,] 5 10 15 20 25 " 220 | ] 221 | }, 222 | "metadata": {}, 223 | "output_type": "display_data" 224 | } 225 | ], 226 | "source": [ 227 | "mat <- matrix(1:25,nrow=5)\n", 228 | "mat" 229 | ] 230 | }, 231 | { 232 | "cell_type": "code", 233 | "execution_count": 9, 234 | "metadata": { 235 | "collapsed": false 236 | }, 237 | "outputs": [ 238 | { 239 | "name": "stdout", 240 | "output_type": "stream", 241 | "text": [ 242 | "[1] 1\n", 243 | "[1] 2\n", 244 | "[1] 3\n", 245 | "[1] 4\n", 246 | "[1] 5\n", 247 | "[1] 6\n", 248 | "[1] 7\n", 249 | "[1] 8\n", 250 | "[1] 9\n", 251 | "[1] 10\n", 252 | "[1] 11\n", 253 | "[1] 12\n", 254 | "[1] 13\n", 255 | "[1] 14\n", 256 | "[1] 15\n", 257 | "[1] 16\n", 258 | "[1] 17\n", 259 | "[1] 18\n", 260 | "[1] 19\n", 261 | "[1] 20\n", 262 | "[1] 21\n", 263 | "[1] 22\n", 264 | "[1] 23\n", 265 | "[1] 24\n", 266 | "[1] 25\n" 267 | ] 268 | } 269 | ], 270 | "source": [ 271 | "for (num in mat){\n", 272 | " print(num)\n", 273 | "}" 274 | ] 275 | }, 276 | { 277 | "cell_type": "markdown", 278 | "metadata": {}, 279 | "source": [ 280 | "## Verschachtelte for-Schleifen\n", 281 | "\n", 282 | "Wir können for-Schleifen ineinander verschachteln. Allerdings müssen wir darauf achten, dass jede for-Schleife, die in eine andere eingebettet wird, die Anzahl der Befehle und Durchführungszeit extrem erhöhen kann." 283 | ] 284 | }, 285 | { 286 | "cell_type": "code", 287 | "execution_count": 10, 288 | "metadata": { 289 | "collapsed": false 290 | }, 291 | "outputs": [ 292 | { 293 | "name": "stdout", 294 | "output_type": "stream", 295 | "text": [ 296 | "[1] \"Das Element in Zeile: 1 und Spalte: 1 ist 1\"\n", 297 | "[1] \"Das Element in Zeile: 1 und Spalte: 2 ist 6\"\n", 298 | "[1] \"Das Element in Zeile: 1 und Spalte: 3 ist 11\"\n", 299 | "[1] \"Das Element in Zeile: 1 und Spalte: 4 ist 16\"\n", 300 | "[1] \"Das Element in Zeile: 1 und Spalte: 5 ist 21\"\n", 301 | "[1] \"Das Element in Zeile: 2 und Spalte: 1 ist 2\"\n", 302 | "[1] \"Das Element in Zeile: 2 und Spalte: 2 ist 7\"\n", 303 | "[1] \"Das Element in Zeile: 2 und Spalte: 3 ist 12\"\n", 304 | "[1] \"Das Element in Zeile: 2 und Spalte: 4 ist 17\"\n", 305 | "[1] \"Das Element in Zeile: 2 und Spalte: 5 ist 22\"\n", 306 | "[1] \"Das Element in Zeile: 3 und Spalte: 1 ist 3\"\n", 307 | "[1] \"Das Element in Zeile: 3 und Spalte: 2 ist 8\"\n", 308 | "[1] \"Das Element in Zeile: 3 und Spalte: 3 ist 13\"\n", 309 | "[1] \"Das Element in Zeile: 3 und Spalte: 4 ist 18\"\n", 310 | "[1] \"Das Element in Zeile: 3 und Spalte: 5 ist 23\"\n", 311 | "[1] \"Das Element in Zeile: 4 und Spalte: 1 ist 4\"\n", 312 | "[1] \"Das Element in Zeile: 4 und Spalte: 2 ist 9\"\n", 313 | "[1] \"Das Element in Zeile: 4 und Spalte: 3 ist 14\"\n", 314 | "[1] \"Das Element in Zeile: 4 und Spalte: 4 ist 19\"\n", 315 | "[1] \"Das Element in Zeile: 4 und Spalte: 5 ist 24\"\n", 316 | "[1] \"Das Element in Zeile: 5 und Spalte: 1 ist 5\"\n", 317 | "[1] \"Das Element in Zeile: 5 und Spalte: 2 ist 10\"\n", 318 | "[1] \"Das Element in Zeile: 5 und Spalte: 3 ist 15\"\n", 319 | "[1] \"Das Element in Zeile: 5 und Spalte: 4 ist 20\"\n", 320 | "[1] \"Das Element in Zeile: 5 und Spalte: 5 ist 25\"\n" 321 | ] 322 | } 323 | ], 324 | "source": [ 325 | "for (zeile in 1:nrow(mat)){\n", 326 | " for (spalte in 1:ncol(mat)){\n", 327 | " print(paste('Das Element in Zeile:',zeile,'und Spalte:',spalte,'ist',mat[zeile,spalte]))\n", 328 | " }\n", 329 | "}" 330 | ] 331 | }, 332 | { 333 | "cell_type": "markdown", 334 | "metadata": {}, 335 | "source": [ 336 | "Toll! Soweit zu den for-Schleifen. Wir werden unser Wissen später noch überprüfen." 337 | ] 338 | } 339 | ], 340 | "metadata": { 341 | "kernelspec": { 342 | "display_name": "Python 3", 343 | "language": "python", 344 | "name": "python3" 345 | }, 346 | "language_info": { 347 | "codemirror_mode": { 348 | "name": "ipython", 349 | "version": 3 350 | }, 351 | "file_extension": ".py", 352 | "mimetype": "text/x-python", 353 | "name": "python", 354 | "nbconvert_exporter": "python", 355 | "pygments_lexer": "ipython3", 356 | "version": "3.6.0" 357 | } 358 | }, 359 | "nbformat": 4, 360 | "nbformat_minor": 1 361 | } 362 | -------------------------------------------------------------------------------- /4-Fortgeschrittene Programmierung mit R/3-Mathe mit R.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Eingebaute R Features - Mathematik\n", 8 | "\n", 9 | "Wir haben uns bereits einige eingebaute mathematische Funktionen und Features in R angeschaut. Lasst uns trotzdem noch einmal einen genauer Blick auf einige davon werden:\n", 10 | "\n", 11 | "* abs(): Berechnet den Betrag (absoluten Wert)\n", 12 | "* sum(): Summiert alle Werte des Inputs\n", 13 | "* mean(): Berechnet das arithmetische Mittel\n", 14 | "* round(): Rundet Werte\n", 15 | "\n", 16 | "Hier ein paar kurze Beispiele zu allen davon:" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 1, 22 | "metadata": { 23 | "collapsed": true 24 | }, 25 | "outputs": [], 26 | "source": [ 27 | "v <- c(-1,0,1,2,3,4,5)" 28 | ] 29 | }, 30 | { 31 | "cell_type": "code", 32 | "execution_count": 2, 33 | "metadata": { 34 | "collapsed": false 35 | }, 36 | "outputs": [ 37 | { 38 | "data": { 39 | "text/html": [ 40 | "2" 41 | ], 42 | "text/latex": [ 43 | "2" 44 | ], 45 | "text/markdown": [ 46 | "2" 47 | ], 48 | "text/plain": [ 49 | "[1] 2" 50 | ] 51 | }, 52 | "metadata": {}, 53 | "output_type": "display_data" 54 | } 55 | ], 56 | "source": [ 57 | "abs(-2)" 58 | ] 59 | }, 60 | { 61 | "cell_type": "code", 62 | "execution_count": 3, 63 | "metadata": { 64 | "collapsed": false 65 | }, 66 | "outputs": [ 67 | { 68 | "data": { 69 | "text/html": [ 70 | "
    \n", 71 | "\t
  1. 1
    2. \n", 72 | "\t
  2. 0
    3. \n", 73 | "\t
  3. 1
    4. \n", 74 | "\t
  4. 2
    5. \n", 75 | "\t
  5. 3
    6. \n", 76 | "\t
  6. 4
    7. \n", 77 | "\t
  7. 5
    8. \n", 78 | "
\n" 79 | ], 80 | "text/latex": [ 81 | "\\begin{enumerate*}\n", 82 | "\\item 1\n", 83 | "\\item 0\n", 84 | "\\item 1\n", 85 | "\\item 2\n", 86 | "\\item 3\n", 87 | "\\item 4\n", 88 | "\\item 5\n", 89 | "\\end{enumerate*}\n" 90 | ], 91 | "text/markdown": [ 92 | "1. 1\n", 93 | "2. 0\n", 94 | "3. 1\n", 95 | "4. 2\n", 96 | "5. 3\n", 97 | "6. 4\n", 98 | "7. 5\n", 99 | "\n", 100 | "\n" 101 | ], 102 | "text/plain": [ 103 | "[1] 1 0 1 2 3 4 5" 104 | ] 105 | }, 106 | "metadata": {}, 107 | "output_type": "display_data" 108 | } 109 | ], 110 | "source": [ 111 | "abs(v)" 112 | ] 113 | }, 114 | { 115 | "cell_type": "code", 116 | "execution_count": 4, 117 | "metadata": { 118 | "collapsed": false 119 | }, 120 | "outputs": [ 121 | { 122 | "data": { 123 | "text/html": [ 124 | "14" 125 | ], 126 | "text/latex": [ 127 | "14" 128 | ], 129 | "text/markdown": [ 130 | "14" 131 | ], 132 | "text/plain": [ 133 | "[1] 14" 134 | ] 135 | }, 136 | "metadata": {}, 137 | "output_type": "display_data" 138 | } 139 | ], 140 | "source": [ 141 | "sum(v)" 142 | ] 143 | }, 144 | { 145 | "cell_type": "code", 146 | "execution_count": 5, 147 | "metadata": { 148 | "collapsed": false 149 | }, 150 | "outputs": [ 151 | { 152 | "data": { 153 | "text/html": [ 154 | "2" 155 | ], 156 | "text/latex": [ 157 | "2" 158 | ], 159 | "text/markdown": [ 160 | "2" 161 | ], 162 | "text/plain": [ 163 | "[1] 2" 164 | ] 165 | }, 166 | "metadata": {}, 167 | "output_type": "display_data" 168 | } 169 | ], 170 | "source": [ 171 | "mean(v)" 172 | ] 173 | }, 174 | { 175 | "cell_type": "code", 176 | "execution_count": 6, 177 | "metadata": { 178 | "collapsed": false 179 | }, 180 | "outputs": [ 181 | { 182 | "data": { 183 | "text/html": [ 184 | "23" 185 | ], 186 | "text/latex": [ 187 | "23" 188 | ], 189 | "text/markdown": [ 190 | "23" 191 | ], 192 | "text/plain": [ 193 | "[1] 23" 194 | ] 195 | }, 196 | "metadata": {}, 197 | "output_type": "display_data" 198 | } 199 | ], 200 | "source": [ 201 | "round(23.1231)" 202 | ] 203 | }, 204 | { 205 | "cell_type": "code", 206 | "execution_count": 7, 207 | "metadata": { 208 | "collapsed": false 209 | }, 210 | "outputs": [ 211 | { 212 | "data": { 213 | "text/html": [ 214 | "23.12" 215 | ], 216 | "text/latex": [ 217 | "23.12" 218 | ], 219 | "text/markdown": [ 220 | "23.12" 221 | ], 222 | "text/plain": [ 223 | "[1] 23.12" 224 | ] 225 | }, 226 | "metadata": {}, 227 | "output_type": "display_data" 228 | } 229 | ], 230 | "source": [ 231 | "round(23.1231234,2)" 232 | ] 233 | }, 234 | { 235 | "cell_type": "markdown", 236 | "metadata": {}, 237 | "source": [ 238 | "Eine Übersicht weiterer mathematischer Funktionen seht ihr hier:\n", 239 | "\n", 240 | "

Numerische Funktionen

\n", 241 | "\t\t\t\t

\n", 242 | "\t\t\t\t\n", 243 | " \n", 244 | " \n", 245 | " \n", 246 | " \n", 247 | " \n", 248 | " \n", 249 | " \n", 250 | " \n", 251 | " \n", 252 | " \n", 253 | " \n", 254 | " \n", 255 | " \n", 256 | " \n", 257 | " \n", 258 | " \n", 259 | " \n", 260 | " \n", 261 | " \n", 262 | " \n", 263 | " \n", 264 | " \n", 265 | " \n", 266 | " \n", 267 | " \n", 268 | " \n", 269 | " \n", 270 | " \n", 271 | " \n", 272 | " \n", 273 | " \n", 274 | " \n", 275 | " \n", 276 | " \n", 277 | " \n", 278 | " \n", 279 | " \n", 280 | " \n", 281 | " \n", 282 | " \n", 283 | " \n", 284 | " \n", 285 | " \n", 286 | " \n", 287 | " \n", 288 | " \n", 289 | " \n", 290 | " \n", 291 | "
FunktionBeschreibung
abs(x)absoluter Wert
sqrt(x)Quadratwurzel
ceiling(x)ceiling(3.475) ist 4
floor(x)floor(3.475) ist 3
trunc(x)trunc(5.99) ist 5
round(x, digits=n) round(3.475, digits=2) ist 3.48
signif(x, digits=n) signif(3.475, digits=2) ist 3.5
cos(x), sin(x), tan(x) also acos(x), cosh(x), acosh(x), etc.
log(x)natürliocher Logarithmus
log10(x)Logarithmus
exp(x)e^x
\n" 292 | ] 293 | }, 294 | { 295 | "cell_type": "markdown", 296 | "metadata": {}, 297 | "source": [ 298 | "Außerdem könnt ihr in die Dokumentation von R schauen, um einen detaillierteren Überblick zu gewinnen. Einige weitere Funktionen werden wir im Verlauf des Kurses noch kennenlernen." 299 | ] 300 | } 301 | ], 302 | "metadata": { 303 | "kernelspec": { 304 | "display_name": "Python 3", 305 | "language": "python", 306 | "name": "python3" 307 | }, 308 | "language_info": { 309 | "codemirror_mode": { 310 | "name": "ipython", 311 | "version": 3 312 | }, 313 | "file_extension": ".py", 314 | "mimetype": "text/x-python", 315 | "name": "python", 316 | "nbconvert_exporter": "python", 317 | "pygments_lexer": "ipython3", 318 | "version": "3.6.0" 319 | } 320 | }, 321 | "nbformat": 4, 322 | "nbformat_minor": 1 323 | } 324 | -------------------------------------------------------------------------------- /4-Fortgeschrittene Programmierung mit R/4-Regular Expressions.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Regular Expressions\n", 8 | "\n", 9 | "*Regular expressions* ist ein allgemeiner Begriff dafür, typischerweise in Strings oder Vektoren von Strings, nach Mustern zu suchen.\n", 10 | "\n", 11 | "An diesem Punkt des Kurses möchten wir uns nun 2 nützliche Funktionen für Regular Expressions und Mustersuche lernen. Später im Kurs werden wir das Konzept vertiefen.\n", 12 | "\n", 13 | "\n", 14 | "* grepl(), ergibt einen logischen Wert, der angibt, ob das Muster gefunden wurde\n", 15 | "\n", 16 | "* grep(), ergibt einen Vektor der passenden Indizes der gesuchten Muster\n", 17 | "\n", 18 | "Für beide dieser Funktionen übergeben wir ein Muster und das Objekt, das wir danach durchsuchen möchten. Schauen wir uns einige Beispiele an:" 19 | ] 20 | }, 21 | { 22 | "cell_type": "code", 23 | "execution_count": 1, 24 | "metadata": { 25 | "collapsed": true 26 | }, 27 | "outputs": [], 28 | "source": [ 29 | "text <- \"Hallo, weißt du schon für wen du wählen wirst?\"" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": 2, 35 | "metadata": { 36 | "collapsed": false 37 | }, 38 | "outputs": [ 39 | { 40 | "data": { 41 | "text/html": [ 42 | "TRUE" 43 | ], 44 | "text/latex": [ 45 | "TRUE" 46 | ], 47 | "text/markdown": [ 48 | "TRUE" 49 | ], 50 | "text/plain": [ 51 | "[1] TRUE" 52 | ] 53 | }, 54 | "metadata": {}, 55 | "output_type": "display_data" 56 | } 57 | ], 58 | "source": [ 59 | "grepl('wählen',text)" 60 | ] 61 | }, 62 | { 63 | "cell_type": "code", 64 | "execution_count": 3, 65 | "metadata": { 66 | "collapsed": false 67 | }, 68 | "outputs": [ 69 | { 70 | "data": { 71 | "text/html": [ 72 | "TRUE" 73 | ], 74 | "text/latex": [ 75 | "TRUE" 76 | ], 77 | "text/markdown": [ 78 | "TRUE" 79 | ], 80 | "text/plain": [ 81 | "[1] TRUE" 82 | ] 83 | }, 84 | "metadata": {}, 85 | "output_type": "display_data" 86 | } 87 | ], 88 | "source": [ 89 | "grepl('Hallo',text)" 90 | ] 91 | }, 92 | { 93 | "cell_type": "code", 94 | "execution_count": 5, 95 | "metadata": { 96 | "collapsed": false 97 | }, 98 | "outputs": [ 99 | { 100 | "data": { 101 | "text/html": [ 102 | "FALSE" 103 | ], 104 | "text/latex": [ 105 | "FALSE" 106 | ], 107 | "text/markdown": [ 108 | "FALSE" 109 | ], 110 | "text/plain": [ 111 | "[1] FALSE" 112 | ] 113 | }, 114 | "metadata": {}, 115 | "output_type": "display_data" 116 | } 117 | ], 118 | "source": [ 119 | "grepl('Sam',text)" 120 | ] 121 | }, 122 | { 123 | "cell_type": "code", 124 | "execution_count": 6, 125 | "metadata": { 126 | "collapsed": true 127 | }, 128 | "outputs": [], 129 | "source": [ 130 | "v <- c('a','b','c','d')" 131 | ] 132 | }, 133 | { 134 | "cell_type": "code", 135 | "execution_count": 7, 136 | "metadata": { 137 | "collapsed": false 138 | }, 139 | "outputs": [ 140 | { 141 | "data": { 142 | "text/html": [ 143 | "1" 144 | ], 145 | "text/latex": [ 146 | "1" 147 | ], 148 | "text/markdown": [ 149 | "1" 150 | ], 151 | "text/plain": [ 152 | "[1] 1" 153 | ] 154 | }, 155 | "metadata": {}, 156 | "output_type": "display_data" 157 | } 158 | ], 159 | "source": [ 160 | "grep('a',v)" 161 | ] 162 | }, 163 | { 164 | "cell_type": "code", 165 | "execution_count": 8, 166 | "metadata": { 167 | "collapsed": false 168 | }, 169 | "outputs": [ 170 | { 171 | "data": { 172 | "text/html": [ 173 | "3" 174 | ], 175 | "text/latex": [ 176 | "3" 177 | ], 178 | "text/markdown": [ 179 | "3" 180 | ], 181 | "text/plain": [ 182 | "[1] 3" 183 | ] 184 | }, 185 | "metadata": {}, 186 | "output_type": "display_data" 187 | } 188 | ], 189 | "source": [ 190 | "grep('c',v)" 191 | ] 192 | }, 193 | { 194 | "cell_type": "markdown", 195 | "metadata": {}, 196 | "source": [ 197 | "Wir werden mehr über Regular Expressions und passende Funktionen lernen, sobald wir sie in unseren Übungen oder Projekten benötigen. In der Zwischenzeit kann dir dieser [Link](http://www.regular-expressions.info/rlanguage.html) mehr Infos bieten." 198 | ] 199 | } 200 | ], 201 | "metadata": { 202 | "kernelspec": { 203 | "display_name": "Python 3", 204 | "language": "python", 205 | "name": "python3" 206 | }, 207 | "language_info": { 208 | "codemirror_mode": { 209 | "name": "ipython", 210 | "version": 3 211 | }, 212 | "file_extension": ".py", 213 | "mimetype": "text/x-python", 214 | "name": "python", 215 | "nbconvert_exporter": "python", 216 | "pygments_lexer": "ipython3", 217 | "version": "3.6.0" 218 | } 219 | }, 220 | "nbformat": 4, 221 | "nbformat_minor": 1 222 | } 223 | -------------------------------------------------------------------------------- /4-Fortgeschrittene Programmierung mit R/5-Zeiten und Daten.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Zeitstempel\n", 8 | "\n", 9 | "R bietet uns eine Vielzahl an Werkzeugen, um mit Zeitstempel (en. timestamp) Informationen zu arbeiten. Schauen wir uns als erstes das `Date` Objekt an:\n", 10 | "\n", 11 | "## Date\n", 12 | "\n", 13 | "Du kannst die `as.Date()` Funktion nutzen, um Zeichen-Strings in ein Datums-Objekt zu konvertieren. Dieses Format erlaub es, mehr Informationen zu speicher. Der String muss dabei in einem Standard-Zeitformat vorliegen. \n", 14 | "\n", 15 | "Um das heutige Datum zu erhalten könne wir das System (`Sys.`) danach fragen:" 16 | ] 17 | }, 18 | { 19 | "cell_type": "code", 20 | "execution_count": 1, 21 | "metadata": {}, 22 | "outputs": [ 23 | { 24 | "data": { 25 | "text/html": [ 26 | "" 27 | ], 28 | "text/latex": [ 29 | "2017-10-31" 30 | ], 31 | "text/markdown": [ 32 | "2017-10-31" 33 | ], 34 | "text/plain": [ 35 | "[1] \"2017-10-31\"" 36 | ] 37 | }, 38 | "metadata": {}, 39 | "output_type": "display_data" 40 | } 41 | ], 42 | "source": [ 43 | "Sys.Date()" 44 | ] 45 | }, 46 | { 47 | "cell_type": "code", 48 | "execution_count": 2, 49 | "metadata": {}, 50 | "outputs": [ 51 | { 52 | "data": { 53 | "text/html": [ 54 | "" 55 | ], 56 | "text/latex": [ 57 | "2017-10-31" 58 | ], 59 | "text/markdown": [ 60 | "2017-10-31" 61 | ], 62 | "text/plain": [ 63 | "[1] \"2017-10-31\"" 64 | ] 65 | }, 66 | "metadata": {}, 67 | "output_type": "display_data" 68 | } 69 | ], 70 | "source": [ 71 | "# Als Variable festlegen\n", 72 | "heute <- Sys.Date()\n", 73 | "heute" 74 | ] 75 | }, 76 | { 77 | "cell_type": "markdown", 78 | "metadata": {}, 79 | "source": [ 80 | "Wir können außerdem Zeichen-Strings in ein Datum konvertieren, indem wir `as.Date()` verwenden. Dabei können wir einerseits gleich das richtige Format angeben oder andererseits mit % Zeichen das Format selbst definieren:\n", 81 | "\n", 82 | "\n", 83 | "\n", 84 | "\n", 85 | "\n", 86 | "\n", 87 | "\n", 88 | "\n", 89 | "\n", 90 | "
CodeWert
%dTag des Monats (Dezimalzahl)
%mMonat (Dezimalzahl)
%bMonat (abgekürzt)
%BMonat (vollständiger Name)
%yJahr (2 Stellen)
%YJahr (4 Stellen)
\n", 91 | "\n", 92 | "\n", 93 | "*Hinweis: Achtet dabei darauf, dass bspw. der abgekürzte Monat sich auf die englischen Namen bezieht!*\n", 94 | "\n", 95 | "Schauen wir uns nun einige Beispiele an, wie wir `as.Date` und das passende Format einsetzen können:" 96 | ] 97 | }, 98 | { 99 | "cell_type": "code", 100 | "execution_count": 3, 101 | "metadata": {}, 102 | "outputs": [ 103 | { 104 | "data": { 105 | "text/html": [ 106 | "" 107 | ], 108 | "text/latex": [ 109 | "1990-11-03" 110 | ], 111 | "text/markdown": [ 112 | "1990-11-03" 113 | ], 114 | "text/plain": [ 115 | "[1] \"1990-11-03\"" 116 | ] 117 | }, 118 | "metadata": {}, 119 | "output_type": "display_data" 120 | } 121 | ], 122 | "source": [ 123 | "# YYYY-MM-DD\n", 124 | "as.Date('1990-11-03')" 125 | ] 126 | }, 127 | { 128 | "cell_type": "code", 129 | "execution_count": 4, 130 | "metadata": {}, 131 | "outputs": [ 132 | { 133 | "data": { 134 | "text/html": [ 135 | "" 136 | ], 137 | "text/latex": [ 138 | "1990-11-03" 139 | ], 140 | "text/markdown": [ 141 | "1990-11-03" 142 | ], 143 | "text/plain": [ 144 | "[1] \"1990-11-03\"" 145 | ] 146 | }, 147 | "metadata": {}, 148 | "output_type": "display_data" 149 | } 150 | ], 151 | "source": [ 152 | "# Formatierung nutzen\n", 153 | "as.Date(\"Nov-03-90\",format=\"%b-%d-%y\")" 154 | ] 155 | }, 156 | { 157 | "cell_type": "code", 158 | "execution_count": 5, 159 | "metadata": {}, 160 | "outputs": [ 161 | { 162 | "data": { 163 | "text/html": [ 164 | "" 165 | ], 166 | "text/latex": [ 167 | "1990-11-03" 168 | ], 169 | "text/markdown": [ 170 | "1990-11-03" 171 | ], 172 | "text/plain": [ 173 | "[1] \"1990-11-03\"" 174 | ] 175 | }, 176 | "metadata": {}, 177 | "output_type": "display_data" 178 | } 179 | ], 180 | "source": [ 181 | "# Formatierung nutzen\n", 182 | "as.Date(\"November-03-1990\",format=\"%B-%d-%Y\")" 183 | ] 184 | }, 185 | { 186 | "cell_type": "markdown", 187 | "metadata": {}, 188 | "source": [ 189 | "Durch die Kombination von `as.Date()` und dem `format` Parameter können wir im Grunde genommen jeden String konvertieren, der Datumsinformationen enthält. Das ist extrem nützlich, um Zeitreihen zu analysieren.\n", 190 | "\n", 191 | "## Zeit\n", 192 | "\n", 193 | "Genau wie mit Daten können wir auch Zeitinformationen aus Strings erhalten. R nutzt den `POSIXct` Objekttyp, um Zeitinformationen zu speichern. \n", 194 | "\n", 195 | "*Es geht etwas über den Rahmen des Kurses hinaus, aber nur als kleine Info: POSIX stellt eine portable Betriebssystem-Oberfläche dar, die insbesondere für UNIX Systeme eingesetzt wird.*\n", 196 | "\n", 197 | "Was wir für diesen Kurs wissen müssen ist, dass wir `as.POSIXct()` nutzen können, um einen String in ein POSIXct Objekt zu konvertieren. Die Formatregelung lesen wir am besten in der Dokumentation der `strptime()` Funktion nach:" 198 | ] 199 | }, 200 | { 201 | "cell_type": "code", 202 | "execution_count": 7, 203 | "metadata": { 204 | "collapsed": true 205 | }, 206 | "outputs": [], 207 | "source": [ 208 | "help(strptime)" 209 | ] 210 | }, 211 | { 212 | "cell_type": "code", 213 | "execution_count": 8, 214 | "metadata": {}, 215 | "outputs": [ 216 | { 217 | "data": { 218 | "text/plain": [ 219 | "[1] \"2017-10-31 11:02:03 CET\"" 220 | ] 221 | }, 222 | "metadata": {}, 223 | "output_type": "display_data" 224 | } 225 | ], 226 | "source": [ 227 | "as.POSIXct(\"11:02:03\",format=\"%H:%M:%S\")" 228 | ] 229 | }, 230 | { 231 | "cell_type": "markdown", 232 | "metadata": {}, 233 | "source": [ 234 | "Achtet dabei darauf, wie das heutige Datum automatisch hinzugefügt wird, da wir es nicht selbst spezifiziert haben. Hätten wir die Information bereits, dann würden wir schreiben:" 235 | ] 236 | }, 237 | { 238 | "cell_type": "code", 239 | "execution_count": 9, 240 | "metadata": {}, 241 | "outputs": [ 242 | { 243 | "data": { 244 | "text/plain": [ 245 | "[1] \"1990-11-03 11:02:03 CET\"" 246 | ] 247 | }, 248 | "metadata": {}, 249 | "output_type": "display_data" 250 | } 251 | ], 252 | "source": [ 253 | "as.POSIXct(\"November-03-1990 11:02:03\",format=\"%B-%d-%Y %H:%M:%S\")" 254 | ] 255 | }, 256 | { 257 | "cell_type": "markdown", 258 | "metadata": {}, 259 | "source": [ 260 | "Meistens werden wir tatsächlich die `strptime()` Funktion anstatt POSIXct benutzen. Hier ist eine kurze Beschreibung der Unterschiede zwischen den Funktionen:\n", 261 | "\n", 262 | "Es gibt zwei interne Implementierungen von Datum/Zeit: POSIXct, welches die Sekunden seit Beginn der UNIX Epoche speichert, und POSIXlt, welches eine Liste an Tagen, Monaten, Jahren, Stunden, Minuten und Sekunden speichert.\n", 263 | "\n", 264 | "`strptime` ist eine Funktion, um Zeichenvektoren direkt ins POSIXlt Format zu konvertieren.\n", 265 | "\n", 266 | "`as.POSIXlt` konvertiert eine Vielzahl an Datentypen zu POSIXlt. Es versucht dabei intelligent zu erkennen, welche Formatierung angebracht ist.\n", 267 | "\n", 268 | "`as.POSIXct` konvertiert eine Vielzahl an Datentypen ins POSICct Format. Es versucht ebenso intelligent zu erknnnen, welche Umwandlung angebracht ist. Im Fall von Zeichen führt es zuerst strptime aus und konvertiert anschließend von POSIXlt zu POSIXct.\n", 269 | "\n", 270 | "Es ergibt daher Sinn, dass strptime schneller ist, da es nur Zeichen als Input verarbeitet, während die anderen Methoden zuerst zu erkennen versuchen, welche Umwandlung angebracht ist. Außerdem bietet es insofern etwas mehr Sicherheit, dass kein ungewollter Input übergeben werden kann.\n", 271 | "\n", 272 | "Schauen wir uns daher ein einfaches Beispiel für strptime an:" 273 | ] 274 | }, 275 | { 276 | "cell_type": "code", 277 | "execution_count": 10, 278 | "metadata": {}, 279 | "outputs": [ 280 | { 281 | "data": { 282 | "text/plain": [ 283 | "[1] \"2017-10-31 11:02:03 CET\"" 284 | ] 285 | }, 286 | "metadata": {}, 287 | "output_type": "display_data" 288 | } 289 | ], 290 | "source": [ 291 | "strptime(\"11:02:03\",format=\"%H:%M:%S\")" 292 | ] 293 | }, 294 | { 295 | "cell_type": "markdown", 296 | "metadata": {}, 297 | "source": [ 298 | "Toll! Für den Großtei des Kurses werden wir direkt strptime() verwenden. Sollten dich die verschiedenen Methoden dieser Lektion verwirrt haben, merke dir bitte folgendes:\n", 299 | "\n", 300 | "* Wie man strptime() nutzt und formatiert\n", 301 | "* Wie du help(strptime) verwenden kannst, um mehr über die Formatierung zu erfahren\n", 302 | "\n", 303 | "Soviel zu Zeitstempeln und Daten. Wir werden uns wieder mit dem Thema befassen, wenn wir Datensätze betrachten, die Zeitinformationen beinhalten." 304 | ] 305 | } 306 | ], 307 | "metadata": { 308 | "kernelspec": { 309 | "display_name": "Python 3", 310 | "language": "python", 311 | "name": "python3" 312 | }, 313 | "language_info": { 314 | "codemirror_mode": { 315 | "name": "ipython", 316 | "version": 3 317 | }, 318 | "file_extension": ".py", 319 | "mimetype": "text/x-python", 320 | "name": "python", 321 | "nbconvert_exporter": "python", 322 | "pygments_lexer": "ipython3", 323 | "version": "3.6.4" 324 | } 325 | }, 326 | "nbformat": 4, 327 | "nbformat_minor": 1 328 | } 329 | -------------------------------------------------------------------------------- /6-Daten Visualisierung mit R/Economist1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/datamics/R-DataScience-MachineLearning/f36bd24e6155a5a05ad96d7d00d14c52a620f4a0/6-Daten Visualisierung mit R/Economist1.png -------------------------------------------------------------------------------- /6-Daten Visualisierung mit R/Economist_Assignment_Data.csv: -------------------------------------------------------------------------------- 1 | "","Country","HDI.Rank","HDI","CPI","Region" 2 | "1","Afghanistan",172,0.398,1.5,"Asia Pacific" 3 | "2","Albania",70,0.739,3.1,"East EU Cemt Asia" 4 | "3","Algeria",96,0.698,2.9,"MENA" 5 | "4","Angola",148,0.486,2,"SSA" 6 | "5","Argentina",45,0.797,3,"Americas" 7 | "6","Armenia",86,0.716,2.6,"East EU Cemt Asia" 8 | "7","Australia",2,0.929,8.8,"Asia Pacific" 9 | "8","Austria",19,0.885,7.8,"EU W. Europe" 10 | "9","Azerbaijan",91,0.7,2.4,"East EU Cemt Asia" 11 | "10","Bahamas",53,0.771,7.3,"Americas" 12 | "11","Bahrain",42,0.806,5.1,"MENA" 13 | "12","Bangladesh",146,0.5,2.7,"Asia Pacific" 14 | "13","Barbados",47,0.793,7.8,"Americas" 15 | "14","Belarus",65,0.756,2.4,"East EU Cemt Asia" 16 | "15","Belgium",18,0.886,7.5,"EU W. Europe" 17 | "16","Benin",167,0.427,3,"SSA" 18 | "17","Bhutan",141,0.522,5.7,"Asia Pacific" 19 | "18","Bolivia",108,0.663,2.8,"Americas" 20 | "19","Bosnia and Herzegovina",74,0.733,3.2,"East EU Cemt Asia" 21 | "20","Botswana",118,0.633,6.1,"SSA" 22 | "21","Brazil",84,0.718,3.8,"Americas" 23 | "22","Britain",28,0.863,7.8,"EU W. Europe" 24 | "23","Bulgaria",55,0.771,3.3,"EU W. Europe" 25 | "24","Burkina Faso",181,0.331,3,"SSA" 26 | "25","Burundi",185,0.316,1.9,"SSA" 27 | "26","Cambodia",139,0.523,2.1,"Asia Pacific" 28 | "27","Cameroon",150,0.482,2.5,"SSA" 29 | "28","Canada",6,0.908,8.7,"Americas" 30 | "29","Cape Verde",133,0.568,5.5,"SSA" 31 | "30","Central African Republic",179,0.343,2.2,"SSA" 32 | "31","Chad",183,0.328,2,"SSA" 33 | "32","Chile",44,0.805,7.2,"Americas" 34 | "33","China",101,0.687,3.6,"Asia Pacific" 35 | "34","Colombia",87,0.71,3.4,"Americas" 36 | "35","Comoros",163,0.433,2.4,"SSA" 37 | "36","Congo",187,0.286,2,"SSA" 38 | "37","Congo Republic",137,0.533,2.2,"SSA" 39 | "38","Costa Rica",69,0.744,4.8,"Americas" 40 | "39","Côte d'Ivoire",170,0.4,2.2,"SSA" 41 | "40","Croatia",46,0.796,4,"East EU Cemt Asia" 42 | "41","Cuba",51,0.776,4.2,"Americas" 43 | "42","Cyprus",31,0.84,6.3,"EU W. Europe" 44 | "43","Czech Republic",27,0.865,4.4,"EU W. Europe" 45 | "44","Denmark",16,0.895,9.4,"EU W. Europe" 46 | "45","Djibouti",165,0.43,3,"SSA" 47 | "46","Dominica",81,0.724,5.2,"Americas" 48 | "47","Dominican Republic",98,0.689,2.6,"Americas" 49 | "48","Ecuador",83,0.72,2.7,"Americas" 50 | "49","Egypt",113,0.644,2.9,"MENA" 51 | "50","El Salvador",105,0.674,3.4,"Americas" 52 | "51","Equatorial Guinea",136,0.537,1.9,"SSA" 53 | "52","Eritrea",177,0.349,2.5,"SSA" 54 | "53","Estonia",34,0.835,6.4,"EU W. Europe" 55 | "54","Ethiopia",174,0.363,2.7,"SSA" 56 | "55","Finland",22,0.882,9.4,"EU W. Europe" 57 | "56","France",20,0.884,7,"EU W. Europe" 58 | "57","Gabon",106,0.674,3,"SSA" 59 | "58","Gambia",168,0.42,3.5,"SSA" 60 | "59","Georgia",75,0.733,4.1,"East EU Cemt Asia" 61 | "60","Germany",9,0.905,8,"EU W. Europe" 62 | "61","Ghana",135,0.541,3.9,"SSA" 63 | "62","Greece",29,0.861,3.4,"EU W. Europe" 64 | "63","Guatemala",131,0.574,2.7,"Americas" 65 | "64","Guinea",178,0.344,2.1,"SSA" 66 | "65","Guinea-Bissau",176,0.353,2.2,"SSA" 67 | "66","Guyana",117,0.633,2.5,"Americas" 68 | "67","Haiti",158,0.454,1.8,"Americas" 69 | "68","Honduras",121,0.625,2.6,"Americas" 70 | "69","Hong Kong",13,0.898,8.4,"Asia Pacific" 71 | "70","Hungary",38,0.816,4.6,"EU W. Europe" 72 | "71","Iceland",14,0.898,8.3,"EU W. Europe" 73 | "72","India",134,0.547,3.1,"Asia Pacific" 74 | "73","Indonesia",124,0.617,3,"Asia Pacific" 75 | "74","Iran",88,0.707,2.7,"MENA" 76 | "75","Iraq",132,0.573,1.8,"MENA" 77 | "76","Ireland",7,0.908,7.5,"EU W. Europe" 78 | "77","Israel",17,0.888,5.8,"MENA" 79 | "78","Italy",24,0.874,3.9,"EU W. Europe" 80 | "79","Jamaica",79,0.727,3.3,"Americas" 81 | "80","Japan",12,0.901,8,"Asia Pacific" 82 | "81","Jordan",95,0.698,4.5,"MENA" 83 | "82","Kazakhstan",68,0.745,2.7,"East EU Cemt Asia" 84 | "83","Kenya",143,0.509,2.2,"SSA" 85 | "84","Kiribati",122,0.624,3.1,"Asia Pacific" 86 | "85","Korea (South)",15,0.897,5.4,"Asia Pacific" 87 | "86","Kuwait",63,0.76,4.6,"MENA" 88 | "87","Kyrgyzstan",126,0.615,2.1,"East EU Cemt Asia" 89 | "88","Laos",138,0.524,2.2,"Asia Pacific" 90 | "89","Latvia",43,0.805,4.2,"EU W. Europe" 91 | "90","Lebanon",71,0.739,2.5,"MENA" 92 | "91","Lesotho",160,0.45,3.5,"SSA" 93 | "92","Liberia",182,0.329,3.2,"SSA" 94 | "93","Libya",64,0.76,2,"MENA" 95 | "94","Lithuania",40,0.81,4.8,"EU W. Europe" 96 | "95","Luxembourg",25,0.867,8.5,"EU W. Europe" 97 | "96","Madagascar",151,0.48,3,"SSA" 98 | "97","Malawi",171,0.4,3,"SSA" 99 | "98","Malaysia",61,0.761,4.3,"Asia Pacific" 100 | "99","Maldives",109,0.661,2.5,"Asia Pacific" 101 | "100","Mali",175,0.359,2.8,"SSA" 102 | "101","Malta",36,0.832,5.6,"EU W. Europe" 103 | "102","Mauritania",159,0.453,2.4,"SSA" 104 | "103","Mauritius",77,0.728,5.1,"SSA" 105 | "104","Mexico",57,0.77,3,"Americas" 106 | "105","Moldova",111,0.649,2.9,"East EU Cemt Asia" 107 | "106","Mongolia",110,0.653,2.7,"Asia Pacific" 108 | "107","Montenegro",54,0.771,4,"East EU Cemt Asia" 109 | "108","Morocco",130,0.582,3.4,"MENA" 110 | "109","Mozambique",184,0.322,2.7,"SSA" 111 | "110","Myanmar",149,0.483,1.5,"Asia Pacific" 112 | "111","Namibia",120,0.625,4.4,"SSA" 113 | "112","Nepal",157,0.458,2.2,"Asia Pacific" 114 | "113","Netherlands",3,0.91,8.9,"EU W. Europe" 115 | "114","New Zealand",5,0.908,9.5,"Asia Pacific" 116 | "115","Nicaragua",129,0.589,2.5,"Americas" 117 | "116","Niger",186,0.295,2.5,"SSA" 118 | "117","Nigeria",156,0.459,2.4,"SSA" 119 | "118","Norway",1,0.943,9,"EU W. Europe" 120 | "119","Oman",89,0.705,4.8,"MENA" 121 | "120","Pakistan",145,0.504,2.5,"Asia Pacific" 122 | "121","Panama",58,0.768,3.3,"Americas" 123 | "122","Papua New Guinea",153,0.466,2.2,"Asia Pacific" 124 | "123","Paraguay",107,0.665,2.2,"Americas" 125 | "124","Peru",80,0.725,3.4,"Americas" 126 | "125","Philippines",112,0.644,2.6,"Asia Pacific" 127 | "126","Poland",39,0.813,5.5,"EU W. Europe" 128 | "127","Portugal",41,0.809,6.1,"EU W. Europe" 129 | "128","Qatar",37,0.831,7.2,"MENA" 130 | "129","Romania",50,0.781,3.6,"EU W. Europe" 131 | "130","Russia",66,0.755,2.4,"East EU Cemt Asia" 132 | "131","Rwanda",166,0.429,5,"SSA" 133 | "132","Saint Lucia",82,0.723,7,"Americas" 134 | "133","Saint Vincent and the Grenadines",85,0.717,5.8,"Americas" 135 | "134","Samoa",99,0.688,3.9,"Asia Pacific" 136 | "135","Saudi Arabia",56,0.77,4.4,"MENA" 137 | "136","Senegal",155,0.459,2.9,"SSA" 138 | "137","Serbia",59,0.766,3.3,"East EU Cemt Asia" 139 | "138","Seychelles",52,0.773,4.8,"SSA" 140 | "139","Sierra Leone",180,0.336,2.5,"SSA" 141 | "140","Singapore",26,0.866,9.2,"Asia Pacific" 142 | "141","Slovakia",35,0.834,4,"EU W. Europe" 143 | "142","Slovenia",21,0.884,5.9,"EU W. Europe" 144 | "143","Solomon Islands",142,0.51,2.7,"Asia Pacific" 145 | "144","South Africa",123,0.619,4.1,"SSA" 146 | "145","Spain",23,0.878,6.2,"EU W. Europe" 147 | "146","Sri Lanka",97,0.691,3.3,"Asia Pacific" 148 | "147","Sudan",169,0.408,1.6,"SSA" 149 | "148","Suriname",104,0.68,3,"Americas" 150 | "149","Swaziland",140,0.522,3.1,"SSA" 151 | "150","Sweden",10,0.904,9.3,"EU W. Europe" 152 | "151","Switzerland",11,0.903,8.8,"EU W. Europe" 153 | "152","Syria",119,0.632,2.6,"MENA" 154 | "153","Tajikistan",127,0.607,2.3,"East EU Cemt Asia" 155 | "154","Tanzania",152,0.466,3,"SSA" 156 | "155","Thailand",103,0.682,3.4,"Asia Pacific" 157 | "156","Timor-Leste",147,0.495,2.4,"Asia Pacific" 158 | "157","Togo",162,0.435,2.4,"SSA" 159 | "158","Tonga",90,0.704,3.1,"Asia Pacific" 160 | "159","Trinidad and Tobago",62,0.76,3.2,"Americas" 161 | "160","Tunisia",94,0.698,3.8,"MENA" 162 | "161","Turkey",92,0.699,4.2,"East EU Cemt Asia" 163 | "162","Turkmenistan",102,0.686,1.6,"East EU Cemt Asia" 164 | "163","Uganda",161,0.446,2.4,"SSA" 165 | "164","Ukraine",76,0.729,2.3,"East EU Cemt Asia" 166 | "165","United Arab Emirates",30,0.846,6.8,"MENA" 167 | "166","United States",4,0.91,7.1,"Americas" 168 | "167","Uruguay",48,0.783,7,"Americas" 169 | "168","Uzbekistan",115,0.641,1.6,"East EU Cemt Asia" 170 | "169","Vanuatu",125,0.617,3.5,"Asia Pacific" 171 | "170","Venezuela",73,0.735,1.9,"Americas" 172 | "171","Yemen",154,0.462,2.1,"MENA" 173 | "172","Zambia",164,0.43,3.2,"SSA" 174 | "173","Zimbabwe",173,0.376,2.2,"SSA" -------------------------------------------------------------------------------- /6-Daten Visualisierung mit R/ggplot2-cheatsheet.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/datamics/R-DataScience-MachineLearning/f36bd24e6155a5a05ad96d7d00d14c52a620f4a0/6-Daten Visualisierung mit R/ggplot2-cheatsheet.pdf -------------------------------------------------------------------------------- /6-Daten Visualisierung mit R/grammar_layers.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/datamics/R-DataScience-MachineLearning/f36bd24e6155a5a05ad96d7d00d14c52a620f4a0/6-Daten Visualisierung mit R/grammar_layers.png -------------------------------------------------------------------------------- /7-Interaktive Daten Visualisierung mit R und plotly/1-Übersicht von Plotly und R.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Übersicht von Plotly und R\n", 8 | "\n", 9 | "Plotly ist ein R Paket, um interaktive web-basierte Grafiken durch Ploitly's JavaScript Library plotly.js zu erstellen. Die Plotly Library für R beinhaltet eine Funktion namens `ggplotly`, die es uns erlaub ggplot2 Figuren mit plotly.js zu konvertieren. Die neu erzeugten interaktiven Grafiken können in einem online Plotly-Account gespeichert werden oder lokal gerendered." 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": 1, 15 | "metadata": {}, 16 | "outputs": [ 17 | { 18 | "name": "stderr", 19 | "output_type": "stream", 20 | "text": [ 21 | "also installing the dependencies ‘httpuv’, ‘xtable’, ‘sourcetools’, ‘yaml’, ‘shiny’, ‘base64enc’, ‘htmltools’, ‘htmlwidgets’, ‘crosstalk’\n", 22 | "\n" 23 | ] 24 | }, 25 | { 26 | "name": "stdout", 27 | "output_type": "stream", 28 | "text": [ 29 | "\n", 30 | "The downloaded binary packages are in\n", 31 | "\t/var/folders/l_/ph09zg211515zffvzrp3bb680000gn/T//RtmppNSgfD/downloaded_packages\n" 32 | ] 33 | } 34 | ], 35 | "source": [ 36 | "install.packages('plotly')" 37 | ] 38 | }, 39 | { 40 | "cell_type": "markdown", 41 | "metadata": {}, 42 | "source": [ 43 | "___\n", 44 | "Plotly hat sein eigenen Grafik-Aufrug namens `plot_ly()` kann aber auch mit `ggplotly()` ggplot() Codes konvertieren und ausführen. Manchmal brauchen wir kleienre Anpassungen für unseren Code.\n", 45 | "___" 46 | ] 47 | }, 48 | { 49 | "cell_type": "markdown", 50 | "metadata": {}, 51 | "source": [ 52 | "Anschließend können wir folgendes aufrufen:" 53 | ] 54 | }, 55 | { 56 | "cell_type": "code", 57 | "execution_count": null, 58 | "metadata": { 59 | "collapsed": true 60 | }, 61 | "outputs": [], 62 | "source": [ 63 | "library(plotly)\n", 64 | "# pl <- # Unser ggplot2 Code hier\n", 65 | "print(ggplotly(pl))" 66 | ] 67 | }, 68 | { 69 | "cell_type": "markdown", 70 | "metadata": {}, 71 | "source": [ 72 | "So erhalten wir ein interaktives Diagramm, das wir in R Studio oder Shiny anzeigen können!" 73 | ] 74 | } 75 | ], 76 | "metadata": { 77 | "kernelspec": { 78 | "display_name": "Python 3", 79 | "language": "python", 80 | "name": "python3" 81 | }, 82 | "language_info": { 83 | "codemirror_mode": { 84 | "name": "ipython", 85 | "version": 3 86 | }, 87 | "file_extension": ".py", 88 | "mimetype": "text/x-python", 89 | "name": "python", 90 | "nbconvert_exporter": "python", 91 | "pygments_lexer": "ipython3", 92 | "version": "3.6.4" 93 | } 94 | }, 95 | "nbformat": 4, 96 | "nbformat_minor": 1 97 | } 98 | -------------------------------------------------------------------------------- /7-Interaktive Daten Visualisierung mit R und plotly/1-Übersicht von Plotly und R.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Übersicht von Plotly und R\n", 8 | "\n", 9 | "Plotly ist ein R Paket, um interaktive web-basierte Grafiken durch Ploitly's JavaScript Library plotly.js zu erstellen. Die Plotly Library für R beinhaltet eine Funktion namens `ggplotly`, die es uns erlaub ggplot2 Figuren mit plotly.js zu konvertieren. Die neu erzeugten interaktiven Grafiken können in einem online Plotly-Account gespeichert werden oder lokal gerendered." 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": 1, 15 | "metadata": {}, 16 | "outputs": [ 17 | { 18 | "name": "stderr", 19 | "output_type": "stream", 20 | "text": [ 21 | "also installing the dependencies ‘httpuv’, ‘xtable’, ‘sourcetools’, ‘yaml’, ‘shiny’, ‘base64enc’, ‘htmltools’, ‘htmlwidgets’, ‘crosstalk’\n", 22 | "\n" 23 | ] 24 | }, 25 | { 26 | "name": "stdout", 27 | "output_type": "stream", 28 | "text": [ 29 | "\n", 30 | "The downloaded binary packages are in\n", 31 | "\t/var/folders/l_/ph09zg211515zffvzrp3bb680000gn/T//RtmppNSgfD/downloaded_packages\n" 32 | ] 33 | } 34 | ], 35 | "source": [ 36 | "install.packages('plotly')" 37 | ] 38 | }, 39 | { 40 | "cell_type": "markdown", 41 | "metadata": {}, 42 | "source": [ 43 | "___\n", 44 | "Plotly hat sein eigenen Grafik-Aufrug namens `plot_ly()` kann aber auch mit `ggplotly()` ggplot() Codes konvertieren und ausführen. Manchmal brauchen wir kleienre Anpassungen für unseren Code.\n", 45 | "___" 46 | ] 47 | }, 48 | { 49 | "cell_type": "markdown", 50 | "metadata": {}, 51 | "source": [ 52 | "Anschließend können wir folgendes aufrufen:" 53 | ] 54 | }, 55 | { 56 | "cell_type": "code", 57 | "execution_count": null, 58 | "metadata": { 59 | "collapsed": true 60 | }, 61 | "outputs": [], 62 | "source": [ 63 | "library(plotly)\n", 64 | "# pl <- # Unser ggplot2 Code hier\n", 65 | "print(ggplotly(pl))" 66 | ] 67 | }, 68 | { 69 | "cell_type": "markdown", 70 | "metadata": {}, 71 | "source": [ 72 | "So erhalten wir ein interaktives Diagramm, das wir in R Studio oder Shiny anzeigen können!" 73 | ] 74 | } 75 | ], 76 | "metadata": { 77 | "kernelspec": { 78 | "display_name": "Python 3", 79 | "language": "python", 80 | "name": "python3" 81 | }, 82 | "language_info": { 83 | "codemirror_mode": { 84 | "name": "ipython", 85 | "version": 3 86 | }, 87 | "file_extension": ".py", 88 | "mimetype": "text/x-python", 89 | "name": "python", 90 | "nbconvert_exporter": "python", 91 | "pygments_lexer": "ipython3", 92 | "version": "3.6.4" 93 | } 94 | }, 95 | "nbformat": 4, 96 | "nbformat_minor": 1 97 | } 98 | -------------------------------------------------------------------------------- /8-Meilenstein Projekt/Moneyball.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/datamics/R-DataScience-MachineLearning/f36bd24e6155a5a05ad96d7d00d14c52a620f4a0/8-Meilenstein Projekt/Moneyball.jpg -------------------------------------------------------------------------------- /8-Meilenstein Projekt/moneyball_title.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/datamics/R-DataScience-MachineLearning/f36bd24e6155a5a05ad96d7d00d14c52a620f4a0/8-Meilenstein Projekt/moneyball_title.jpg -------------------------------------------------------------------------------- /8-Meilenstein Projekt/salary.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/datamics/R-DataScience-MachineLearning/f36bd24e6155a5a05ad96d7d00d14c52a620f4a0/8-Meilenstein Projekt/salary.png -------------------------------------------------------------------------------- /9-Machine Learning mit R/anscombe.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/datamics/R-DataScience-MachineLearning/f36bd24e6155a5a05ad96d7d00d14c52a620f4a0/9-Machine Learning mit R/anscombe.png -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # R-DataScience-MachineLearning --------------------------------------------------------------------------------