praesentation_2019_11_06.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": [
    "## Fragen\n",
    "\n",
    "Haben Sie Fragen zur letzten Sitzung?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Erklärung zur letzten Stunde\n",
    "\n",
    "In der letzten Stunde gab es ein Problem mit den folgenden Zeilen:\n",
    "\n",
    "```\n",
    "c = [1, 2, 8, 17, 5, 4]\n",
    "a = c.sort(reverse=True)\n",
    "```\n",
    "\n",
    "Wenn Sie sich a anzeigen lassen wollten, war es leer. Warum?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Erklärung zur letzten Stunde\n",
    "\n",
    "**sort** sortiert eine Liste *in-place*, d.h., es verändert die Originalliste und gibt None als Ergebnis zurück. Deshalb war a auch leer.\n",
    "\n",
    "Wenn man die Originalliste behalten und die sortierte Liste in einer neuen Variable haben möchte, kann man **sorted()** verwenden:\n",
    "\n",
    "```\n",
    "a = sorted(c, reverse=True)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Erklärung zur letzten Stunde\n",
    "\n",
    "Noch ein Punkt zur Sortierung:\n",
    "\n",
    "Geben Sie die folgende Liste in der Konsole ein und lassen sie sortieren:\n",
    "\n",
    "```\n",
    "c = [\"apfel\", \"Banane\", \"kirsche\"]\n",
    "```\n",
    "\n",
    "Welches Ergebnis bekommen Sie?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Erklärung zur letzten Stunde\n",
    "\n",
    "Sie sollten folgendes Ergebnis bekommen:\n",
    "\n",
    "```\n",
    "['Banane', 'apfel', 'kirsche']\n",
    "```\n",
    "\n",
    "In Python werden Großbuchstaben vor Kleinbuchstaben sortiert."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Erklärung zur letzten Stunde\n",
    "\n",
    "Wenn Sie möchten, dass die Werte in der Liste unabhängig von Groß/Kleinschreibung sortiert werden, verwenden Sie **sorted()** mit dem Parameter **key**. Mit **key** können Sie eine Funktion wählen, die den für die Sortierung verwendeten Wert generiert. Hier ist das **str.lower**, welche alle Groß- in Kleinbuchstaben umwandelt:\n",
    "\n",
    "```\n",
    "a = sorted(c, key=str.lower)\n",
    "a\n",
    "['apfel', 'Banane', 'kirsche']\n",
    "```\n",
    "\n",
    "**key** wirkt sich hier nicht auf den in der Liste gespeicherten Wert aus, nur darauf, wie er während der Sortierung behandelt wird."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Datenstrukturen: Listen\n",
    "\n",
    "Zurück zu den Listen:\n",
    "\n",
    "```\n",
    "a = ['banane', 'ananas', 'apfel', 'kirsche', 'apfel']\n",
    "```\n",
    "\n",
    "Listen gehören zu den veränderbaren, oder mutablen (*mutable*) Datentypen. Das bedeutet, dass sie nach ihrer Erzeugung verändert werden können. Im folgenden Beispiel wird das zweite Element der Liste a (\"ananas\") durch \"birne\" ersetzt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['banane', 'birne', 'apfel', 'kirsche', 'apfel']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = ['banane', 'ananas', 'apfel', 'kirsche', 'apfel']\n",
    "a[1] = 'birne'\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Datenstrukturen: Listen\n",
    "\n",
    "Sie können auch mehrere Werte auf einmal ändern. Im folgenden Beispiel werden der zweite und dritte Wert der Liste durch zwei andere Werte ersetzt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['banane', 'erbse', 'gurke', 'kirsche', 'apfel']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = ['banane', 'ananas', 'apfel', 'kirsche', 'apfel']\n",
    "a[1:3] = ['erbse', 'gurke']\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Datenstrukturen: Listen\n",
    "\n",
    "Schließlich können Sie Schrittweiten angeben, so dass nicht jeder Wert in der angebenen Spanne geändert wird, sondern immer ein, zwei, usw. Werte ausgelassen werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['erbse', 'gurke', 'tomate']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = ['banane', 'ananas', 'apfel', 'kirsche', 'apfel']\n",
    "a[0:6] = ['erbse', 'gurke', 'tomate']\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Datenstrukturen: Listen\n",
    "\n",
    "Mit **append()** können Sie einzelne Werte an eine Liste anfügen. Falls mehrere Werte (etwa aus einer anderen Liste) dazukommen sollen, verwenden Sie **extend()**: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['banane', 'ananas', 'apfel', 'kirsche', 'apfel', 'erbse', 'gurke', 'tomate']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = ['banane', 'ananas', 'apfel', 'kirsche', 'apfel']\n",
    "a.append('erbse')\n",
    "a\n",
    "a.extend(['gurke', 'tomate'])\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Datenstrukturen: Listen\n",
    "\n",
    "Wenn Sie zwei Listen zusammenfügen möchten, können Sie das auch mit dem **+**-Operator erreichen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1, 2]\n",
    "b = [3, 4]\n",
    "c = a + b\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Datenstrukturen: Listen\n",
    "\n",
    "So wie Sie bestimmte Werte aus einer Liste auswählen können, so können Sie auch einzelne oder mehrere Werte aus einer Liste löschen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apfel', 'gurke']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = ['banane', 'ananas', 'apfel', 'kirsche', 'apfel', 'erbse', 'gurke', 'tomate']\n",
    "del a[0] # Löscht ersten Wert. a hat jetzt 7 Werte.\n",
    "del a[1:3] # Löscht zweiten und dritten Wert. a hat jetzt 5 Werte.\n",
    "del a[0:5:2] # Löscht ersten, dritten, fünften usw. Wert. a hat jetzt 2 Werte.\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## And now to something (not) completely different...\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Datenstrukturen: Tuples\n",
    "\n",
    "Im Vergleich zu Listen haben *tuples* zwar eine ähnliche Struktur, bieten aber weniger Flexibilität, da sie unveränderbar (immutabel, *immutable*) sind. *Tuples* werden mit runden Klammern erzeugt. Werte in einem *tuple* können wieder über ihre Indexwerte adressiert werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'banane'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = ('banane', 'ananas', 'apfel', 'kirsche', 'apfel')\n",
    "a[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('banane', 'ananas', 'apfel')"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[0:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('banane', 'apfel', 'apfel')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[0:5:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Datenstrukturen: Tuples\n",
    "\n",
    "Was passiert, wenn Sie versuchen, einen Wert aus dem *tuple* zu löschen?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object doesn't support item deletion",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-11-c47830f0ae67>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mdel\u001b[0m \u001b[0ma\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object doesn't support item deletion"
     ]
    }
   ],
   "source": [
    "del a[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Datenstrukturen: Tuples\n",
    "\n",
    "Operationen, welche ein *tuple* verändern würden, führen zu Fehlermeldungen. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Datenstrukturen: Tuples\n",
    "\n",
    "Bei der Erzeugung eines *tuple* können Sie die runden Klammern auch weglassen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "person = 'karl', 'theodor', 'mustermann'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Dieser Vorgang heißt *Tuple Packing*. Beim *Tuple Unpacking* können Sie dann jeden der Werte im *tuple* einer Variablen zuweisen und so direkt aufrufen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "vorname, patenname, nachname = person"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'karl'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vorname"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Ein kleiner Exkurs: String-Formatierung\n",
    "\n",
    "Wenn Sie Werte, die Sie etwa in einer Liste oder einem *tuple* gespeichert haben, zu einem Satz zusammenfügen wollen, steht Ihnen die **join()**-Funktion zur Verfügung:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Das ist ein Satz'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = ['Das', 'ist', 'ein', 'Satz']\n",
    "b = \" \".join(a)\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Wenn Sie kein Trennzeichen angeben, werden die Werte ohne Unterbrechung zusammengesetzt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = ['https://', 'www', '.', 'uni-tuebingen', '.', 'de']\n",
    "b = \"\".join(a)\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## String-Formatierung\n",
    "\n",
    "Bei der Ausgabe von Werten kann man diese in strings einfügen, wie z.B. Sätze. Dazu bietet Python die **format()**-Funktion an. Dabei werden geschweifte Klammern {} als Platzhalter eingesetzt, die dann durch die Werte ersetzt werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Heute ist Mittwoch, der 6.11.2019.'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Heute ist {}, der {}.{}.{}.\".format(\"Mittwoch\", 6, 11, 2019)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## String-Formatierung\n",
    "\n",
    "Die Reihenfolge, in der die Werte dabei eingesetzt werden, richtet sich dabei erst einmal danach, wie sie an **format()** übergeben wurden. Sie können jedem Platzhalter auch einen Namen geben und die Werte dann dadurch adressieren:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Heute ist Mittwoch, der 6.11.2019.'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Heute ist {wochentag}, der {tag}.{monat}.{jahr}.\".format(wochentag=\"Mittwoch\", tag=6, monat=11, jahr=2019)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## String-Formatierung\n",
    "\n",
    "Soll das Ergebnis selbst geschweifte Klammern enthalten, verwenden Sie doppelte Klammern:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Das ist eine geschweifte Klammer{} und das ist eine runde Klammer().'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Das ist eine {g} {k}{{}} und das ist eine {r} {k}().\".format(g=\"geschweifte\", r=\"runde\", k=\"Klammer\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Wie Sie sehen, kann ein Platzhalter auch mehrere Male verwendet werden, wenn Sie ihm einen Namen zugewiesen haben."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## String-Formatierung\n",
    "\n",
    "Wenn Sie einen der eingefügten Werte noch ändern müssen (etwa eine Zahl runden), kann dies als Teil des Formatierungsprozesses geschehen. Hier etwa wird eine Zahl (mit Typ *float*) mit fünf Nachkommastellen auf zwei Nachkommastellen gerundet, um einen Eurobetrag angeben zu können:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Die durchschnittlichen Kosten betrugen 36.86 Euro.'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 36.85739\n",
    "\"Die durchschnittlichen Kosten betrugen {:.2f} Euro.\".format(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## String-Formatierung\n",
    "\n",
    "Um zu den Datenstrukturen zurückzukommen: Sie können auch Werte aus Listen und *tuples* in *strings* eingefügen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Heute ist Mittwoch, der 6.11.2019.'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datum = [\"Mittwoch\", 6, 11, 2019]\n",
    "\"Heute ist {l[0]}, der {l[1]}.{l[2]}.{l[3]}.\".format(l=datum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Datenstrukturen: Mengen\n",
    "\n",
    "Mengen, oder *sets*, haben die Eigenschaft, dass in ihnen jedes Element nur einmal vorkommen darf. Es gibt zwei verschiedene Methoden, um *sets* zu erzeugen:\n",
    "\n",
    "- **set()** erzeugt eine mutable Menge, d.h., eine Menge, die nachträglich verändert werden kann. Hier wird ein neues *set* mit Werten aus einem *tuple* befüllt, daher die doppelten runden Klammern."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a', 'b', 'c'}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = set(('a', 'b', 'c'))\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Datenstrukturen: Mengen\n",
    "\n",
    "- **frozenset()** erzeugt eine immutable Menge, d.h., sie kann nachträglich nicht mehr verändert werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "frozenset({'a', 'b', 'c'})"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = frozenset(('a', 'b', 'c'))\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Datenstrukturen: Mengen\n",
    "\n",
    "Was passiert, wenn Sie versuchen, mehrmals den gleichen Wert in ein *set* zu packen?\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5}"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = (1, 2, 2, 3, 4, 5, 5, 5, 5)\n",
    "b = set(a)\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Jeder Wert, der mehrfach vorhanden ist, wird auf eine Erwähnung reduziert."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Datenstrukturen: Mengen\n",
    "\n",
    "Ein anderes Experiment: Was passiert, wenn Sie versuchen, einmal ein *tuple* und dann eine Liste in ein Set einzufügen? Ein Beispiel:\n",
    "\n",
    "```\n",
    "a = set((1, (3, 4)))\n",
    "a = set((1, [3, 4]))\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-31-512112760dc8>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0ma\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m4\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0ma\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m4\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unhashable type: 'list'"
     ]
    }
   ],
   "source": [
    "a = set((1, (3, 4)))\n",
    "a = set((1, [3, 4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Datenstrukturen: Mengen\n",
    "\n",
    "Der Grund für die Fehlermeldung ist, dass *sets* keine mutablen Elemente, wie etwa Listen, enthalten können. *Tuples* verursachen keine Probleme, da sie immutabel sind.\n",
    "\n",
    "Dafür sind *sets* selbst aber mutabel, wenn sie mit **set()** und nicht mit **frozenset()** erzeugt wurden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5}"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = set((1, 2, 3, 4))\n",
    "a.add(5)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "b = set((4, 5, 6, 7, 8))\n",
    "b.discard(8)\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Operatoren und Methoden für Mengen\n",
    "\n",
    "|Operator|Beispiel|Erklärung|Werte|Äquivalente Methode|\n",
    "|:-|:-|:-|:-|:-|\n",
    "|in|x in a|Ist Wert x in Menge a?|*True*/*False*||\n",
    "|not in|x not in a|Ist Wert x nicht in Menge a?|*True*/*False*||\n",
    "|<=|a <= b|Ist a eine Teilmenge von b?|*True*/*False*|a.issubset(b)|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Operatoren und Methoden für Mengen\n",
    "\n",
    "|Operator|Beispiel|Erklärung|Werte|Äquivalente Methode|\n",
    "|:-|:-|:-|:-|:-|\n",
    "|<|a < b|Ist a eine echte Teilmenge von b, d.h., es gibt mindestens ein Element in b, das nicht in a ist|*True*/*False*||\n",
    "|>=|a >= b|Ist b eine Teilmenge von a?|*True*/*False*|a.issuperset(b)|\n",
    "|>|a > b|Ist b eine echte Teilmenge von a|*True*/*False*||"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Operatoren und Methoden für Mengen\n",
    "\n",
    "|Operator|Beispiel|Erklärung|\n",
    "|:-|:-|:-|\n",
    "|&#124;|a &#124; b|Neue Menge, die alle Werte von a und b enthält|a.union(b)\n",
    "|&|a & b|Schnittmenge von a und b|a.intersection(b)|\n",
    "|-|a - b|Menge mit allen Elementen aus a, außer denen, die auch in b sind|a.difference(b)|\n",
    "|^|a ^ b|Menge mit Elementen, die entweder in a oder b sind, aber nicht in beiden|a.symmetric_difference(b)|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Noch ein Exkurs...\n",
    "\n",
    "Zum Anfang des Kurses haben wir bereits etwas über die Unterschiede zwischen Python 2 und 3 gesprochen. Ein weiterer wichtiger Unterschied ist, dass Python 3 standardmäßig *Unicode* für die Übersetzung von Bytes in Schriftzeichen und umgekehrt verwendet.\n",
    "\n",
    "Was ist Unicode?\n",
    "\n",
    "Lange Geschichte..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Unicode\n",
    "\n",
    "- Charaktere werden als Bits (0 oder 1) gespeichert\n",
    "- Anfangs war Speicherplatz sehr teuer und man versuchte, wann immer möglich Speicher zu sparen\n",
    "- Zeichensatztabellen (*codepages*) hatten ursprünglich nur wenige Zeichen. ASCII (*American Standard Code for Information Interchange*) etwa verwendete anfangs 7 bits, d.h., es können 2<sup>7</sup>, oder 128, Zeichen dargestellt werden. Dazu gehören auch Steuerzeichen wie Tabulator.\n",
    "- Spätere Tabellen wurden auf 8 bit vergrößert, um Sonderzeichen wie etwa die deutschen Umlaute berücksichtigen zu können."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Unicode\n",
    "\n",
    "- Da sich im Laufe der Zeit immer mehr Tabellen entwickelten, um mehr Sprachen abdecken zu können, musste man immer angeben, welche Tabelle in einer Datei verwendet wurde.\n",
    "- Jedem einzelnen Zeichen immer mehr Speicher zur Verfügung zu stellen hilft auf die Dauer auch nicht, da dadurch in den meisten Fällen Speicher verschwendet wird.\n",
    "- Unicodes Lösung: Eine einzelne Tabelle mit jedem bekannten Zeichen und unterschiedliche lange Byte-Sequenzen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Unicode\n",
    "\n",
    "- Unicode verwendet verschiedene Formate, um Zeichen zu kodieren. Das gebräuchlichste ist UTF-8, welches bis zu 7 Bytes pro Zeichen verwendet (für die ursprünglichen ASCII-Zeichen benötigt es nur 1 Byte).\n",
    "- Seit Python 3 werden Zeichenketten automatisch als Unicode gespeichert. Sie können also auch Zeichen, wie deutsche Umlaute oder asiatische Schriftzeichen, direkt in Zeichenketten verwenden.\n",
    "- Alternativ kann man Unicode-Zeichen als Escape-Sequenzen einfügen, die mit einem \"u\" beginnen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Diese Escape-Sequenz stellt das Euro-Symbol € dar.'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = \"Diese Escape-Sequenz stellt das Euro-Symbol \\u20ac dar.\"\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Unicode\n",
    "\n",
    "Unicode-Homepage:\n",
    "\n",
    "[https://home.unicode.org/](https://home.unicode.org/)\n",
    "\n",
    "Gute englischsprachige Zusammenfassung zu Unicode/Unicode in Python:\n",
    "\n",
    "[https://docs.python.org/3.3/howto/unicode.html](https://docs.python.org/3.3/howto/unicode.html)\n",
    "\n",
    "Suchmaschine für Unicode-Zeichen:\n",
    "\n",
    "[https://unicode-table.com/de/](https://unicode-table.com/de/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Fortsetzung folgt..."
   ]
  }
 ],
 "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": 2
}