praesentation_2019_10_16.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       "td {\n",
       "    font-size: 25px;\n",
       "}\n",
       "thead th {\n",
       "    font-size: 25px;\n",
       "}\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<style>\n",
    "td {\n",
    "    font-size: 25px;\n",
    "}\n",
    "thead th {\n",
    "    font-size: 25px;\n",
    "}\n",
    "</style>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Einführung in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Vorstellung\n",
    "\n",
    "- Markus Wust\n",
    "- Studium: Englisch, Geschichte, Germanistik, Bibliothekswissenschaften, Humanities Computing\n",
    "- Arbeitete an Universitätsbibliothek in den USA\n",
    "- Seit Februar 2019 an der Universitätsbibliothek Tübingen\n",
    "\n",
    "Und Sie?\n",
    "- Wie heißen Sie?\n",
    "- Was studieren Sie?\n",
    "- Haben Sie schon einmal mit einer Programmiersprache gearbeitet? Wenn ja, mit welcher/welchen?\n",
    "- Warum belegen Sie diesen Kurs?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Termine\n",
    "\n",
    "|Oktober|November|Dezember|Januar|Februar|\n",
    "|:-|:-|:-|:-|:-|\n",
    "|16|6|11|8|5|\n",
    "|23|20|18|15||\n",
    "|30|||20||\n",
    "||||||"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Leistungen\n",
    "\n",
    "- Anwesenheit\n",
    "- Mehrere kleine Übungen\n",
    "- Kleines Datenanalyseprojekt am Ende des Semesters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sprechstunde\n",
    "\n",
    "- Nach Absprache"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Geplante Themen\n",
    "\n",
    "- Was ist Python?\n",
    "- Einführung in die Arbeitsumgebung\n",
    "- Grundlagen:\n",
    "  - Variablen\n",
    "  - Datenstrukturen\n",
    "  - Kontrollstrukturen\n",
    "  - Funktionen\n",
    "- Interaktive Dokumente mit Jupyter Notebook\n",
    "- Datenanalyse und -visualisierung\n",
    "- GUI-Programmierung"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python: Die Geschichte\n",
    "\n",
    "- Ab 1989 von dem niederländischen Programmierer Guido van Rossum entwickelt\n",
    "- Python 1.0 (Erste Vollversion): Januar 1994\n",
    "- Python 2.0: Oktober 2000\n",
    "- Python 3.0: Dezember 2008\n",
    "- Python 2.7.16 (Letzte 2.x Version): März 2019\n",
    "- Python 3.7: Juni 2018\n",
    "\n",
    "**Übrigens:** Mehr zur Entwicklungsgeschichte von Python erfahren Sie in dem Vorwort, das Guido van Rossum zur ersten Auflage von *Programming Python* (Mark Lutz, O'Reilly, 1996) geschrieben hat. Sie können es frei zugänglich unter [https://www.python.org/doc/essays/foreword](https://www.python.org/doc/essays/foreword) finden."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python: Der Name\n",
    "\n",
    "Python wurde nach der britischen Komikergruppe Monty Python benannt.\n",
    "\n",
    "![Monty Python. Quelle: Wikipedia](monty_python.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Warum Python?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Warum nicht?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Warum Python?\n",
    "\n",
    "- Python ist eine höhere Programmiersprache, das heißt, es ist leichter für Menschen zu verstehen, muss aber erst für Maschinen übersetzt werden. Bei Python wird diese Übersetzung von einem *Interpreter* übernommen.\n",
    "- Ein Ziel bei der Entwicklung war es, Python möglichst einfach und übersichtlich zu gestalten, was es zu einer guten Sprache für Programmieranfänger macht.\n",
    "- Python hat eine sehr klare Syntax, was die Lesbarkeit erleichtert."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Warum Python?\n",
    "\n",
    "- Wie viele andere Sprachen auch kann Python durch Pakete erweitert werden. Es ist deshalb sehr flexibel und leistungsfähig.\n",
    "- Es gibt eine sehr große und aktive Nutzergemeinde und Python ist eine der wichtigsten Sprachen in Forschung und Wirtschaft."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Ranglisten für Programmiersprachen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "|Rang|Sprache|\n",
    "|:-|:-|\n",
    "|1.-2.|Java / C|\n",
    "|3.|**Python**|\n",
    "|4.-10.|C++ / C# / Visual Basic .NET / Javascript / PHP / Objective-C|\n",
    "|11.-20.|SQL / Ruby / MATLAB / Groovy / Delphi/Objective Pascal / Assembly / Visual Basic / Go / Swift / Perl / R|\n",
    "\n",
    "TIOBE Index August 2019. Quelle: [https://www.tiobe.com/tiobe-index/](https://www.tiobe.com/tiobe-index/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "|Rang|Sprache|\n",
    "|:-|:-|\n",
    "|1.-2.|JavaScript / Java|\n",
    "|3.|**Python**|\n",
    "|4.-10.|PHP / C++ / C# / CSS / Ruby / TypeScript / Swift|\n",
    "|11.-20.|Objective-C / Scala / Shell / R / Go / PowerShell / Perl / Haskell / Kotlin|\n",
    "\n",
    "RedMonk Programming Language Ranking Juni 2019. Quelle: [https://redmonk.com/sogrady/2019/07/18/language-rankings-6-19/](https://redmonk.com/sogrady/2019/07/18/language-rankings-6-19/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python 2 oder Python 3?\n",
    "\n",
    "- Seit dem Erscheinen von Python 3 Ende 2008 wurden zwei Versionen von Python weiterentwickelt: Python 2 und Python 3. Die Entscheidung, welche Version man verwenden sollte, hing oft davon ab, ob benötigte Pakete schon für Python 3 erhältlich waren.\n",
    "- Die Zeit für Python 2 läuft jetzt aus: Ab dem 1.1.2020 wird es nicht mehr weiterentwickelt werden\n",
    "(siehe dazu auch [https://pythonclock.org](https://pythonclock.org)).\n",
    "- Wir werden uns deshalb auf Python 3 konzentrieren."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python: Voraussetzungen\n",
    "\n",
    "- Um mit Python arbeiten zu können, muss es auf Ihrem Computer installiert sein, was bei macOS und Linux-basierten Betriebssystemen normalerweise schon der Fall ist. Windows-Nutzer können es seit 2019 über den Microsoft-Store installieren oder von der [Python-Seite](https://www.python.org) herunterladen.\n",
    "- Am einfachsten geht die Installation aber über ein Programm wie [Anaconda](https://www.anaconda.com/distribution/#download-section), mit dem Sie nicht nur Python, sondern auch Jupyter Notebook, unser Hauptwerkzeug in diesem Kurs, installieren können."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Editoren: Wichtige Funktionen\n",
    "\n",
    "Grundsätzlich kann man Python-Code in jedem Texteditor schreiben, selbst in so einfachen Anwendungen wie etwa Notepad in Windows. Sie bekommen hierbei aber nur ein Grundmaß an Funktionalität. Besser sind hier Editoren, die einige Zusatzfunktionen anbieten wie etwa:\n",
    "\n",
    "- Automatischer Zeileneinzug (*Auto Indentation*, dazu später mehr)\n",
    "- Codevervollständigung (*Code Completion*): Man tippt die ersten Buchstaben etwa eines Funktionsnamens, und der Editor zeigt dann einen oder mehrere Vorschläge an.\n",
    "- Syntaxhervorhebung (*Syntax Highlighting*): <span style=\"color:red;\">Unterschiedliche syntaktische</span> <span style=\"color:blue;\">Elemente</span> <span style=\"color:green;\">haben</span> <span style=\"color:red;\">unterschiedliche</span> <span style=\"color:blue;\">Farben</span>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Editoren: Beispiele\n",
    "\n",
    "Wenn Sie sich Python von der Python-Seite heruntergeladen und installiert haben, dann haben Sie auch IDLE (**I**ntegrated **L**earning and **D**evelopment **E**nvironment), einen (sehr) einfachen Editor, mit dem Sie Python-Code schreiben und ausführen lassen können.\n",
    "\n",
    "Weitere gute Werkzeuge sind:\n",
    "- [Notepad++](https://notepad-plus-plus.org): Klein, aber leistungsfähig. Kostenlos. Nur Windows.\n",
    "- [Sublime Text](https://www.sublimetext.com): Sehr leistungsfähig. Zeitlich unbegrenzter Test möglich. Windows, macOS, Linux.\n",
    "- [Atom](https://atom.io): Sehr leistungsfähig. Kostenlos. Windows, macOS, Linux.\n",
    "- [Spyder](https://www.spyder-ide.org): Sehr leistungsfähig. Auf Python spezialisiert. Kostenlos. Kann über Anaconda installiert werden.\n",
    "- [PyCharm](https://www.jetbrains.com/pycharm/): Sehr leistungsfähig. Auf Python spezialisiert. Kostenlose Community Edition oder kostenlose Studentenlizenz für PyCharm Professional."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Editoren: Jupyter Notebook\n",
    "\n",
    "Hier werden wir [Jupyter Notebook](https://jupyter.org) verwenden, das über Anaconda installiert werden kann. Die mit diesem Programm geschaffenen Notebooks sind in der Wissenschaft und Lehre sehr populär geworden, da sie in einem Dokument Code, Visualisierungen und formattierten Text enthalten und in mehrere Formate exportiert werden können.\n",
    "\n",
    "Wenn Sie Veränderungen am Code oder einem eingebundenen Datensatz vornehmen, müssen Sie das Notebook nur ausführen lassen, um alles auf den neuesten Stand zu bringen.\n",
    "\n",
    "Notebooks können auch Code in anderen Sprachen beinhalten (der Name setzt sich aus den drei Programmiersprachen **Ju**lia, **Pyt**hon und **R** zusammen), sie lassen sich leicht mit anderen teilen und ermutigen zum Experimentieren."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Editoren: Jupyter Notebook\n",
    "\n",
    "Jupyter Notebook läuft, wie auch sein bereits erhältlicher Nachfolger JupyterLab, als eine Anwendung in Ihrem Browser. In diesem Fall werden aber keine Daten mit einem externen Server ausgetauscht. Stattdessen startet Jupyter Notebook zu Beginn jeder Sitzung einen Server auf Ihrem Computer: daher auch das Befehlszeilenfenster, das Sie sehen, kurz bevor der Browser geöffnet wird und das Sie nicht schließen dürfen. Alle Operationen finden also auf Ihrem Computer statt!\n",
    "\n",
    "Wenn Sie wollen, können Sie Jupyter Notebooks aber auch in der \"Cloud\" ausführen lassen. Dazu eignen sich Dienste wie etwa [binder](https://mybinder.org)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Was ist ein Notebook?\n",
    "\n",
    "Ein Notebook besteht aus einzelnen Zellen (oder *cells*), die ähnlich einer Folie in einer Präsentation funktionieren. Zellen dienen dazu, das Notebook zu strukturieren und erlauben es Ihnen, entweder das ganze Notebook oder nur Teile ausführen zu lassen. Sie können nachträglich auch leicht verschoben werden. Für jede Zelle können Sie einen von drei Inhaltstypen wählen:\n",
    "\n",
    "- Code: Python-Code, der in der Zelle ausgeführt werden kann.\n",
    "- Markdown\n",
    "- Raw NBConvert: Damit können Zellen beim Export in bestimmte Formate unterdrückt werden."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Was ist Markdown?\n",
    "\n",
    "Markdown ist eine Auszeichnungssprache (**markup language**)--wie etwa auch HTML--die es erlaubt, mit sehr wenig Aufwand Dokumente zu strukturieren und sie dann mit der passenden Software in verschiedene Formate umzuwandeln.\n",
    "\n",
    "Mit Jupyter Notebook können Sie etwa Markdown-Dokumente in HTML (für Onlinedokumentation), Präsentationen, PDFs oder LaTeX (für hochwertige Druckvorlagen) umwandeln."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Textformatierung in Markdown\n",
    "\n",
    "|Syntax | Darstellung|\n",
    "|:-|:-|\n",
    "|`*kursiv*`, `_kursiv_`|*kursiv*, _kursiv_|\n",
    "|`*fett*`, `__fett__`|**fett**, __fett__|\n",
    "|`~~durchgestrichen~~`|~~durchgestrichen~~|\n",
    "|endash: `--`|endash: --|\n",
    "|emdash: `---`|emdash: ---|\n",
    "|Ellipse: `...`| Ellipse: ...|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Horizontale Linie\n",
    "\n",
    "Mit `***` fügen Sie eine horizontale Linie ein:\n",
    "\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Überschriften\n",
    "\n",
    "Sie erstellen eine Überschrift, indem Sie dem Text ein bis sechs `#` voranstellen. Die wichtigsten Überschriften haben nur ein `#`; je weiter sie untergeordnet sind, desto mehr `#` haben sie.\n",
    "\n",
    "# Überschrift 1 `# Überschrift 1`\n",
    "## Überschrift 2 `## Überschrift 2`\n",
    "### Überschrift 3 `### Überschrift 3`\n",
    "#### Überschrift 4 `#### Überschrift 4`\n",
    "##### Überschrift 5 `##### Überschrift 5`\n",
    "###### Überschrift 6 `###### Überschrift 6`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Formeln\n",
    "\n",
    "Wenn Sie  eine Formel in den Text integrieren wollen, setzen Sie ein `$` an den Anfang und das Ende der Formel:\n",
    "\n",
    "|Syntax|Darstellung|\n",
    "|:-|:-|\n",
    "|Eine Formel: `$A = \\pi*r^{2}$` |Eine Formel: $A = \\pi*r^{2}$|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Links\n",
    "\n",
    "Links können folgendermaßen eingefügt werden:\n",
    "\n",
    "```[Link zu Python Seite](https://www.python.org/)```\n",
    "\n",
    "Der Text in eckigen Klammern wird dann im Dokument dargestellt und kann angeklickt werden. In den runden Klammern steht die URL:\n",
    "\n",
    "[Link zu Python Seite](https://www.python.org/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Bilder\n",
    "\n",
    "Markdown für Bilder funktioniert fast so wie bei Links, nur dass Sie vorher noch ein Ausrufezeichen benötigen:\n",
    "\n",
    "```![Optionale Bildunterschrift](monty_python.jpg)```\n",
    "\n",
    "![Optionale Bildunterschrift](monty_python.jpg)\n",
    "\n",
    "### Blockzitate\n",
    "\n",
    ">Für ein Blockzitat beginnen Sie die Zeile mit einem >. Auf diese Weise können Sie längere Zitate optisch hervorheben."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Listen\n",
    "\n",
    "Markdown bietet Ihnen zwei verschiedene Arten von Listen (geordnet und ungeordnet), die Sie auch schon von Textverarbeitungsprogrammen kennen. \n",
    "\n",
    "#### Geordnete Listen\n",
    "\n",
    "Bei geordneten Listen müssen Sie die Nummerierung nicht selbst vornehmen. Sie können immer die gleiche Zahl eingeben; solange danach ein Punkt folgt, erfolgt bei der Konvertierung in das Zielformat die korrekte Nummerierung. Bei den Einrückungen müssen Sie darauf achten, dass Sie immer die gleiche Anzahl von Leerzeichen verwenden."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "##### Markup\n",
    "\n",
    "```\n",
    "1. Nummer 1  \n",
    "1. Nummer 2  \n",
    "    1. Nummer 2.1  \n",
    "    1. Nummer 2.2  \n",
    "        1. Nummer 2.2.1  \n",
    "        1. Nummer 2.2.2  \n",
    "    1. Nummer 2.3  \n",
    "1. Nummer 3\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "##### Darstellung\n",
    "\n",
    "1. Nummer 1\n",
    "1. Nummer 2\n",
    "    1. Nummer 2.1\n",
    "    1. Nummer 2.2\n",
    "        1. Nummer 2.2.1\n",
    "        1. Nummer 2.2.2\n",
    "    1. Nummer 2.3\n",
    "1. Nummer 3\n",
    "\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Ungeordnete Listen\n",
    "\n",
    "Bei ungeordneten Listen können Sie das gleiche Zeichen verwenden (Minus funktioniert gut), solange Sie immer die gleiche Anzahl von Leerzeichen pro Stufe verwenden.\n",
    "\n",
    "***\n",
    "\n",
    "##### Markup\n",
    "\n",
    "```\n",
    "- Stufe 1  \n",
    "    - Stufe 2  \n",
    "        - Stufe 3  \n",
    "    - Stufe 2  \n",
    "- Stufe 1\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "##### Darstellung\n",
    "\n",
    "- Stufe 1\n",
    "    - Stufe 2\n",
    "        - Stufe 3\n",
    "    - Stufe 2\n",
    "- Stufe 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Tabellen\n",
    "\n",
    "Tabellen lassen sich mit Markdown sehr leicht erstellen. Sie müssen nur drei Sachen beachten:\n",
    "\n",
    "- Spalten werden mit | getrennt. Um den Markdowntext lesbarer zu machen, können Sie zwischen Text und | auch Leerzeichen einfügen.\n",
    "- Nach der ersten Reihe mit den Spaltennamen müssen Sie eine Zeile einfügen, in der für jede Spalte mindestens ein Minuszeichen steht. Diese werden dann auch wieder mit | getrennt.\n",
    "- Normalerweise ist der Text in Tabellenzellen rechtsbündig ausgerichtet. Um ihn zu zentrieren, setzen Sie vor und hinter das Minuszeichen jeweils einen Doppelpunkt `:-:`. Für eine linksbündige Ausrichtung benötigen Sie nur vor dem Minuszeichen einen Doppelpunkt."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Markup\n",
    "\n",
    "```\n",
    "|Spalte 1|Spalte 2|Spalte 3|  \n",
    "|:-|:-:|-:|\n",
    "|Reihe 1, Spalte 1|Reihe 1, Spalte 2|Reihe 1, Spalte 3|  \n",
    "|Reihe 2, Spalte 1|Reihe 2, Spalte 2|Reihe 2, Spalte 3|\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Darstellung\n",
    "\n",
    "|Name Spalte 1|Name Spalte 2|Name Spalte 3|\n",
    "|:-|:-:|-:|\n",
    "|Reihe 1, Spalte 1|Reihe 1, Spalte 2|Reihe 1, Spalte 3|\n",
    "|Reihe 2, Spalte 1|Reihe 2, Spalte 2|Reihe 2, Spalte 3|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Resultate in Markdown Integrieren\n",
    "\n",
    "Mithilfe der \"Python Markdown\"-Erweiterung können Sie sich die Ergebnisse von bereits ausgeführtem Code in einer Markdown-Zelle anzeigen lassen. Die Erweiterung kann auf der Startseite von Jupyter Notebook unter \"Nbextensions\" aktiviert werden."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Zuerst benötigen Sie etwas Python-Code in einer Code-Zelle, wie etwa die folgende Zeile, in der wir die beiden Zahlen 1 und 2 addieren. Das Ergebnis wird dann mit dem Gleichheitszeichen der Variable \"a\" zugewiesen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = 1 + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Integrieren Sie dann den Wert in den Text, indem Sie den Variablennamen an der gewünschten Stelle einfügen und in doppelte geschweifte Klammern setzen: {&zwnj;{a}&zwnj;}. Wenn Sie jetzt auf die Schaltfläche mit den nach rechts deutenden Pfeilen klicken (\"Vorspulsymbol\"), wird dann an der entsprechenden Stelle die Zahl {{a}} angezeigt."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python: Einrückungen\n",
    "\n",
    "Viele Programmiersprachen verwenden Schlüsselwörter oder Klammern, um Code in Blöcken zu organisieren. Solche Blöcke können beispielsweise Schleifen sein, in denen man die gleiche Operation für jeden Bestandteil einer Sammlung von Werten ausführen lässt. Hier ist ein Beispiel in R: Es gibt die Zahlen von eins bis zehn nacheinander aus:\n",
    "\n",
    "```r\n",
    "for(i in 1:10){\n",
    "    print(i)\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Da R Klammern verwendet um den Code zu strukturieren, könnte man das ganze Stück auch linksbündig (und/oder in einer einzigen Zeile) schreiben und es würde immer noch funktionieren:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```r\n",
    "for(i in 1:10) {print(i)}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Für Python jedoch sind solche Einrückungen nötig, denn sonst kann es die Rang- und Reihenfolge der verschiedenen Codesegmente nicht korrekt bewerten. Auch muss die Anzahl der Einrückungen pro Code-Level konstant bleiben. Normalerweise verwendet man vier:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 11):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Dadurch, dass Blöcke eingerückt und weniger Klammern verwendet werden, wird der Code leichter lesbar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Fortsetzung folgt..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Hello World!\n",
    "\n",
    "Seit seiner ersten öffentlichen Verwendung in dem 1978 erschienenen Programmierhandbuch *Programmieren in C* (*Programming in C*) von  Brian Kernighan und Dennis Ritchie ist es eine Tradition geworden, dass das erste Programm, dass ProgrammiererInnen in einer neuen Sprache schreiben, die Worte \"Hello World!\" ausgibt.\n",
    "\n",
    "**Übrigens:** Auf der Seite [http://helloworldcollection.de](http://helloworldcollection.de) finden Sie \"Hello World!\"-Programme in mehreren hundert Sprachen.\n",
    "\n",
    "Versuchen Sie es also! Geben Sie den Text `print(\"Hello World!\")` in die nächste Zelle ein und klicken dann auf Run:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Hello World! - Was Passiert Hier?\n",
    "In dieser kurzen Zeile sehen wir bereits einige wichtige Aspekte von Python und auch anderen Programmiersprachen sowie einen der augenfälligsten Unterschiede zwischen Python 2 und Python 3:\n",
    "\n",
    "- Es gibt **Funktionen**. Funktionen erlauben es Ihnen, Code für eine bestimmte Aufgabe zu schreiben und diesen dann immer wieder zu verwenden. Viele Funktionen haben **Parameter**, d.h., Sie können Objekte wie etwa die Phrase \"Hello World!\" oder eine Zahl als **Argumente** an die Funktion weitergeben und von der bearbeiten lassen. Man kann die bereits in Python integrierten Funktionen nutzen oder eigene Funktionen schreiben."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Hello World! - Was Passiert Hier?\n",
    "\n",
    "- Es gibt verschiedene **Datentypen**. \"Hello World!\" ist eine **Zeichenkette** (*character string*), also eine Abfolge von Buchstaben, Leerzeichen, Satzzeichen, oder auch Ziffern. Es steht deshalb in Anführungszeichen, während etwa eine Zahl wie 12345 ohne Anführungszeichen auskommt.\n",
    "- In Python 3 ist `print` eine Funktion und der auszugebende Text steht in Klammern. In Python 2 war `print` eine **Anweisung** und verwendete deshalb keine Klammern: `print \"Hello World!\"`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Schlüsselwörter (*keywords*)\n",
    "\n",
    "|&nbsp;|||||\n",
    "|:-|:-|:-|:-|:-|\n",
    "|and|del|for|is|raise| \n",
    "|assert|elif|from|lambda|return|\n",
    "|break|else|global|not|try|\n",
    "|class|except|if|or|while|\n",
    "|continue|exec|import|pass|yield|\n",
    "|def|finally|in|print||"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}