{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python Einführungskurs für das Physikalische Anfängerpraktikum der Universität Heidelberg | [Startseite](index.ipynb)\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 101 - Grundlagen der Programmierung in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- [Aufgabe 1 - Werte und Typen](#Aufgabe-1---Werte-und-Typen)\n",
    "- [Strings](#Strings)\n",
    "- [Aufgabe 2 - Strings und Dokumentation](#Aufgabe-2---Strings-und-Dokumentation)\n",
    "- [Aufgabe 3 - String Formatierung](#Aufgabe-3---String-Formatierung)\n",
    "- [Listen und Tupel](#Listen-und-Tupel)\n",
    "- [Slicing](#Slicing)\n",
    "- [Dictionaries](#Dictionaries)\n",
    "- [Aufgabe 4 - Dictionaries](#Aufgabe-4---Dictionaries)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Programmieren besteht aus einer Aneinanderreihung von Befehlen, die der Python Interpreter ausführt. Ein einfacher Befehl ist die Zuweisung eines Wertes zu einer **Variablen**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1\n",
    "# Diese Zelle auswählen und mit `<SHIFT> + <ENTER>` ausführen.\n",
    "# Der letzte Rückgabewert der Zelle wird dann unten ausgegeben,\n",
    "# hier also der Wert von `x`:\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Hinweis:** Dieses Kursmaterial besteht aus interaktiven [Jupyter Notebooks](http://jupyter.org). Jede _Zelle_, wie die obige, könnt ihr per Klick oder mit den Pfeiltasten auswählen und mit `<SHIFT> + <ENTER>` ausführen. Probiert's mal mit der Zelle oben!\n",
    "> \n",
    "> **Geht, um dem Kurs zu folgen, _alle_ Zellen nacheinander durch und führt sie aus.**\n",
    ">\n",
    "> Wie hier demonstriert gibt das Jupyter Notebook immer den letzten Rückgabewert einer Zelle aus. Wir können auch die `print()` Funktion verwenden, um Ausgaben zu generieren:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Der **Wert** der Variable `x` ist nun der Integer `1`. Werte haben immer einen **Typ** wie\n",
    "\n",
    "- `int` für ganze Zahlen, z.B. `1`, `42`, `-10`,\n",
    "- `float` für Fließkommazahlen, z.B. `0.5`, `3.14`, `1e10`,\n",
    "- `str` für Zeichenketten (_Strings_), z.B. `\"Hello World!\"`,\n",
    "- `boolean` für Wahrheitswerte (_Booleans_), also `True` und `False`\n",
    "\n",
    "> Die Typen der Python Standardlibrary findet ihr in der [Dokumentation](https://docs.python.org/3/library/stdtypes.html).\n",
    "\n",
    "Da Variablen in Python nicht typisiert sind, können der gleichen Variable nacheinander Werte verschiedener Typen zugewiesen werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 0.5\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Weiterhin können Werte in einen anderen Typ konvertiert werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = int(0.5) # Bei der Konvertierung zu int wird immer abgerundet!\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die grundlegenden Rechenoperationen `+`, `-`, `*`, `/` und `**` sind ebenfalls in Python verfügbar und verhalten sich, wie man es erwartet:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 + 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 / 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Hinweis zu Python 2.x:** Die Division zweier Integer gab vor Python 3 wieder einen abgerundeten Integer zurück, im obigen Beispiel also `3 / 2 = int(1.5) = 1`. Damit sich die Division mit Python 2.x stattdessen wie in Python 3 verhält, kann diese zu Beginn des Skripts importiert werden:\n",
    "> \n",
    "> ```python\n",
    "> from __future__ import division\n",
    "> ```\n",
    "> \n",
    "> Die Integer Division ist außerdem in Python 3 als Operator `//` verfügbar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 // 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aufgabe 1 - Werte und Typen\n",
    "\n",
    "Der Operator zur Potenzierung ist in Python `**`. Weise einer Variablen `y` folgende Werte zu und lasse dir dann ihren Wert und Typ ausgeben. Stimmen Wert und Typ mit deinen Erwartungen überein?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a) $4^3$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Hinweis:** Dies ist eine Übungsaufgabe. Verwende die Zelle unten, um sie zu lösen. **Entferne** dazu den Platzhalter-Code\n",
    ">\n",
    "> ```python\n",
    "> # DEINE LÖSUNG HIER\n",
    "> ```\n",
    ">\n",
    "> und schreibe stattdessen den Code zur Lösung der Aufgabe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "101-1a-sol",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "y = 4**3\n",
    "y, type(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Hinweis:** Auf die Lösung jeder Aufgabe folgt eine Test-Zelle wie die folgende, mit der du deine Lösung überprüfen kannst. Führe einfach diese Zelle aus. Wenn etwas an deiner Lösung nicht stimmt, erhälst du eine Fehlermeldung mit Hinweisen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "101-1a-test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from nose.tools import assert_equal\n",
    "try:\n",
    "    y\n",
    "except NameError:\n",
    "    raise NameError(\"Es gibt keine Variable 'y'. Weise den Wert einer Variablen mit diesem Namen zu.\")\n",
    "assert_equal(y, 64, \"Die Variable hat nicht den richtigen Wert. Überprüfe deine Rechnung.\")\n",
    "print(\"👍 Sehr gut!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "b) $2+3.4^2$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "101-1b-sol",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "y = 2 + 3.4**2\n",
    "y, type(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "101-1b-test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from nose.tools import assert_equal\n",
    "try:\n",
    "    y\n",
    "except NameError:\n",
    "    raise NameError(\"Es gibt keine Variable 'y'. Weise den Wert einer Variablen mit diesem Namen zu.\")\n",
    "assert_equal(y, 2 + 3.4**2, \"Die Variable hat nicht den richtigen Wert. Überprüfe deine Rechnung.\")\n",
    "print(\"Ok, du hast es verstanden.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings sind **Zeichenketten** wie:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"Hello World\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "und werden in Python vom Typ `str` repräsentiert. Um einen String zu erstellen können wir einzelne (`'`), doppelte (`\"`) oder dreifache (`'''` oder `\"\"\"`, für mehrzeilige Strings) Anführungszeichen verwenden, sodass das jeweils andere Anführungszeichen im String verwendet werden kann:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s.count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"I'm\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternativ können Steuerzeichen im String auch _escaped_ werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Say \\\"hi\\\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings sind Reihen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Da Strings eine Aneinanderreihung von Elementen (in diesem Fall Textzeichen) darstellen, können viele Funktionen mit Strings verwendet werden, die mit **Reihen** arbeiten. Dazu gehören:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(s) # gibt die Zahl der Reihenelemente zurück"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[0] # gibt das Element der Reihe an der Stelle 0 zurück"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s + \"!\" # Reihen können kombiniert werden"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings sind Objekte"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die meisten \"Dinge\" in Python sind **Objekte**, d.h. neben ihrem Typ besitzen sie assoziierte **Attribute** und **Methoden**, auf die über einen Punkt `.` zugegriffen werden kann. Neben Strings sind bspw. auch Werte der anderen schon bekannten Datentypen wie `int(5)` und sogar Funktionen und die Datentypen selbst Objekte.\n",
    "\n",
    "Ein Attribut eines Objekts ist eine Variable, die gelesen und gesetzt werden kann, wie bspw. `x.shape`. Eine Methode ist eine Funktion, die das Objekt zur Verfügung stellt, wie `x.min()`.\n",
    "\n",
    "Einige Beispiele für Methoden, die Strings zur Verfügung stellen, sind:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s.index('World')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Hinweis:** In Jupyter Notebooks können wir die **`<TAB>`-Vervollständigung** verwenden um die assoziierten Attribute und Methoden eines Objekts zu inspizieren:\n",
    ">\n",
    "> ```python\n",
    "> s = \"Hello World\"\n",
    "> # Zelle ausführen, dann:\n",
    "> s.<TAB> # `s.` tippen und die <TAB>-Taste drücken\n",
    "> ```\n",
    ">\n",
    "> Dies zeigt die verfügbaren Attribute und Methoden des Strings `s` an. Die `<TAB>`-Vervollständigung für eine Variable funktioniert erst nachdem die Variable erstellt wurde, also die Zelle einmal ausgeführt wurde.\n",
    ">\n",
    "> Um herauszufinden, was eine Funktion oder Methode tut, könnt ihr im Jupyter Notebook ein Fragezeichen `?` verwenden:\n",
    ">\n",
    ">```python\n",
    ">In [1]: s.split?\n",
    ">```\n",
    ">```markdown\n",
    ">Docstring:\n",
    ">S.split(sep=None, maxsplit=-1) -> list of strings\n",
    ">\n",
    ">Return a list of the words in S, using sep as the\n",
    ">delimiter string.  If maxsplit is given, at most maxsplit\n",
    ">splits are done. If sep is not specified or is None, any\n",
    ">whitespace string is a separator and empty strings are\n",
    ">removed from the result.\n",
    ">Type:      builtin_function_or_method\n",
    ">```\n",
    ">\n",
    "> Schreibt ihr stattdessen zwei Fragezeichen `??` zeigt das Jupyter Notebook die gesamte Definition der Funktion oder Methode an.\n",
    ">\n",
    "> **Verwendet die `<TAB>`-Vervollständigung und die `?`-Dokumentation häufig um hilfreiche Attribute und Methoden zu finden und zu verstehen!**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aufgabe 2 - Strings und Dokumentation\n",
    "\n",
    "Finde im folgenden String mithilfe einer Methode, wie häufig der Buchstabe `\"A\"` auftaucht und weise den Wert einer Variable `n` zu. Probiere die `<TAB>`-Vervollständigung und die `?`-Dokumentation aus um eine passende Methode zu finden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "101-2-sol",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "s = \"CAGTACCAAGTGAAAGAT\"\n",
    "### BEGIN SOLUTION\n",
    "n = s.count(\"A\")\n",
    "### END SOLUTION\n",
    "print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "101-2-test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from nose.tools import assert_equal\n",
    "try:\n",
    "    y\n",
    "except NameError:\n",
    "    raise NameError(\"Es gibt keine Variable 'n'. Weise den Wert einer Variablen mit diesem Namen zu.\")\n",
    "assert_equal(n, 8, \"Das ist nicht die richtige Anzahl. Versuch's mal mit der `count` Methode!\")\n",
    "print(\"Klappt!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String-Formatierung\n",
    "\n",
    "Eine wichtige Methode ist `str.format()`, die markierte Platzhalter im String mit Werten ersetzt, die der Methode übergeben werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10\n",
    "\"Der Wert von x ist {}\".format(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ein Platzhalter wird durch eine öffnende `{` und schließende `}` geschweifte Klammer begrenzt und kann eine Bezeichnung des Platzhalters sowie Formatierungsoptionen beinhalten:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"{raw_value} ist gerundet {rounded_value:.3f}.\".format(raw_value=2/3, rounded_value=2/3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Hinweis:** Die vollständige Syntax der String-Formatierung ist in der [Dokumentation](https://docs.python.org/2/library/string.html#format-string-syntax) einzusehen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aufgabe 3 - String Formatierung\n",
    "\n",
    "Schreibe deinen Namen in die Variable `name`. Verwende dann die `format` Methode um aus `s` und `name` den Gruß `\"Hello World, mein Name ist __DEIN_NAME__!\"` zusammenzusetzen. Weise den zusammengesetzten String der Variable `greeting` zu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "101-3-sol",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "s = \"Hello World\"\n",
    "name = \"__DEIN_NAME__\"\n",
    "### BEGIN SOLUTION\n",
    "greeting = s + \", mein Name ist {name}!\".format(name=name)\n",
    "### END SOLUTION\n",
    "print(greeting)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "101-3-test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from nose.tools import assert_in\n",
    "try:\n",
    "    greeting\n",
    "except NameError:\n",
    "    raise NameError(\"Es gibt keine Variable 'greeting'. Weise den Wert einer Variablen mit diesem Namen zu.\")\n",
    "assert_in(\"mein Name ist\", greeting)\n",
    "print(\"Hello {}! 👋\".format(name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Listen und Tupel\n",
    "\n",
    "Während Strings einzelne Zeichen aneinanderreihen, repräsentieren **Listen** und **Tupel** eine Reihe _beliebiger_ Werte. Die Elemente einer Liste können verändert werden, während ein Tupel unveränderlich ist. Wir können Listen erstellen, indem wir die Elemente durch Kommata getrennt in eckigen Klammern `[` und `]` angeben, und Tupel durch die Verwendung runder Klammern `(` und `)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [ 4, 0.5, \"Alice\" ]\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = ( \"Bob\", True )\n",
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Auch Listen und Tupel sind Reihen\n",
    "\n",
    "Wie bei jeder Reihe können wir die Anzahl der Elemente bestimmen und auf einzelne Elemente über ihren Index zugreifen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(l), len(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l[0] # Indexierung beginnt in Python mit dem Index 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Listen sind veränderlich"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Anders als Strings und Tupel können Listen jedoch verändert werden, indem Elemente verändert, hinzugefügt oder entfernt werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l[1] = -2.2 # Weise der Liste einen neuen Wert beim Index 1 zu\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l.append(-3) # Füge einen neuen Wert am Ende der liste hinzu\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l.pop() # Entfernt das letzte Element (bzw. das am angegebenen Index) aus der Liste und gibt es zurück"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slicing\n",
    "\n",
    "Du kannst mit der _Slicing_ Syntax auf Teile einer Reihe zugreifen:\n",
    "\n",
    "```python\n",
    "slice = list[start:stop:step]\n",
    "```\n",
    "\n",
    "Dabei bezeichnet `start` den ersten Index und `stop` den letzten nicht mehr enthaltenen Index des Abschnitts. Mit `step` kannst du eine Schrittweite angeben, in der die Reihe iteriert werden soll.\n",
    "\n",
    "Du musst nicht alle drei Argumente angeben. Per default ist dann `start=0`, `stop=len(list)` und `step=1`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l[:2] # Der erste Index ist per default start=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l[2:] # Der letzte Index ist per default das Ende der Reihe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l[::2] # Jedes zweite Element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l[::-1] # Umgekehrte Reihenfolge"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Hinweis:** Slicing ist ein mächtiges Werkzeug um kurzen, prägnanten Code zu schreiben und wird dir bei der Arbeit mit _Numpy Arrays_ ab Lektion [201 - Numerik mit Numpy](201 - Numerik mit Numpy.ipynb) noch sehr häufig begegnen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries\n",
    "\n",
    "Ein weiterer wichtiger Datentyp ist das **Dictionary**. Ein Dictionary ordnet jeweils einem _Key_ einen _Value_ zu und wird durch geschweifte Klammern `{` und `}` erstellt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = { 'a':1, 'b':2, 'c':3 }\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Auf einzelne Werte kann über ihren Key zugegriffen werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d['a']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries sind veränderlich wie Listen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d['d'] = 4\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es müssen nicht unbedingt Strings als Keys verwendet werden, und auch verschiedene Datentypen sind möglich:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e = { 'some_key': 4.2, 3517: 'some_value' }\n",
    "e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e['some_key']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e[3517]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aufgabe 4 - Dictionaries\n",
    "\n",
    "Schreibe ein Wörterbuch mit einigen deutschen Wörtern und ihrer Übersetzung ins Englische. Weise es der Variable `d` zu und verwende es dann, indem du dir einige Werte darin ausgeben lässt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "101-4-sol",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "### BEGIN SOLUTION\n",
    "d = {\n",
    "    \"Wörterbuch\": \"dictionary\"\n",
    "}\n",
    "### END SOLUTION\n",
    "d[\"Wörterbuch\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "101-4-test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "from nose.tools import assert_true\n",
    "try:\n",
    "    d\n",
    "except NameError:\n",
    "    raise NameError(\"Es gibt keine Variable 'd'. Weise den Wert einer Variablen mit diesem Namen zu.\")\n",
    "assert_true(len(d) > 0, \"Das Wörterbuch hat keine Einträge.\")\n",
    "print(\"Wow, {} Einträge im Wörterbuch!\".format(len(d)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "Du kannst nun mit Variablen und Datentypen umgehen und den Python Interpreter rechnen lassen. Lerne in der nächsten Lektion, wie du mit _Control Flow_ Anweisungen deine ersten Programme schreiben kannst.\n",
    "\n",
    "[Startseite](index.ipynb) | [**>> 102 - Control Flow**](102%20-%20Control%20Flow.ipynb)"
   ]
  }
 ],
 "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}