die_pythonische_kueche.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Die pythonische Küche\n",
    "Jede Skript- oder Programmiersprache besteht aus Bestandteilen, die man wie die Zutaten der Küche eines bestimmten Landes sehen kann. Es gibt die arabische, die japanische, die mexikanische und die deutsche Küche. Und es gibt PHP, Ruby, C und [viele weitere Programmiersprachen](https://en.wikipedia.org/wiki/Comparison_of_programming_languages). Und es gibt Python.\n",
    "\n",
    "Um einen kurzen Überblick in die pythonische Küche zu erlangen, wollen wir im folgenden die typischen Zutaten der pythonischen Küche vorstellen und am Ende ein erstes Gericht kochen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%HTML\n",
    "<a data-flickr-embed=\"true\" data-footer=\"true\"  href=\"https://www.flickr.com/photos/chris_fynn/17306765722/in/photolist-snkGus-caHnR1-xu821-rpTLoy-aHVVCa-9HCtuM-5TBbf9-5pdsTN-6uFfXS-as8AVu-ryWb7m-8ENynw-fKgdBp-dcnUCL-969ph6-6jJQy5-ogzafq-6PdEtv-aeQtWj-9Kx2Kf-6CyvD1-8EKodZ-6Pk8DB-7szfrX-6CYNJz-cXoYkw-9X4va3-aeyj55-7WP55r-eQoRR5-dUwpRX-aeyqYh-govHd6-i4dLKh-aeyiMN-begQVa-b7HMoX-8vaDer-7wq3Ya-5ETLwq-5hscmj-aevBiP-8arifu-aevtUv-nBuFiJ-4frgBF-aeybvw-6jED5P-dzEHCi-aeyj9u\" title=\"Mysore - Fruit vendor\"><img src=\"https://c1.staticflickr.com/9/8803/17306765722_a2d0be2f9e_n.jpg\" width=\"320\" height=\"213\" alt=\"Mysore - Fruit vendor\"></a><script async src=\"//embedr.flickr.com/assets/client-code.js\" charset=\"utf-8\"></script>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ausgaben"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hallo Welt!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Damit sagen wir der Community der Pythonköchinnen und -köche, dass wir jetzt auch dabei sind. Außerdem gibt uns dieser Ausgabebefehl in Zukunft die Möglichkeit, in der Richtung *Maschine -> Mensch* zu kommunizieren. Mit `print()` können also Ergebnisse von Berechnungen, Eingabeaufforderungen u.ä. ausgegeben werden."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kommentare\n",
    "\n",
    "Kommentare sind nützlich und sinnvoll, wenn sie den Code genauer beschreiben und anderen Menschen Hinweise geben, was ein Programmteil für Aufgaben hat, was in Zukunft noch zu tun ist oder was nicht funktioniert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ein Kommentar hat am Anfang eine Raute.\n"
     ]
    }
   ],
   "source": [
    "# Ein einzeiliger Kommentar\n",
    "print(\"Ein Kommentar hat am Anfang eine Raute.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variablen und Datentypen\n",
    "\n",
    "**Variablen** speichern Werte, die wir häufiger in unseren Programmen brauchen. Diese verschiedenen Arten von Daten werden **Datentypen** genannt."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hier haben wir eine Ganzzahl, auch Integer genannt, in der Variablen `sinn_des_lebens` gespeichert. Ganzzahlen gehören in Python zum Datentyp **Numbers**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n"
     ]
    }
   ],
   "source": [
    "sinn_des_lebens = 42\n",
    "print(sinn_des_lebens)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45\n"
     ]
    }
   ],
   "source": [
    "print(42+3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hier haben wir eine Fließkommazahl gespeichert und ausgegeben. Auch sie gehört zu den **Numbers**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "preis = 1.99\n",
    "print(preis)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String (Zeichenkette)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Variablen lassen sich sehr unterschiedliche Arten von Werten speichern. Eben haben wir eine Zeichenkette, auch **String** genannt, in der Variablen `tier` gespeichert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tier = \"Giraffe\"\n",
    "print(tier)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Liste"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jetzt haben wir eine **Liste** in der Variablen `tiere` gespeichert und wieder ausgegeben."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tiere = [\"Giraffe\", \"Salamander\", \"Iltis\"]\n",
    "print(tiere)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionary (Verzeichnis)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dieser Datentyp wird **Dictionary** genannt, weil er wie eine Art Verzeichnis funktioniert: Links stehen die Bezeichner, rechts die dazugehörigen Werte."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "elefant = {\n",
    "    \"name\": \"Dieter\",\n",
    "    \"alter\": 12,\n",
    "    \"gewicht\": 5800\n",
    "}\n",
    "\n",
    "print(elefant)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolean (Wahrheitswert)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`True` und `False` sind die beiden Werte des **boolschen Datentyps**. Mit ihm werden eindeutige Zustände ausgedrückt wie \"an\" und \"aus\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "schalter_1 = False\n",
    "schalter_2 = True\n",
    "\n",
    "print(schalter_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Zusammenfassung und weiterführende Informationen\n",
    "**Numbers**, **String**, **List**, **Dictionary** und **Boolean** sind *Datentypen* in Python. Es gibt noch viele weitere, die aber an dieser Stelle erst einmal keine Rolle spielen. Sehr ausführlich werden Variablen und Datentypen auf der Website [Datentypen und Variablen](http://www.python-kurs.eu/python3_variablen.php) erläutert."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wer lieber einen Film schauen möchte, findet z.B. das Thema **Listen** gut erklärt im folgenden Video. Auf Youtube gibt es noch mehr Filme dieser Art."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%HTML\n",
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/Z-folPNH6ro?list=PLD20BEE125C1FC7B1\" frameborder=\"0\" allowfullscreen></iframe>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bedingte Anweisungen und Verzweigungen\n",
    "\n",
    "Man spricht von einer Fallunterscheidung oder bedingten Anweisung, wenn ein Codeblock an eine Bedingung geknüpft ist. Der Codeblock wird folglich nur ausgeführt, wenn die Bedingung erfüllt wird.\n",
    "\n",
    "Eine **bedingte Anweisung** wird mit `if` formuliert:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "kartoffeln = 3\n",
    "\n",
    "if kartoffeln >= 4:\n",
    "  print(\"Es gibt Kartoffelsalat.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Z1 wird der Variablen `kartoffeln` der Wert `3` zugewiesen. In Z3 wird geprüft, ob es vier oder mehr Kartoffeln gibt. Wenn ja, reicht es für Kartoffelsalat. Es reicht nicht..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Will man auch eine Ausgabe sehen, wenn die Kartoffeln nicht für den Salat reichen, ist eine **Verzweigung** angebracht:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "kartoffeln = 3\n",
    "\n",
    "if kartoffeln >= 4:\n",
    "  print(\"Es gibt Kartoffelsalat.\")\n",
    "else:\n",
    "  print(\"Die Kartoffeln reichen nicht. Leider.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eine weitere Variante von Verzweigungen ist möglich, wenn mehr Zweige gebraucht werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "kartoffeln = 3\n",
    "\n",
    "if kartoffeln >= 4:\n",
    "  print(\"Es gibt Kartoffelsalat.\")\n",
    "elif kartoffeln == 3:\n",
    "  print(\"Das gibt genau einen Kartoffelpuffer.\")\n",
    "else:\n",
    "  print(\"Die Kartoffeln reichen nicht. Leider.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mit bedingten Anweisungen und Verzweigungen haben wir sozusagen die Kartoffel der pythonischen Küche kennengelernt. Diese **Kontrollstruktur** ermöglicht es, ein Programm den Umständen bzw. Bedingungen entsprechend unterschiedliche Pfade einzuschlagen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operatoren\n",
    "\n",
    "In den meisten Programmiersprachen gibt es Operatoren, die - wie der Name schon sagt - Operationen mit den Daten eines Programms ermöglichen. In dem letzten Beispiel oben kommen z.B. die **Vergleichsoperatoren** `==` und `>=` vor. Außerdem gibt es noch **Rechenoperatoren** für die Grundrechenarten, `+`, `-`, `*` und `/`. Weitere Operatoren sind [in entsprechenden Onlinereferenzen zu finden](http://www.python-kurs.eu/python3_operatoren.php)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Schleifen\n",
    "\n",
    "Mit Schleifen können Vorgänge in Programmen wiederholt werden. In der Regel hat eine Schleife eine *Abbruchbedingung*. Wenn diese erfüllt ist, wird die Schleife verlassen und das Programm danach fortgesetzt."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### for-Schleife\n",
    "\n",
    "Die **for-Schleife** wird eingesetzt, wenn die Anzahl der Male, die sie laufen soll, bekannt ist."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tiere = ['Hund', 'Katze', 'Maus']\n",
    "\n",
    "for tier in tiere:\n",
    "    print(tier)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hier werden die Elemente einer Liste von Anfang bis Ende durchlaufen. `tier` ist dabei immer der aktuelle Wert in einem Durchlauf. Wenn die Liste komplett durchlaufen wurde, wird die Schleife verlassen und das Programm danach fortgesetzt."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Es gibt noch weitere Schleifen, die aber an dieser Stelle noch nicht so wichtig sind. Interessierte können darüber [online nachlesen](http://www.python-kurs.eu/python3_schleifen.php)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funktionen\n",
    "\n",
    "Funktionen schließen Programmteile ein, die häufiger verwendet werden. Man sagt auch, die Programmteile werden *gekapselt*. Nach außen sind diese teilweise sehr komplexen Programmteile unter einem sinnvollen und aufschlussreichen Namen erreichbar.\n",
    "\n",
    "Zunächst muss eine Funkion definiert werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "# Funktionsdefinition\n",
    "def berechne_tagesabschnitt():\n",
    "    \n",
    "    zeitstempel = time.time()\n",
    "    # print(\"{} Sekunden sind seit 1970 vergangen.\".format(zeitstempel))\n",
    "    \n",
    "    teile_des_zeitstempels = time.localtime(zeitstempel)\n",
    "    # print(teile_des_zeitstempels)\n",
    "    \n",
    "    stunde_des_tages = teile_des_zeitstempels[3]\n",
    "    # print(stunde_des_tages)\n",
    "    \n",
    "    if stunde_des_tages < 12:\n",
    "        print(\"Es ist Vormittag.\")\n",
    "    elif stunde_des_tages < 18:\n",
    "        print(\"Es ist Nachmittag.\")\n",
    "    elif stunde_des_tages < 24:\n",
    "        print(\"Es ist Abend.\")\n",
    "    else:\n",
    "        print(\"Es ist Nacht.\")\n",
    "\n",
    "# Funktionsaufruf\n",
    "berechne_tagesabschnitt()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Das Programm ist absichtlich etwas komplexer, um einige Dinge zeigen zu können:\n",
    "\n",
    "1. Es wird ein so genanntes Modul importiert: `time`\n",
    "1. Es wird von Variablen Gebrauch gemacht, die verschiedene Zwischenergebnisse speichern.\n",
    "1. Es werden Funktionen verwendet, die schon in Python \"eingebaut\" sind: `time()`, `localtime()` und `print()`.\n",
    "1. Es wird eine Verzweigung verwendet, die einen Wert untersucht und danach entscheidet, wie das Programm weitergeht.\n",
    "1. Es werden verschiedene Ausgaben getätigt."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Man könnte sagen, dass für die Ausgabe \"Es ist...\" ziemlich viel Aufwand getrieben wird. Dieser Aufwand wird aber in der Funktion `berechne_tagesabschnitt()` gekapselt. Diese wird zunächst mit dem Schlüsselwort `def` *definiert*. Deshalb spricht man hier auch von der *Funktionsdefinition*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Um nun von der Funktion Gebrauch machen zu können, muss sie aufgerufen werden. Dies geschieht mit dem *Funktionsaufruf* in Z25."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funktionen mit Parametern\n",
    "\n",
    "Funktionen machen dann erst richtig Spaß, wenn man ihnen Argumente übergeben kann. Dafür muss die erste Zeile einer Funktion, die *Funktionssignatur*, Parameter enthalten, die Argumente beim Funktionsaufruf auffangen können."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def verdoppeln(zahl):\n",
    "    print(zahl * 2)\n",
    "    \n",
    "verdoppeln(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Funktion stellt einen Parameter bereit, der einen übergebenen Wert \"auffängt\" wie ein Eimer. Dieser wird dann innerhalb der Funktion, im *Funktionsrumpf* weiterverarbeitet.\n",
    "\n",
    "Beim Funktionsaufruf wird eine beliebige Zahl übergeben, und egal welche es ist, die Funktion verdoppelt sie und gibt das Ergebnis aus."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funktionen mit Rückgabewert\n",
    "\n",
    "Die zunächst letzte Variante von Funktionen liefert nach getaner Arbeit einen Wert zurück."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def verdoppeln(zahl):\n",
    "    return zahl * 2\n",
    "    \n",
    "ergebnis = verdoppeln(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hier wird das Ergebnis der Verdopplung nicht sofort ausgegeben, sondern zunächst mit `return` an die aufrufende Stelle zurückgegeben. Dort muss der Rückgabewert in einer Variablen gespeichert werden, da er sonst verloren geht. Mit der Variablen `ergebnis` kann nun in der Folge des Programms weitergearbeitet werden. Eine Ausgabe erfolgt also ggf. später."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zusammenfassung\n",
    "\n",
    "Die pythonische Küche verfügt noch über weit mehr Zutaten und Techniken, die in diesem Crashkurs Python nicht alle genannt werden können. Es wurden jedoch einige wesentliche Teile der Programmiersprache vorgestellt, die für den Bau von Webseiten z.B. mit [Flask](http://flask.pocoo.org/) zunächst ausreichend sind."
   ]
  }
 ],
 "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.4.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}