Cheat Sheet.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Cheat Sheet\n",
    "Auch in diesem Dokument wurden die erklärten Konzepte mit Icons versehen.\n",
    "Solltet ihr in der Vorlesung oder auf einem Arbeitsblatt Schwierigkeiten haben, könnt ihr anhand der Icons die relevanten Abschnitte in diesem Dokument finden\n",
    "<table>\n",
    "    <tr>\n",
    "        <td style=\"border: none;\"><img src=\"https://user-images.githubusercontent.com/12890716/141120590-2dc798a8-26d6-4527-a549-1d6f2c6d9d5c.png\" alt=\"drawing\" width=\"50\"/></td>\n",
    "        <td style=\"border: none;\">String-Formattierung</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"border: none;\"><img src=\"https://user-images.githubusercontent.com/12890716/141121893-bbf61d9e-f245-483b-a950-da12c72478c3.png\" alt=\"drawing\" width=\"50\"/></td>\n",
    "        <td style=\"border: none;\">Listen</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"border: none;\"><img src=\"https://user-images.githubusercontent.com/12890716/141121899-975e737f-da86-44f1-b683-a084b59869c1.png\" alt=\"drawing\" width=\"50\"/></td>\n",
    "        <td style=\"border: none;\">Dictionaries</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"border: none;\"><img src=\"https://user-images.githubusercontent.com/12890716/141122083-093a85dd-2455-4da3-b23b-71c99bc76d66.png\" alt=\"drawing\" width=\"40\"/></td>\n",
    "        <td style=\"border: none;\">Loops</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"border: none;\"><img src=\"https://user-images.githubusercontent.com/12890716/141122099-47fc98f5-7a5b-43f1-9b49-e31a129a6900.png\" alt=\"drawing\" width=\"40\"/></td>\n",
    "        <td style=\"border: none;\">Conditions</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"border: none;\"><img src=\"https://user-images.githubusercontent.com/12890716/141302710-7ff3067e-1b53-41f0-a5a8-d7e2c9c78af9.png\" alt=\"drawing\" width=\"40\"/></td>\n",
    "        <td style=\"border: none;\">Scopes</td>\n",
    "    </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Markdown syntax\n",
    "<p>Markdown ist sehr praktisch um Kommentare schnell und Strukturiert für Dokumentation von Code einzubinden und basiert auf HTML. Hier einmal die gängigsten Funktion:<p>\n",
    "\n",
    "### Überschriften\n",
    "Überschriften können mit \\# eingeleitet werden, Unterüberschriften mit \\## usw.\n",
    "    \n",
    "### Aufzählungen\n",
    "Mit dem \\* Zeichen können Punkte in einer Liste ausgegeben werden. Für eine Unterebene muss das \\* eingerückt werden. \n",
    "\n",
    "Beispiel:    \n",
    "* Item 1\n",
    "* Item 2\n",
    "    * Item 2.1\n",
    "* Item 3 \n",
    "\n",
    "### Bilder einfügen\n",
    "!\\[Bildtitel\\](Bild_Path.png)\n",
    "    \n",
    "### LateX (advanced)\n",
    "Jupyter Notebook Unterstützt außerdem LateX syntax:  \n",
    "$$K_y = \\sigma_y^2 I + K(X,X) = \\sigma_y^2 I + \\sigma_f^2 e^{-\\frac{1}{2\\ell^2} D} $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Jupyter Notebook\n",
    "\n",
    "Neue Zellen können mit dem + Symbol hinzugefügt werden. Des Weiteren kann man in dem Code dropdown auf Markdown umschalten um Freitext zu dokumentieren wie z.B. Erklärungen.\n",
    "\n",
    "### Shortcuts\n",
    "* Zelle auszuführen = Shift+Enter\n",
    "* Markdown Zelle nach ausführung wieder editieren = Doppelklick auf die Zelle\n",
    "* Speichern = Strg + S\n",
    "* Einrücken = TAB\n",
    "* Einrückung zurücknehmen = Shift + TAB\n",
    "\n",
    "### PDF generieren\n",
    "File -> Download as -> PDF via LateX (Erfordert eine Installation von LateX mit z.B. mikTeX)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python\n",
    "Nun zum wichtigen Teil, die Python Syntax. Im Folgenden werden die wichtigsten Beispiele aus der Vorlesung und Übung nochmal aufgegriffen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Kommentare\n",
    "Kommentare werden in Python mit einem \\# eingeleitet. Dadurch werde sie nicht als Code interpretiert und nicht ausgeführt. Bei Kommentaren über mehre Zeilen wird \"\"\" ... \"\"\" verwendet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Das ist ein Kommentar\n",
    "\n",
    "\"\"\"\n",
    "Hier \n",
    "ist \n",
    "auch \n",
    "ein \n",
    "Kommentar\n",
    "der \n",
    "über \n",
    "viele \n",
    "Zeilen\n",
    "geht\n",
    "\"\"\"\n",
    "the_answer = 42"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Elementare Datentypen und Initialisierung\n",
    "In Python gibt es vier elementare Datentypen:\n",
    "* Integer - Ganze Zahlen\n",
    "* Float   - Gleitkomma Zahlen\n",
    "* String  - Text\n",
    "* Boolean - Wahrheitswerte\n",
    "\n",
    "Die Namen für Variablen können freigewählt werden, können jedoch z.B. nicht mit Zahlen beginnen. Des Weiteren sollen Sonderzeichen wie 'ü,ö,ä,ß,..' vermieden werden da diese zu Problem führen können."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "var_int    = 4      #Beispiel für ein Integer\n",
    "var_float  = 3.5    #Beispiel für ein Float. VORSICHT: Hier muss ein Punkt\n",
    "                    # verwendet werden, 3,5 geht nicht!\n",
    "var_String = 'Lorem ipsum'    #Beispiel für ein Float\n",
    "var_boolean_true  = True      #Beispiel für die beiden booleans\n",
    "var_boolean_false = False     #True und False müssen groß geschrieben werden!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ausgaben\n",
    "<img src=\"https://user-images.githubusercontent.com/12890716/141120590-2dc798a8-26d6-4527-a549-1d6f2c6d9d5c.png\" alt=\"drawing\" width=\"100\"/> <br>\n",
    "Ausgaben in Python können mit der print() funktion implementiert werden. Hier ein paar Beispiele:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "print('Hello World')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hier wird eine Variable ausgegeben: 4\n"
     ]
    }
   ],
   "source": [
    "print('Hier wird eine Variable ausgegeben:', var_int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Oder auch zwei: 4 Lorem ipsum\n"
     ]
    }
   ],
   "source": [
    "print('Oder auch zwei:', var_int, var_String)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Integer: 4 || Text: Lorem ipsum\n"
     ]
    }
   ],
   "source": [
    "print('Integer:', var_int, '|| Text:' ,var_String)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Fortgeschrittene String Formattierung"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "f strings are useful: inserted variable here -> Lorem ipsum\n"
     ]
    }
   ],
   "source": [
    "print(f'f strings are useful: inserted variable here -> {var_String}')\n",
    "#     ^ notice the f in front of the string. This indicates a f string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Today temperature is 25.14 C with a humidity of 12.12\n"
     ]
    }
   ],
   "source": [
    "temp = 25.1425\n",
    "humid = 12.1242\n",
    "print(\"Today temperature is %1.2f C with a humidity of %1.2f\"%(temp, humid))\n",
    "# Mit dieser Notation kannst du die Genauigkeit der Zahlen angeben,\n",
    "# die du printen möchtest\n",
    "# Die genaue Syntax für die %-Platzhalter findest du online"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Typecasting\n",
    "Variablen von einem Typ können durch ein Typecast in einen anderen Typen convertiert werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mein_String_1: <class 'str'>\n",
      "mein_String_2: <class 'int'>\n",
      "mein_String_3: <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "mein_String_1 = '4'\n",
    "mein_String_2 = int(mein_String_1)\n",
    "mein_String_3 = float(mein_String_1)\n",
    "\n",
    "print('mein_String_1:', type(mein_String_1))\n",
    "print('mein_String_2:',type(mein_String_2))\n",
    "print('mein_String_3:',type(mein_String_3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dadurch ist es z.B. auch möglich einen String durch einen Float zu teilen\n",
      "0.7333333333333333\n"
     ]
    }
   ],
   "source": [
    "zähler = '3.3'\n",
    "nenner = 4.5\n",
    "\n",
    "print('Dadurch ist es z.B. auch möglich einen String durch einen Float zu teilen')\n",
    "ergebnis = float(zähler) / nenner\n",
    "print(ergebnis)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importieren von Paketen\n",
    "Es gibt viele verschiedene liberies für Python die sehr mächtige neue Funktionalitäten mit sich bringen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "# So importiert man ein Software Paket:\n",
    "import math\n",
    "\n",
    "# Nach dem Import kann das Paket verwendet werden. Falls eine Funktion aus\n",
    "# dem Paket im weiteren genutzt werden soll muss Sie immer mit dem Paketnamen\n",
    "# referenziert werden:\n",
    "\n",
    "pi = math.pi\n",
    "print(pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Komplexe Datentypen\n",
    "Zusätzlich zu den elementaren Datentypen gibt es Komplexe Datentypen wie z.B. Listen, Dictonaries und Arrays\n",
    "#### Listen\n",
    "<img src=\"https://user-images.githubusercontent.com/12890716/141121893-bbf61d9e-f245-483b-a950-da12c72478c3.png\" alt=\"drawing\" width=\"100\"/> <br>\n",
    "Listen in Python kann man an den eckigen Klammern erkennen. Um auf Elemente in einer Liste zuzugreifen kann man sie mit dem richtigen index aufrufen. Die Indexzählung beginnt immer bei 0!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n"
     ]
    }
   ],
   "source": [
    "#    Index =     0     1     2    3\n",
    "meineListe = ['Hallo', 42, True, 1.7] # In einer Liste können auch verschiedene\n",
    "                                      # Datentypen gespeichert werden\n",
    "\n",
    "print(meineListe[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Noch\n"
     ]
    }
   ],
   "source": [
    "# Des Weiteren ist es möglich Listen zu Schachteln \n",
    "\n",
    "listenVonListen = [['Eine', 'Liste'], ['Noch', 'Eine', 'Liste']]\n",
    "\n",
    "# Hier haben wir 2 Listen in einer Liste gespeichert und brauch für eine Referenz\n",
    "# daher auch zwei Indizies\n",
    "print(listenVonListen[1][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries\n",
    "<img src=\"https://user-images.githubusercontent.com/12890716/141121899-975e737f-da86-44f1-b683-a084b59869c1.png\" alt=\"drawing\" width=\"100\"/> <br>\n",
    "Ein dict wird mit geschleiften Klammern eingeleitet und besteht immer aus key-value Paaren welche mit einem ':' seperiert werden müssen. Die einzelen paare werdern mit einem ',' getrennt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Kurs': 'Python lab', 'Lehrende': ['Thorben', 'Johannes'], 'Semster': 1, 'Zeiten': ['Montag', 'Freitag']}\n"
     ]
    }
   ],
   "source": [
    "mydict = {\n",
    "    \"Kurs\": \"Python lab\",\n",
    "    \"Lehrende\": ['Thorben', 'Johannes'],\n",
    "    \"Semster\": 1,\n",
    "    \"Zeiten\": ['Montag', 'Freitag']\n",
    "}\n",
    "print(mydict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python lab\n"
     ]
    }
   ],
   "source": [
    "print(mydict['Kurs'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Range()\n",
    "Die range() funktion ermöglich es eine liste automatisch zu erstellen und hat 3 Eingabe-Argumente:\n",
    "* Start\n",
    "* Ende\n",
    "* Inkrement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[-10, -8, -6, -4, -2, 0, 2, 4, 6, 8]\n",
      "[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "liste_1 = range(0, 10, 1)\n",
    "print(list(liste_1))\n",
    "\n",
    "liste_2 = range(-10, 10, 2)\n",
    "print(list(liste_2))\n",
    "\n",
    "liste_3 = range(10, 0, -1)\n",
    "print(list(liste_3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Schleifen\n",
    "<img src=\"https://user-images.githubusercontent.com/12890716/141122083-093a85dd-2455-4da3-b23b-71c99bc76d66.png\" alt=\"drawing\" width=\"70\"/> <br>\n",
    "Schleifen sind sehr nützlich in der Programmierung wenn man einen Schritt mehrmals ausführen möchte. In Python gibt es While und for Schleifen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for index in range(5):\n",
    "    print(index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "index = 0\n",
    "while(index < 5):\n",
    "    print(index)\n",
    "    index = index + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### If-Conditions\n",
    "<img src=\"https://user-images.githubusercontent.com/12890716/141122099-47fc98f5-7a5b-43f1-9b49-e31a129a6900.png\" alt=\"drawing\" width=\"70\"/> <br>\n",
    "In einem If-Statement können verschiedene Fälle ausgeführt werden basierend auf einer Fallunterscheidung."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fall 1\n"
     ]
    }
   ],
   "source": [
    "if 1 < 2:\n",
    "    print('Fall 1')\n",
    "else:\n",
    "    print('Fall 2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fall 2\n"
     ]
    }
   ],
   "source": [
    "if 1 > 2:\n",
    "    print('Fall 1')\n",
    "else:\n",
    "    print('Fall 2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fall 1\n"
     ]
    }
   ],
   "source": [
    "# Für einen Vergleich beachten, dass man zwei '=' benötigt!\n",
    "if 1 == 1:\n",
    "    print('Fall 1')\n",
    "else:\n",
    "    print('Fall 2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fall 1\n"
     ]
    }
   ],
   "source": [
    "# Kleiner/Gleich funktioniert genauso mit <=\n",
    "if 2 >= 2:\n",
    "    print('Fall 1')\n",
    "else:\n",
    "    print('Fall 2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolische Logik\n",
    "<img src=\"https://user-images.githubusercontent.com/12890716/141122099-47fc98f5-7a5b-43f1-9b49-e31a129a6900.png\" alt=\"drawing\" width=\"70\"/> <br>\n",
    "Die vollen Logiktabellen findet ihr in der Vorlesung, hier ein paar Beispiele:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AND - Fall 2\n",
      "OR - Fall 1\n"
     ]
    }
   ],
   "source": [
    "a = 20\n",
    "b = 3\n",
    "\n",
    "# Bei AND müssen BEIDE Fälle WAHR sein\n",
    "if a < 10 and b > 1:\n",
    "    print('AND - Fall 1')\n",
    "else:\n",
    "    print('AND - Fall 2')\n",
    "\n",
    "# Bei OR muss EINER der Fälle WAHR sein\n",
    "if a < 10 or b > 1:\n",
    "    print('OR - Fall 1')\n",
    "else:\n",
    "    print('OR - Fall 2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}