01_Python_Einführung.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inhalt\n",
    "\n",
    "* [1 Grundsätzliche Syntax](#t11)\n",
    "* [2 Variablen](#t2)\n",
    "* [3 Datentypen](#t3)\n",
    "    * [3.1 Datentypen verändern](#t31)\n",
    "* [4 Operatoren](#t4)\n",
    "    * [4.1 Relationale Operatoren](#t41)\n",
    "* [5 Funktionales Programmieren](#t5)\n",
    "    * [5.1 def](#t51)\n",
    "    * [5.1 lambda](#t52)\n",
    "* [6 Control Flow Statements](#t6)\n",
    "    * [6.1 Conditionals](#t61)\n",
    "        * [If](#t611)\n",
    "        * [Else-If](#t612)\n",
    "        * [If Else](#t613)\n",
    "    * [6.2 Schleifen](#t62)\n",
    "        * [For](#t621)\n",
    "        * [While](#t622)\n",
    "        * [Break](#t623)\n",
    "        * [Continue](#t624)\n",
    "* [7 Bibliotheken](#t7)\n",
    "    * [7.1 Mathematische Funktionen - math](#t71)\n",
    "    * [7.2 Differenzieren und Integrieren](#t72)\n",
    "        * [Analytisch - sympy](#t721)\n",
    "        * [Numerisches Inegrieren - scipy.integrate](#t722)\n",
    "* [8 Mit Datenmengen arbeiten](#t8)\n",
    "    * [8.1 List](#t81)\n",
    "    * [8.2 Tuple](#t82)\n",
    "    * [8.3 Set](#t83)\n",
    "    * [8.4 Dictionary](#t84)\n",
    "    * [8.5 Datenvisualisierung](#t85)\n",
    "    * [8.6 Panda](#t86)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Grundsätzliche Syntax <a class=\"anchor\" id=\"t1\"></a>\n",
    "Die Grundregeln für das Schreiben von einfachen Aussagen und Ausdrücken in Python sind\n",
    "* Am Anfang einer Anweisung dürfen keine **Leerzeichen oder Tabulator**-Zeichen stehen: Einrückungen spielen in Python eine besondere Rolle und können beim Kompilieren oder Ausführen von Code Probleme verursachen. Stellen Sie vorerst einfach sicher, dass alle Anweisungen am **Zeilenanfang** beginnen.\n",
    "* **Variablennamen** in Python können beliebig lang sein und aus Groß- und Kleinbuchstaben ( A-Z , a-z ), Ziffern ( 0-9 ) und dem <br> Unterstreichungszeichen ( _ ) bestehen. Eine zusätzliche Einschränkung besteht darin, dass ein Variablenname zwar Ziffern enthalten kann, das erste Zeichen eines Variablennamens jedoch keine Ziffer sein darf.\n",
    "* Das Zeichen **'#'** zeigt an, dass der Rest der Zeile ein **Kommentar** ist.\n",
    "* Python hat eine umfangreiche Hilfe für alle Ihre Fragen eingebaut, die nicht von diesen Modulen abgedeckt werden. Sie können **help()** für eine Übersicht oder help(x) für jede Bibliothek, jedes Objekt oder jeden Typ x ausführen, um weitere Informationen zu erhalten."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variablen <a class=\"anchor\" id=\"t2\"></a>\n",
    "Ein Name, der verwendet wird, um in ihm einen Wert zu speichern, wird als **Variable** bezeichnet. In Python können Variablen deklariert und ihr können Werte wie folgt zugewiesen werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 100                             # 'y' ist die Variable und 100 der ihr zugewiesene Wert\n",
    "x = y = z = 33                      # Der gleiche Wert kann unterschiedlichen Variablen geleichzeitig zugewiesen werden\n",
    "xy = 'ist meine Glückszahl'         # Die Wertzuweisung muss keine Zahl beinhalten (siehe Datentypen)\n",
    "print(x+y+z, xy)                    # print() gibt bei Ausführung den Klammerinhalt aus"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3 Datentypen <a class=\"anchor\" id=\"t3\"></a>\n",
    "Die grundlegenden Datentypen sind: \n",
    "* `float` (Gleitkommazahlen)\n",
    "    * sind immer fehlerbehaftet\n",
    "    * begrenzt bis max = 1.7976931348623157e+308 und min = 2.2250738585072014e-308\n",
    "* `int` (ganze Zahlen)\n",
    "* `str` (Zeichenketten)\n",
    "* `bool` (wahr/ falsch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2.0           # float\n",
    "-1234567890   # int\n",
    "1e100         # int\n",
    "True          # wahr   oder binär 1\n",
    "False         # falsch oder binär 0\n",
    "'Ich bin eine Zeichenkette'\n",
    "z = \"Ich bin eine gleichwertige Zeichenkette\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1 Datentypen verändern <a class=\"anchor\" id=\"t31\"></a>\n",
    "Die Konvertierung von einem zum anderen Datentyp ist möglich über folgende Funktionen: \n",
    "* int(X), d.h. X wird zur ganzen Zahl (Achtung: Die Kommazahlen werden abgeschnitten)\n",
    "* str(X), d.h. X wird zum Zeichenkette"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(int(7.7), int('111',2),int('7'))\n",
    "print(str(True),str(1.2345678),str(-2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4 Operatoren <a class=\"anchor\" id=\"t4\"></a>\n",
    "Python kann wie ein Taschenrechner verwendet werden. Die grundelegenden Operatoren dabei sind:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Symbol | Was macht das? |\n",
    "|----|---|\n",
    "| +  | Addition |\n",
    "| -  | Subtraktion |\n",
    "| *  | Multiplikation |\n",
    "| /  | Division |\n",
    "| //  | Abgeschnittene Division |\n",
    "| %  | Modulus |\n",
    "| **  | Potenz |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1+2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1*2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3/4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In vielen Sprachen (und älteren Versionen von Python) ist 1/2 = 0 (sog. abgeschnittene Division). In Python 3 wird dieses Verhalten durch einen separaten Operator erfasst, der nach unten rundet: a // b =⌊𝑎𝑏⌋. Darüber hinaus existiert die Modulus Operation, die den Rest eines rationalen Zahl ausgiebt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(3/4)           # normale        Division\n",
    "print(3//4)          # abgeschnittene Division\n",
    "print(7//4)          # abg.           Division\n",
    "print(15%10)         # Modulus"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.1 Relationale Operatoratoren (Beziehung) <a class=\"anchor\" id=\"t41\"></a>\n",
    "R.O. sind boolische Operatoren, die die Beziehung zwischen zwei Werten prüfen und **True** oder **False** ausgeben. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Symbol | Was bedeutet das? |\n",
    "|----|---|\n",
    "| ==  | True, wenn gleich |\n",
    "| !=  | True, wenn **nicht** gleich |\n",
    "| <  | weniger als |\n",
    "| >  | mehr als |\n",
    "| <=  | weniger oder gleich |\n",
    "| >=  | mehr oder gleich |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = 2\n",
    "z == 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z > 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Operatoren können auch logisch verkettet werden:\n",
    "\n",
    "| Bedeutung      | Verkettender Operator |\n",
    "|:-------------|------------------|\n",
    "| Logical and  | `and`            |\n",
    "| Logical or   | `or`             |\n",
    "| Negation     | `not`            |\n",
    "\n",
    "| Wert Abfrage 1 | Wert Abfrage 2 | **and**-Verkettung | **or**-Verkettung |\n",
    "|----|----|----|----    |\n",
    "|True|False|False|True  |\n",
    "|False|True|False|True  |\n",
    "|True|True|True|True    |\n",
    "|False|False|False|False|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#And \n",
    "print(True and False)\n",
    "\n",
    "#Or\n",
    "print(True or False)\n",
    "\n",
    "#Not = Invertieren\n",
    "print(not(True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5 Funktionales Programmieren <a class=\"anchor\" id=\"t5\"></a>\n",
    "Neben dem objektorienterten, ist in Python auch das funktionale Programmieren möglich, welches für Ingenieurs-Anwendungen häufiger zum Einsatz kommt. Dabei können Funktionen mit Eingabeparametern (argument) über die Aufrufe von `def` oder `lambda` einmal definiert, über ihren Namen aufgerufen und dabei ihren Paramtern ein bestimmter Wert übergeben werden. Über den Aufruf von `return` kann spezifiziert werden, was die Funktion ausgeben soll. Der Ausgabewert kann dann weiter verwendet werden, z.B. indem man ihm einer Variable zuordnet oder man ihn sich ausgeben lässt durch `print`.\n",
    "<br> Dabei ist es essenziell darauf zu achten, dass alles, was zur Funktions-Definition gehört, eingerückt ist. Andernfalls wird es so kompiliert, als gehöre es nicht mehr dazu. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.1 def <a class=\"anchor\" id=\"t51\"></a>\n",
    "Mit `def ` kann eine Funktion mit folgender Syntax *definiert* werden: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def zwei_mal_ausführen(funktion, argument):        # def Name (Argumente mit KOMMA getrennt) : | Umlaute sind kein Problem\n",
    "    return funktion(funktion(argument))             # was soll die Funktion ausgeben? | einrücken ist essenziell\n",
    "\n",
    "def fuenf_addieren(x):                              # einfache Funktion, die 5 zu seinem Argument x addiert\n",
    "    return (x+5)                                    # was soll die Funktion ausgeben? | einrücken ist essenziell\n",
    "\n",
    "print(fuenf_addieren(3))\n",
    "print(zwei_mal_ausführen(fuenf_addieren, 10))        # fünf_addieren ist ein Argument von zwei_mal_ausführen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.2 lambda <a class=\"anchor\" id=\"t52\"></a>\n",
    "Bei `def` weist man die Funktion einer Variablen zu, indem man ihr einen Namen gibt. Man kann eine Funktion aber auch *on the fly* mittels `lambda` definieren; weil diese Funktionen dann keinen Namen haben, werden sie als anonym klassifiziert. Es handelt sich meistens um Einzeiler, können aber nicht mehrfach aufgerufen werden. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print ((lambda x: x+5) (5))                  # lambda x weist auf eine anonyme Funkt. hin, gefolgt vom Funktionsterm und dem Argument"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6 Control Flow Statements <a class=\"anchor\" id=\"t6\"></a>\n",
    "| Kategorie | Typ | Bedeutung |\n",
    "|----|--|----|\n",
    "| Conditional | If | Ausführen, wenn ein Zustand zutrifft |\n",
    "| Conditional | If-Else | Ausführen, wenn ein Zustand zutrifft, sonst |\n",
    "| Conditional | Else If | Ausführen, wenn der eine oder andere Zustand zutrifft, sonst |\n",
    "| Schleifen | For | Über einen Bereich (range) laufen |\n",
    "| Schleifen | While | Ausführen, bis ein Zustand erreicht wird |\n",
    "| Schleifen | Break | Ermöglicht den Abbruch einer Schleife |\n",
    "| Schleifen | Continue | Neue Schleife wird erzwungen |\n",
    "\n",
    "Weiterhin wird Einrückungen zum Markieren von Blöcken verwendet. Daher ist die Menge an Leerzeichen oder Tabulatorzeichen am Anfang einer Zeile sehr wichtig. Dies trägt im Allgemeinen dazu bei, den Code besser lesbar zu machen, kann aber neue Benutzer von Python überrumpeln. Grundatz: Fügt keine Leerzeichen ein, es sei denn, sie werden für den Befehl benötigt."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.1 Conditionals<a class=\"anchor\" id=\"t61\"></a>\n",
    "Finden Anwendung in Kombination mit relationalen Operatoren wie `==`, `!=`, `<`, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.1.1 If <a class=\"anchor\" id=\"t611\"></a>\n",
    "**If**: Wenn eine bestimmte Abfrage wahr ist, also den Wert True annimmt, dann führe die zugehörige Anweisung aus, die hinter dem \"**:**\" steht und eingerückt, direkt unter der If Abfrage aufgeführt ist."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python \n",
    "if some_condition:\n",
    "    code block```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "x = 12\n",
    "if x > 10:\n",
    "    print(\"Moin\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.1.2 If-else <a class=\"anchor\" id=\"t612\"></a>\n",
    "Wenn die **If** Abfrage True ist, führe alles direkt unter If aus, ansonsten führe die Anweisung unter **else** aus."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "if some_condition:\n",
    "    code block\n",
    "else:\n",
    "    code block```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 12\n",
    "if 10 < x < 11:\n",
    "    print(\"hello\")\n",
    "else:\n",
    "    print(\"world\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.1.3 Else if <a class=\"anchor\" id=\"613\"></a>\n",
    "Gegeüber **If-else** lässt sich mit **elseif** ein weiterer **If** Aufruf einführen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "if some_condition:  \n",
    "    code block\n",
    "elif some_condition:\n",
    "    code block\n",
    "else:\n",
    "    code block```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10\n",
    "y = 12\n",
    "if x > y:\n",
    "    print(\"x>y\")\n",
    "elif x < y:\n",
    "    print(\"x<y\")\n",
    "else:\n",
    "    print(\"x=y\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10\n",
    "y = 12\n",
    "if x > y:\n",
    "    print( \"x>y\")\n",
    "elif x < y:\n",
    "    print( \"x<y\")\n",
    "    if x==10:\n",
    "        print (\"x=10\")\n",
    "    else:\n",
    "        print (\"invalid\")\n",
    "else:\n",
    "    print (\"x=y\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6.2 Schleifen <a class=\"anchor\" id=\"t62\"></a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.2.1 For <a class=\"anchor\" id=\"t621\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "for variable in something:\n",
    "    code block```\n",
    "    \n",
    "Für jede Variable in etwas wird der Codeblock ausgeführt. Dies wird Schleifenbildung genannt. \n",
    "Beim Schleifenb. über ganze Zahlen ist die Funktion `range()` nützlich, die einen Bereich von ganzen Zahlen erzeugt:\n",
    "* Bereich(n) = 0, 1, ..., n-1\n",
    "* Bereich(m,n)= m, m+1, ..., n-1\n",
    "* Bereich(m,n,s)= m, m+s, m+2s, ..., m + ((n-m-1)//s) * s (die letzte Zahl ist die höchste Zahl in der Form m+xs, die kleiner als n ist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "for ch in 'abc':\n",
    "    print(ch)### 2.1 For <a class=\"anchor\" id=\"t21\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(3):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.2.2 While <a class=\"anchor\" id=\"t622\"></a>\n",
    "**while** Schleifen sind so lange aktiv, wie ihre Bedinung erfüllt ist."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "while some_condition:  \n",
    "    code block```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 1\n",
    "while i < 4:      # Zustand, der True sein muss, damit die Schleife weiterläuft\n",
    "    print(i)      # Ausgabe\n",
    "    i = i+1       # Laufindex\n",
    "print('Die while Schleife ist nicht mehr aktiv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.2.3 Break <a class=\"anchor\" id=\"t623\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(100):\n",
    "    print(i)\n",
    "    if i >= 5:\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7 Bibliotheken <a class=\"anchor\" id=\"t7\"></a>\n",
    "Python kommt mit einer Vielzahl an Funktionen. Einige sind bereits standardmäßig integriert (built-in) und immer verfügbar, <br> andere stehen als vorinstallierte Standard-Bibliothek (standard library) bereit \n",
    "<br> und andere wiederzum stehen als externe Bibliotheken zur Verfügung, die von anderen Python-Benutzern erstellt und bereitgestellt wurden (open source). \n",
    "<br> Die externen Bibiliotheken können mit dem Aufruf von `pip` im Command-Window deines Rechners installiert werden. \n",
    "<br> Um Funktionen aus Bibliotheken (standard oder extern) nutzen zu können, müssen diese explizit im Python-Code importiert werden, dazu ist der Aufruf von `import` nötig. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.1 Mathematische Funktionen - math <a class=\"anchor\" id=\"t71\"></a>\n",
    "Mit der Standard-Bibliothek `math` können Funktionen zu Logarithmen, trigonometrische Funktionen, die Konstante $\\pi$ und so weiter importiert werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "print(math.sin(math.pi/2))\n",
    "\n",
    "from math import * # vermeiden, vor jede mathematische Funktion math. setzen zu müssen\n",
    "print(sin(pi/2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.2 Differenzieren und Integrieren <a class=\"anchor\" id=\"t72\"></a>\n",
    "Bei der Behandlung von Ab- und Aufleitungen kann man zwischen analytischem und numerischem Vorgehen unterscheiden. \n",
    "* analytisch: Für eine gegebene Funktion (y(x)) die über einen Definitionsbereich (x) auf einen Bildbereich (y) abbildet.\n",
    "* numerisch: Näherungsweise Berechnung aus gegebenen Funktionswerten. Dies ist nötig, falls die Funktion selbst nur indirekt, beispielsweise über **Messwerte**, zur Verfügung steht."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.2.1 Analytisch - sympy <a class=\"anchor\" id=\"t721\"></a>\n",
    "SymPy ermöglicht Berechnungen und Darstellungen im Rahmen von einfacher symbolischer Arithmetik bis hin zu Differential- und Integralrechnung sowie Algebra, diskreter Mathematik und Quantenphysik.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sympy\n",
    "x, y, z = sympy.symbols('x y z')\n",
    "sympy.diff(x**4, x, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.2.2 Numerische Integration - scipy.integrate <a class=\"anchor\" id=\"t722\"></a>\n",
    "Die SciPy-Bibliothek stellt Algorithmen zur numerischen Integration und numerischen Optimierung sowie eine wachsende Menge von zusätzlichen Bibliotheken für verschiedene Problemstellungen im Bereich des computerunterstützten numerischen Rechnens, z. B. IPython, Matplotlib, pandas und SymPy zur Verfügung. Mit .integrate werden nur die Tools für die numerische Integration geladen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from scipy.integrate import quad\n",
    "\n",
    "quad(lambda x: 2*math.sqrt(1-x*x), -1, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8 Mit Datenmengen arbeiten <a class=\"anchor\" id=\"t5\"></a>\n",
    "Datenmengen können in Bereichen (sogenannten *arrays*) gespeichert werden, darunter:\n",
    "\n",
    "|Typ|Reihenfolge|Veränderbar|Doppelte Einträge möglich|\n",
    "|----|----|----|----|\n",
    "| List | Ja | Ja | Ja |\n",
    "| Tuple | Ja | Nein | Ja |\n",
    "| Set | Nein | Nein, ohne Index | Nein |\n",
    "| Dictionary | Nein | Ja, mit Index | Nein |\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.1 List <a class=\"anchor\" id=\"t81\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Liste definieren\n",
    "thislist = [\"Apfel\", \"Melone\", \"Orange\", \"Banane\", \"Kirsche\"]\n",
    "print(thislist[0])      # Der erste Eintrag hat den Index 0!\n",
    "\n",
    "#negativer Index\n",
    "print(thislist[-1])\n",
    "\n",
    "#Bereich\n",
    "print(thislist[2:5])    # Der Index 5 ist nicht in der Menge, Index 2 hingegen schon\n",
    "\n",
    "#bis..\n",
    "print(thislist[:4])\n",
    "\n",
    "#von..\n",
    "print(thislist[2:])\n",
    "\n",
    "#Reihenfolge umkehren\n",
    "print(thislist[-4:-1])\n",
    "\n",
    "#Eintrag ändern\n",
    "thislist[1] = \"Schwarzer Pfeffer\"\n",
    "print(thislist)\n",
    "\n",
    "#for-Schleife durch eine Liste hindurch\n",
    "for x in thislist:\n",
    "  print(x)\n",
    "\n",
    "#if-Condition für Liste\n",
    "if \"Apfel\" in thislist:\n",
    "  print(\"Jawoll, Apfel gibts\")\n",
    "\n",
    "#Länge einer Liste abfragen\n",
    "print(len(thislist))\n",
    "\n",
    "#einen Eintrag anhängen\n",
    "thislist.append(\"Kumquat\")\n",
    "print(thislist)\n",
    "\n",
    "#einen Eintrag an einer bestimmten Pos. hinzufügen\n",
    "thislist.insert(1, \"Bestimmte Position\")\n",
    "print(thislist)\n",
    "\n",
    "#einen Eintrag entfernen\n",
    "thislist.remove(\"Bestimmte Position\")\n",
    "print(thislist)\n",
    "\n",
    "#Eintrag an Pos. x entfernen\n",
    "thislist.pop(1)\n",
    "print(thislist)\n",
    "\n",
    "#Liste kopieren\n",
    "mylist = thislist.copy()\n",
    "\n",
    "#Listen zusammenführen\n",
    "finallist = mylist + thislist\n",
    "print(finallist)\n",
    "\n",
    "#Liste leeren, der array hat Bestand\n",
    "thislist.clear()\n",
    "print(thislist)\n",
    "\n",
    "#Liste komplett löschen\n",
    "del thislist\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.2 Tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thistuple = (\"Apfel\", \"Banane\")\n",
    "print(thistuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.3 Set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thisset = {\"Apfel\", \"Melone\", \"Orange\", \"Banane\", \"Kirsche\"}\n",
    "print(thisset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.4 Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thisdict = {\n",
    "  \"Marke\": \"Mercedes\",\n",
    "  \"Modell\": \"C-Klasse\",\n",
    "  \"Bau-Jahr\": 1997## 5.2 List\n",
    "}\n",
    "print(thisdict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.5 Datenvisualisierung <a class=\"anchor\" id=\"t85\"></a>\n",
    "In der Bibliothek matplotlib sind Funktionen zur Visualisierung enthalten: `import matplotlib`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "data = [3,4,5,1,2]\n",
    "s = pd.Series(data, index=range(10, 20, 2))\n",
    "s.plot()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.6 Pandas <a class=\"anchor\" id=\"t86\"></a>\n",
    "Zusammengesetzt aus: Python and data analysis. Pandas ist eine Bibliothek (`import pandas`) und stellt Funktionen und spezielle Daten-Strukturen zur Manipulation numerischer Tabellen und Zeit-Serien zur Verfügung. Die beiden grundlegenden Daten-Strukturen sind dabei:\n",
    "\n",
    "* Series: ein eindimensionales Array-ähnliches Objekt. Es kann verschiedene Daten-Typen aufnehmen, z.B. Integers, Floats, Strings, Python-Objekte, usw..\n",
    "Eine Series kann als eine Datenstruktur mit zwei Arrays angesehen werden: Ein Array fungiert als Index, d.h. als Bezeichner (Label), und ein Array beinhaltet die aktuellen Daten (Werte).\n",
    "* DataFrame: beinhaltet eine geordnete Sammlung von Spalten. Jede Spalte besteht aus einem eindeutigen Daten-Typen, aber verschiedene Spalten haben verschiedene Typen, z.B. könnte die erste Spalte vom Typ Integer sein, während die zweite Spalte vom Typ Boolean ist, usw.. \n",
    "Ein DataFrame hat einen Zeilen- und Spalten-Index. Es ist wie ein Dictionary aus Series mit einem normalen Index. Weitere Funktionen unter <br>https://www.python-kurs.eu/pandas_DataFrame.php"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "years = range(2014, 2018)\n",
    "Jahre = pd.Series([\"Semester 1-2\", \"S. 3-4\", \"S. 5-6\", \"S. 7-8\"], index=years)\n",
    "print (Jahre)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "cities = {\"Bezeichnung\": [\"London\", \"Berlin\", \"Madrid\", \"Rom\"],\n",
    "          \"Einwohner\": [8615246, 3562166, 3165235, 2874038],\n",
    "          \"Land\": [\"England\", \"Deutschland\", \"Spanien\", \"Italien\"]}\n",
    "city_frame = pd.DataFrame(cities)\n",
    "\n",
    "# Ordinate beschriften\n",
    "ordinals = [\"erste\", \"zweite\", \"dritte\", \"vierte\"]\n",
    "\n",
    "\n",
    "city_frame = pd.DataFrame(cities, index=ordinals)\n",
    "print(city_frame)\n",
    "\n",
    "import matplotlib\n",
    "city_frame.plot(xticks=range(len(city_frame.index)),\n",
    "                rot=60)\n",
    "plt.gca().yaxis.set_major_formatter(matplotlib.ticker.FormatStrFormatter('%d')) \n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": true,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}