{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Level 3\n",
"\n",
"In diesem Level lernen wir neue Datentypen, wie `list`, `tuple`, `dict`, `set` und `frozenset` kennen und lernen über Objekte dieser Typen mittels einer __for-Schleife__ zu iterieren. Wir werden die Schlüsselwörter `del` und `for` kennenlernen und auch den Schlüsselwörtern `in`, `break`, `continue` und `else` ein weiteres Mal begegnen.\n",
"\n",
"## Einstieg\n",
"Bisher können wir Werte in Variablen speichern, das funktioniert auch, solange wir wissen, wieviele Werte wir speichern müssen. Das muss aber nicht der Fall sein. Die Datentypen, die wir in diesem Level kennenlernen ermöglichen es meherere Werte in einem Objekt zu speichern. Jeder dieser Typen hat dabei seine Besonderheiten, die wir im Laufe des Levels lernen werden."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## list\n",
"Der `list` Typ ist der erste, den wir uns in diesem Level anschauen möchten. Er bietet viele Möglichkeiten an, ist einfach zu bedienen, weshalb er auch häufig benutzt wird. Im Gegensatz zu allen anderen Typen, die wir bereits kennengelernt haben und auch einigen anderen, die wir noch kennenlernen, ist die Liste ein veränderlicher Typ. Das heißt wir können ein `list` Objekt ändern und müssen es nicht überschreiben. Die Elemente eines `list` Objektes können einen beliebigen Typen haben."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Erstellen einer Liste\n",
"Zuerst erstellen wir eine leere Liste, entweder benutzen wir dafür die `list()` Funktion oder eckige Klammern `[]`, welche die Literale einer Liste darstellen."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"leer = list()\n",
"leer2 = []"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Es ist allerdings möglich eine Liste zu erstellen, die bereits Einträge enthält. Diese Einträge nennen wir _Elemente_. Für das erstellen können wir wieder die Literale nehmen oder die `list()` Funktion. Beim Benutzen der `list()` Funktion müssen wir allerdings beachten, dass diese ein Objekt in eine Liste umwandelt und das nicht mit allen Objekten geht. In dem Beispiel unten erstellen wir aus einem string eine Liste."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0, True, 4.2, 'foo'] Länge: 4\n",
"['a', 'b', 'r', 'a', 'c', 'a', 'd', 'a', 'b', 'r', 'a'] Länge: 11\n"
]
}
],
"source": [
"liste = [0, True, 4.2, \"foo\"]\n",
"liste2 = list(\"abracadabra\")\n",
"print(liste, \"Länge:\", len(liste))\n",
"print(liste2, \"Länge:\", len(liste2))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Operatoren\n",
"Für Listen gibt es ebenfalls einen `+` und einen `*` Operator:
\n",
"Beim `+` Operator wird eine Liste erstellt, die erst alle Elemente der ersten Liste und dann alle Elemente der zweiten Liste enthält.
\n",
"Beim `*` Operator muss der andere Wert neben der Liste ein integer sein. Es wird eine neue Liste erstellt, welche die Elemente der Liste entsprechend häufig wiederholt."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0, True, 4.2, 'foo', 'a', 'b', 'r', 'a', 'c', 'a', 'd', 'a', 'b', 'r', 'a']\n",
"[0, True, 4.2, 'foo', 0, True, 4.2, 'foo']\n"
]
}
],
"source": [
"liste = [0, True, 4.2, \"foo\"]\n",
"liste2 = list(\"abracadabra\")\n",
"print(liste + liste2)\n",
"print(liste * 2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Zugriff auf Elemente \n",
"Auf die Elemente einer Liste wird über deren __Index__ zugegriffen. Dieser ist ein integer startet beim ersten Element mit `0`."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0 0\n",
"1 True\n",
"2 4.2\n",
"3 foo\n"
]
}
],
"source": [
"liste = [0, True, 4.2, \"foo\"]\n",
"index = 0\n",
"length = len(liste)\n",
"while index < length:\n",
" element = liste[index]\n",
" print(index, element)\n",
" index = index + 1 "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Es ist allerdings auch möglich mit negativen Indices zu arbeiten. Diese starten beim letzten Element der Liste mit dem Index `-1`. Dadurch wird es möglich auf die letzten Elemente der Liste zuzugreifen ohne die `len()` Funktion benutzen zu müssen.
\n",
"So können wir die Liste von eben auch rückwärts durchlaufen:"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"-1 foo\n",
"-2 4.2\n",
"-3 True\n",
"-4 0\n"
]
}
],
"source": [
"liste = [0, True, 4.2, \"foo\"]\n",
"index = -1\n",
"length = -1 * len(liste)\n",
"while index >= length:\n",
" element = liste[index]\n",
" print(index, element)\n",
" index = index - 1 "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Slicing\n",
"Es ist nicht nur möglich auf die gesamte Liste oder auf einzelne Elemente zuzugreifen. Mit slicing können wir auch auf Teile einer Liste zugreifen.\n",
"```python\n",
"liste[start:stop:step]\n",
"```\n",
"* _start_ gibt den Index an, an dem unser Teil der Liste startet\n",
"* _stop_ gibt den Index an, bis zu dem unser Teil der Liste geht. Das Element mit diesem Index ist jedoch nicht enthalten.\n",
"* _step_ gibt die Schrittweite zwischen zwei Indices unserer Teilliste an"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[True, 4.2, 'foo', False, 'spam', 'egg']\n",
"[0, 4.2, False]\n",
"[42, 'egg', 'spam', False, 'foo', 4.2, True]\n"
]
}
],
"source": [
"liste = [0, True, 4.2, \"foo\", False, \"spam\", \"egg\", 42]\n",
"print(liste[1:-1]) # von Index 1 bis Index -1\n",
"print(liste[0:6:2]) # von Index 0 bis Index 6 jedes zweite Element\n",
"print(liste[-1:0:-1]) # von Index -1 bis Index 0 jedes Element"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"_start_, _stop_ und _step_ können allerdings auch weggelassen werden.\n",
"* Wird _start_ weggelassen startet die Teilliste mit dem ersten Element.\n",
"* Wird _stop_ weggelassen, endet die Teilliste mit dem letzten Element.\n",
"* wird _step_ weggelassen, ist die Schrittweite 1"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[4.2, False, 'egg']\n",
"[0, 'foo', 'egg']\n",
"[0, False]\n",
"[True, 4.2, 'foo', False, 'spam', 'egg', 42]\n"
]
}
],
"source": [
"liste = [0, True, 4.2, \"foo\", False, \"spam\", \"egg\", 42]\n",
"print(liste[2::2]) # von Index 2 bis zum Ende jedes zweite Element\n",
"print(liste[:-1:3]) # vom Start bis Index -1 jedes dritte Element\n",
"print(liste[::4]) # vom Start bis zum Ende jedes vierte Element\n",
"print(liste[1:]) # von Index 1 bis zum Ende"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Elemente hinzufügen\n",
"Nachdem wir eine Liste erstellt haben, möchten gegebenenfalls auch Elemente hinzufügen. Dazu gibt es mehrere Möglichkeiten. Wir können mit Hilfe der `list.append()` Methode ein Element an unsere Liste hinten anhängen oder mit der `list.insert()` Methode ein Element an einem Index in unsere Liste einfügen, wobei die Elemente nach diesem Index nach hinten aufrücken."
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0, True, 4.2, 'foo', False, 'spam', 'egg', 42]\n",
"[0, True, 4.2, 'foo', False, 'spam', 'egg', 42, 3.14]\n"
]
}
],
"source": [
"liste = [0, True, 4.2, \"foo\", False, \"spam\", \"egg\", 42]\n",
"print(liste)\n",
"liste.append(3.14)\n",
"print(liste)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0, True, 4.2, 'foo', False, 'spam', 'egg', 42]\n",
"[0, True, 4.2, 'foo', 'test', False, 'spam', 'egg', 42]\n"
]
}
],
"source": [
"liste = [0, True, 4.2, \"foo\", False, \"spam\", \"egg\", 42]\n",
"print(liste)\n",
"liste.insert(4, \"test\")\n",
"print(liste)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Elemente finden\n",
"Eventuell wollen wir wissen ob ein Element in unserer Liste enthalten ist, und wenn es in unserer Liste enthalten ist, wollen wir eventuell wissen an welcher Stelle oder wie oft.\n",
"\n",
"Zuerst wollen wir lernen, wie wir mit dem Schlüsselwort `in` feststellen, ob ein Element in unserer Liste enthalten ist:"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"egg: True\n",
"ham: False\n"
]
}
],
"source": [
"liste = [0, True, 4.2, False, \"spam\", \"egg\", 42]\n",
"print(\"egg:\", \"egg\" in liste)\n",
"print(\"ham:\", \"ham\" in liste)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Aber vorsicht:"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1: True\n"
]
}
],
"source": [
"liste = [0, True, 4.2, False, \"spam\", \"egg\", 42]\n",
"print(\"1:\", 1 in liste)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Scheinbar ist der integer `1` in der Liste enthalten, obwohl keiner der Einträge auf den ersten Blick danach aussieht. Also wird ein Element unserer Liste als `1` interpretiert oder ist `== 1`. Um rauszufinden an welcher Stelle sich dieses Element befindet können wir die `list.index()` Methode benutzen. Dabei müssen wir allerdings vorsichtig sein, versuchen wir nämlich den Index eines Elementes zu finden, der __nicht__ in der Liste enthalten ist, erhalten wir einen Fehler."
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1: True\n",
"True\n"
]
}
],
"source": [
"liste = [0, True, 4.2, False, \"spam\", \"egg\", 42]\n",
"print(\"1:\", 1 in liste)\n",
"ind = liste.index(1)\n",
"print(liste[ind])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" Der boolean `True` auf dem Index `1` wird hier also als `1` erkannt. Dieses Phänomen tritt allerdings nur mit `1` und `True` und `0` und `False` auf. Um dieses Problem zu umgehen nutzen wir im folgenden eine Liste mit anderen Elementen."
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['a', 'b', 'r', 'a', 'c', 'a', 'd', 'a', 'b', 'r', 'a']\n",
"Erstes Auftreten von 'a': 0\n",
"Erstes Auftreten von 'b': 1\n",
"Erstes Auftreten von 'c': 4\n",
"Erstes Auftreten von 'd': 6\n"
]
}
],
"source": [
"liste = list(\"abracadabra\")\n",
"print(liste)\n",
"print(\"Erstes Auftreten von 'a':\", liste.index(\"a\"))\n",
"print(\"Erstes Auftreten von 'b':\", liste.index(\"b\"))\n",
"print(\"Erstes Auftreten von 'c':\", liste.index(\"c\"))\n",
"print(\"Erstes Auftreten von 'd':\", liste.index(\"d\"))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wie wir sehen können zeigt und `list.index()` lediglich das erste Auftreten eines Elementes an, auch wenn dieses Element mehrfach in der Liste auftaucht.\n",
"\n",
"Um rauszufinden wie häufig ein Element in unserer Liste auftaucht können wir die `list.count()` Methode benutzen."
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Anzahl von 'a': 5\n",
"Anzahl von 'b': 2\n",
"Anzahl von 'c': 1\n",
"Anzahl von 'd': 1\n",
"Anzahl von 'e': 0\n"
]
}
],
"source": [
"liste = ['a', 'b', 'r', 'a', 'c', 'a', 'd', 'a', 'b', 'r', 'a']\n",
"print(\"Anzahl von 'a':\", liste.count(\"a\"))\n",
"print(\"Anzahl von 'b':\", liste.count(\"b\"))\n",
"print(\"Anzahl von 'c':\", liste.count(\"c\"))\n",
"print(\"Anzahl von 'd':\", liste.count(\"d\"))\n",
"print(\"Anzahl von 'e':\", liste.count(\"e\"))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Dabei sehen wir auch, dass uns die `list.count()` Methode keinen Fehler gibt, wenn ein Element (im obigen Fall 'e') nicht in der Liste enthalten ist, sondern `0` zurück gibt."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Elemente entfernen\n",
"Wenn wir Elemente entfernen wollen, haben wir auch wieder mehrere Möglichkeiten, die sich im Wesentlichen in unserer Herangehungsweise entscheiden. Kennen wir den Index des Elementes, welches wir aus der Liste entfernen möchten, können wir das Schlüsselwort `del` oder die `list.pop()` Methode verwenden, kennen wir jedoch das Element, das wir entfernen möchten, benutzen wir die `list.remove()` Methode."
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['foo', 'test', 23, 'spam', 'egg', 42]\n",
"['test', 23, 'spam', 'egg', 42]\n"
]
}
],
"source": [
"liste = [\"foo\", \"test\", 23, \"spam\", \"egg\", 42]\n",
"print(liste)\n",
"del liste[0]\n",
"print(liste)\n",
"# del liste\n",
"# print(liste)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wie wir sehen, können wir nicht nur einzelne Elemente einer Liste anhand ihres Indexes, sondern auch die gesamte Liste entfernen. Das Schlüsselwort `del` entfernt die Referenz einer Variable und somit die Variable, weshalb wir auch einen `NameError` erhalten, wenn wir versuchen die Variable zu benutzen, nachdem wir sie gelöscht haben."
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['foo', 'test', 23, 'spam', 'egg', 42]\n",
"['foo', 'test', 23, 'spam', 'egg']\n",
"Entfernt: 42\n"
]
}
],
"source": [
"liste = [\"foo\", \"test\", 23, \"spam\", \"egg\", 42]\n",
"print(liste)\n",
"element = liste.pop()\n",
"print(liste)\n",
"print(\"Entfernt:\", element)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Oben haben wir statt des `del` Schlüsselwortes die `list.pop()` Methode benutzt. Das hat den Vorteil, dass uns die `list.pop()` Methode das Element, welches wir aus der Liste entfernt haben, zurück gibt. Wenn wir der `list.pop()` keinen Index mitgeben, entfernt sie standardmäßig das letzte Element. Wenn wir der `list.pop()` Methode einen Index geben, entfernt sie das Element an diesem Index aus der Liste."
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['foo', 'test', 23, 'spam', 'egg', 42]\n",
"['foo', 'test', 23, 'egg', 42]\n",
"Entfernt: spam\n"
]
}
],
"source": [
"liste = [\"foo\", \"test\", 23, \"spam\", \"egg\", 42]\n",
"print(liste)\n",
"element = liste.pop(3)\n",
"print(liste)\n",
"print(\"Entfernt:\", element)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Nun wollen wir ein Element, dessen Wert wir kennen aus der Liste entfernen. Dazu benutzen wir die `list.remove()` Methode. Diese entfernt das erste Auftreten des Wertes, den wir ihr geben, aus der Liste."
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['a', 'b', 'r', 'a', 'c', 'a', 'd', 'a', 'b', 'r', 'a']\n",
"['b', 'r', 'a', 'c', 'a', 'd', 'a', 'b', 'r', 'a']\n",
"['b', 'r', 'c', 'a', 'd', 'a', 'b', 'r', 'a']\n"
]
}
],
"source": [
"liste = list(\"abracadabra\")\n",
"print(liste)\n",
"liste.remove(\"a\")\n",
"print(liste)\n",
"liste.remove(\"a\")\n",
"print(liste)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Verschachtelung\n",
"Da wir in einer Liste Elemente beliebigen Typs speichern können, können wir auch eine Liste als Element einer Liste speichern. Auf die innere Liste können wir dann genauso zugreifen, wie auf jedes andere Element."
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[0, 1, 2], [3, 4, 5]]\n",
"Länge outer_list: 2\n",
"outer_list[0]: [0, 1, 2]\n",
"outer_list[1]: [3, 4, 5]\n"
]
}
],
"source": [
"inner_list1 = [0, 1, 2]\n",
"inner_list2 = [3, 4, 5]\n",
"outer_list = [inner_list1, inner_list2]\n",
"print(outer_list)\n",
"print(\"Länge outer_list:\", len(outer_list))\n",
"print(\"outer_list[0]:\", outer_list[0])\n",
"print(\"outer_list[1]:\", outer_list[1])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Die äußere Liste enthält zwei Elemente, die in diesem Fall jeweils Listen sind."
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Erstes Element von:\n",
"outer_list[0]: 0\n",
"outer_list[1]: 3\n"
]
}
],
"source": [
"inner_list1 = [0, 1, 2]\n",
"inner_list2 = [3, 4, 5]\n",
"outer_list = [inner_list1, inner_list2]\n",
"# die jeweils ersten Elemente der inneren Listen:\n",
"print(\"Erstes Element von:\")\n",
"print(\"outer_list[0]:\", outer_list[0][0])\n",
"print(\"outer_list[1]:\", outer_list[1][0])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Die vergessenen Methoden\n",
"Wenn wir uns mit der `dir()` Funktion die Methoden eines `list` Objektes ansehen und alle Einträge mit `__` am Anfang und Ende des Namens ignorieren, stellen wir fest, dass wir noch einige Methoden nicht behandelt haben."
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['__add__',\n",
" '__class__',\n",
" '__contains__',\n",
" '__delattr__',\n",
" '__delitem__',\n",
" '__dir__',\n",
" '__doc__',\n",
" '__eq__',\n",
" '__format__',\n",
" '__ge__',\n",
" '__getattribute__',\n",
" '__getitem__',\n",
" '__gt__',\n",
" '__hash__',\n",
" '__iadd__',\n",
" '__imul__',\n",
" '__init__',\n",
" '__init_subclass__',\n",
" '__iter__',\n",
" '__le__',\n",
" '__len__',\n",
" '__lt__',\n",
" '__mul__',\n",
" '__ne__',\n",
" '__new__',\n",
" '__reduce__',\n",
" '__reduce_ex__',\n",
" '__repr__',\n",
" '__reversed__',\n",
" '__rmul__',\n",
" '__setattr__',\n",
" '__setitem__',\n",
" '__sizeof__',\n",
" '__str__',\n",
" '__subclasshook__',\n",
" 'append',\n",
" 'clear',\n",
" 'copy',\n",
" 'count',\n",
" 'extend',\n",
" 'index',\n",
" 'insert',\n",
" 'pop',\n",
" 'remove',\n",
" 'reverse',\n",
" 'sort']"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"dir(list)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Da uns die `dir()` Funktion eine Liste zurückgibt, können wir uns diese Methoden ausgeben lassen, indem wir die letzten 11 Elemente anzeigen:"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['append',\n",
" 'clear',\n",
" 'copy',\n",
" 'count',\n",
" 'extend',\n",
" 'index',\n",
" 'insert',\n",
" 'pop',\n",
" 'remove',\n",
" 'reverse',\n",
" 'sort']"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"dir(list)[-11:]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### list.clear()\n",
"Die `list.clear()` Methode können wir benutzen um alle Elemente einer Liste zu entfernen. Der Anwendungsfall ist relativ begrenzt, da wir auch einfach eine leere Liste erstellen können."
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[]\n"
]
}
],
"source": [
"liste = list(\"abracadabra\")\n",
"liste.clear()\n",
"print(liste)"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[]\n"
]
}
],
"source": [
"# Alternativ:\n",
"liste = list(\"abracadabra\")\n",
"liste = list()\n",
"print(liste)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### list.copy()\n",
"Die `list.copy()` Methode kann benutzt werden um eine Kopie der Liste zu erstellen. Auch hier gibt es eine alternative Möglichkeit über Slicing, dasselbe zu erreichen."
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['a', 'b', 'r', 'a', 'c', 'a', 'd', 'a', 'b', 'r', 'a']\n",
"['a', 'b', 'r', 'a', 'c', 'a', 'd', 'a', 'b', 'r', 'a']\n"
]
}
],
"source": [
"liste = list(\"abracadabra\")\n",
"liste_copy = liste.copy()\n",
"print(liste)\n",
"print(liste_copy)"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['a', 'b', 'r', 'a', 'c', 'a', 'd', 'a', 'b', 'r', 'a']\n",
"['a', 'b', 'r', 'a', 'c', 'a', 'd', 'a', 'b', 'r', 'a']\n"
]
}
],
"source": [
"# Alternativ:\n",
"liste = list(\"abracadabra\")\n",
"liste_copy = liste[:]\n",
"print(liste)\n",
"print(liste_copy)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### list.extend()\n",
"Die `list.extend()` Methode kann benutzt werden um an die bestehende Liste eine andere Liste anzuhängen."
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['a', 'b', 'r', 'a', 'c', 'a', 'd', 'a', 'b', 'r', 'a', 's', 'i', 'm', 's', 'a', 'l', 'a']\n"
]
}
],
"source": [
"liste = list(\"abracadabra\")\n",
"liste.extend(\"simsala\")\n",
"print(liste)"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['a', 'b', 'r', 'a', 'c', 'a', 'd', 'a', 'b', 'r', 'a', 's', 'i', 'm', 's', 'a', 'l', 'a']\n"
]
}
],
"source": [
"# Alternativ:\n",
"liste = list(\"abracadabra\")\n",
"liste = liste + list(\"simsala\")\n",
"print(liste)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### list.reverse()\n",
"Mit der `list.reverse()` können wir eine Liste umdrehen. Wie auch die voherigen Methoden gibt es auch hier Alternativen."
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['a', 'r', 'b', 'a', 'd', 'a', 'c', 'a', 'r', 'b', 'a']\n"
]
}
],
"source": [
"liste = list(\"abracadabra\")\n",
"liste.reverse()\n",
"print(liste)"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['a', 'r', 'b', 'a', 'd', 'a', 'c', 'a', 'r', 'b', 'a']\n"
]
}
],
"source": [
"# Alternativ:\n",
"liste = list(\"abracadabra\")\n",
"liste = liste[::-1]\n",
"print(liste)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### list.sort()\n",
"Mit `list.sort()` lässt sich eine Liste sortieren, solange die Elemente miteinander vergleichbar sind."
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['a', 'a', 'a', 'a', 'a', 'b', 'b', 'c', 'd', 'r', 'r']\n"
]
}
],
"source": [
"liste = list(\"abracadabra\")\n",
"liste.sort()\n",
"print(liste)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## tuple\n",
"Ein tuple ist grob gesagt eine unveränderliche Liste. Ein Tupel hat eine Länge, Elemente können nicht entfernt oder hinzugefügt werden. Lediglich die Elemente eines Tupels lassen sich ändern, wenn sie veränderlich sind."
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"('a', 'b', 'r', 'a', 'c', 'a', 'd', 'a', 'b', 'r', 'a')\n",
"(2, 3, 23, 42)\n",
"(3, 2, 3)\n"
]
}
],
"source": [
"t1 = tuple(\"abracadabra\")\n",
"t2 = (2,3,23,42)\n",
"t3 = 3,2,3\n",
"print(t1)\n",
"print(t2)\n",
"print(t3)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ein Tuple lässt sich über die `tuple()` Funktion oder über runde Klammern `()` definieren. Die runden Klammern können wir allerdings meistens weglassen. Der Zugriff auf die Elemente funktioniert, wie bei Listen sowohl über den Index, als auch über Slicing."
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"c\n",
"('a', 'b', 'r', 'a', 'c')\n"
]
}
],
"source": [
"Tuple = tuple(\"abracadabra\")\n",
"print(Tuple[4])\n",
"print(Tuple[0:5])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wenn wir uns die Methoden von einem Tuple anschauen, stellen wir fest, dass es nur zwei \"normale\" Methoden gibt, die wir auch schon von der Liste kennen, nämlich `tuple.count()` und `tuple.index()`. Desweiteren können wir auf einen Tuple auch die `len()` Funktion und das Schlüsselwort `in` anwenden."
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['__add__',\n",
" '__class__',\n",
" '__contains__',\n",
" '__delattr__',\n",
" '__dir__',\n",
" '__doc__',\n",
" '__eq__',\n",
" '__format__',\n",
" '__ge__',\n",
" '__getattribute__',\n",
" '__getitem__',\n",
" '__getnewargs__',\n",
" '__gt__',\n",
" '__hash__',\n",
" '__init__',\n",
" '__init_subclass__',\n",
" '__iter__',\n",
" '__le__',\n",
" '__len__',\n",
" '__lt__',\n",
" '__mul__',\n",
" '__ne__',\n",
" '__new__',\n",
" '__reduce__',\n",
" '__reduce_ex__',\n",
" '__repr__',\n",
" '__rmul__',\n",
" '__setattr__',\n",
" '__sizeof__',\n",
" '__str__',\n",
" '__subclasshook__',\n",
" 'count',\n",
" 'index']"
]
},
"execution_count": 34,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"dir(tuple)"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"('a', 'b', 'r', 'a', 'c', 'a', 'd', 'a', 'b', 'r', 'a')\n",
"Länge: 11\n",
"Anzahl 'a': 5\n",
"Erstes 'b': 1\n",
"e? False\n"
]
}
],
"source": [
"Tuple = tuple(\"abracadabra\")\n",
"print(Tuple)\n",
"print(\"Länge:\", len(Tuple))\n",
"print(\"Anzahl 'a':\", Tuple.count(\"a\"))\n",
"print(\"Erstes 'b':\", Tuple.index(\"b\"))\n",
"print(\"e?\", \"e\" in Tuple)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wir können Tuple auch benutzen um den Wert zweier Variablen zu tauschen. Bisher würden wir dafür den Wert einer Variable in einer temporären Variable (`tmp`) speichern und die Werte so tauschen."
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"a: 10\n",
"b: 5\n"
]
}
],
"source": [
"a = 5\n",
"b = 10\n",
"tmp = a\n",
"a = b\n",
"b = tmp\n",
"print(\"a:\", a)\n",
"print(\"b:\", b)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Durch die Verwendung von Tuplen können wir nun auf unsere temporäre Variable verzichten und den Code lesbarer gestalten:"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"a: 10\n",
"b: 5\n"
]
}
],
"source": [
"a = 5\n",
"b = 10\n",
"a, b = b, a\n",
"# Alternativ: (a, b) = (b, a)\n",
"print(\"a:\", a)\n",
"print(\"b:\", b)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Strings\n",
"Jetzt da wir Listen und Tuple kennengelernt haben lohnt es sich, nochmal Strings anzuschauen, da wir auch hier auch auf einzelne Zeichen mit dem Index zugreifen können. So wie bei Listen und Tupeln, können wir auch bei Strings die `str.count()` und `str.index()` Methoden verwenden."
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"a\n",
"a\n",
"abra\n"
]
}
],
"source": [
"zauberwort = \"abracadabra\"\n",
"print(zauberwort[0])\n",
"print(zauberwort[-1])\n",
"teilwort = zauberwort[:4]\n",
"print(teilwort)"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"5"
]
},
"execution_count": 39,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"zauberwort = \"abracadabra\"\n",
"zauberwort.count(\"a\")"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n"
]
}
],
"source": [
"zauberwort = \"abracadabra\"\n",
"print(zauberwort.index(\"b\"))"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"e? False\n"
]
}
],
"source": [
"zauberwort = \"abracadabra\"\n",
"print(\"e?\", \"e\" in zauberwort)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## dict\n",
"Ein Dictionary speichert Werte nicht anhand ihres Indexes, sondern anhand eines Schlüssels.\n",
"### Erstellen eines dict\n",
"Ein leeres Dictionary kann auf zwei Arten erstellt werden:"
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {},
"outputs": [],
"source": [
"leer1 = dict()\n",
"leer2 = {}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Möchten wir ein Dictionary mit Einträgen erstellen, können wir dies entweder durch die `dict()` Funktion erreichen, in der wir Schlüssel und Werte als Liste von Tuplen mit zwei Elementen übergeben, oder indem wir Schlüssel und Werte durch Doppelpunkte `:` getrennt in geschweiften Klammern `{}` als Literale definieren."
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'name': 'Max', 'nachname': 'Mustermann', 'alter': 42}\n",
"{'name': 'Martha', 'nachname': 'Musterfrau', 'alter': 23}\n"
]
}
],
"source": [
"dict1 = {\"name\": \"Max\", \"nachname\": \"Mustermann\", \"alter\": 42}\n",
"dict2 = dict([(\"name\", \"Martha\"), (\"nachname\", \"Musterfrau\"), (\"alter\", 23)])\n",
"print(dict1)\n",
"print(dict2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Als Schlüssel sind Werte aller unveränderlichen Typen erlaubt, in einem Dictionary müssen die Schlüssel auch nicht denselben Typen haben, es ergibt sich meistens aber, dass die Schlüssel denselben Typen haben."
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{0: 'integer', True: 'boolean', (0, 0): 'tuple', 's': 'strings'}\n"
]
}
],
"source": [
"beispiel_dict = {0:\"integer\", True:\"boolean\", (0,0):\"tuple\", \"s\":\"strings\"}\n",
"print(beispiel_dict)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Zugriff\n",
"Der Zugriff auf die Elemente erfolgt dann über den entsprechenden Schlüssel:"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Alter:\n",
"Max: 42\n",
"Martha: 23\n"
]
}
],
"source": [
"Max = {\"name\": \"Max\", \"nachname\": \"Mustermann\", \"alter\": 42}\n",
"Martha = {\"name\": \"Martha\", \"nachname\": \"Musterfrau\", \"alter\": 23}\n",
"print(\"Alter:\")\n",
"print(\"Max:\", Max[\"alter\"])\n",
"print(\"Martha:\", Martha[\"alter\"])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Löschen erfolgt ähnlich:"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'name': 'Max', 'alter': 42}"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"del Max[\"nachname\"]\n",
"Max"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Alternativ kann für den Zugriff die `dict.get()` Methode benutzt werden. Diese ermöglicht es auch einen Standardwert anzugeben, wenn der Schlüssel in dem Dictionary nicht vorhanden ist."
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Alter:\n",
"Max: 42\n",
"Martha: 0\n"
]
}
],
"source": [
"Max = {\"name\": \"Max\", \"nachname\": \"Mustermann\", \"alter\": 42}\n",
"Martha = {\"name\": \"Martha\", \"nachname\": \"Musterfrau\"}\n",
"print(\"Alter:\")\n",
"print(\"Max:\", Max.get(\"alter\", 0))\n",
"print(\"Martha:\", Martha.get(\"alter\", 0))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Den Wert zu einem Schlüssel können wir setzen indem wir einem Schlüssel einen Wert zuweisen, existiert dieser Schlüssel bereits, wird sein Wert überschrieben."
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'name': 'Martha', 'nachname': 'Musterfrau', 'alter': 23}\n"
]
}
],
"source": [
"Max = {\"name\": \"Max\", \"nachname\": \"Mustermann\", \"alter\": 42}\n",
"Martha = {\"name\": \"Martha\", \"nachname\": \"Musterfrau\"}\n",
"Martha[\"alter\"] = 23\n",
"print(Martha)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Natürlich kann man auch das `in` Schlüsselwort mit Dictionaries benutzen:"
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"name? True\n",
"alter? False\n"
]
}
],
"source": [
"Martha = {\"name\": \"Martha\", \"nachname\": \"Musterfrau\"}\n",
"print(\"name?\", \"name\" in Martha)\n",
"print(\"alter?\", \"alter\" in Martha)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Die `len()` Funktion liefert bei einem Dictionary die Anzahl an Schlüsseln wieder:"
]
},
{
"cell_type": "code",
"execution_count": 49,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Anzahl Schlüssel: 2\n"
]
}
],
"source": [
"Martha = {\"name\": \"Martha\", \"nachname\": \"Musterfrau\"}\n",
"print(\"Anzahl Schlüssel:\", len(Martha))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### items(), keys() und values()\n",
"Die drei Methoden `dict.items()`, `dict.keys()` und `dict.values()` sind sich relativ ähnlich, weshalb wir sie zusammen betrachten wollen."
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"dict_keys([0, True, (0, 0), 's'])\n",
"dict_values(['integer', 'boolean', 'tuple', 'strings'])\n",
"dict_items([(0, 'integer'), (True, 'boolean'), ((0, 0), 'tuple'), ('s', 'strings')])\n"
]
}
],
"source": [
"dictionary = {0:\"integer\", True:\"boolean\", (0,0):\"tuple\", \"s\":\"strings\"}\n",
"print(dictionary.keys()) # liefert die Schlüssel als Liste\n",
"print(dictionary.values()) # liefert die Werte als Liste\n",
"print(dictionary.items()) # liefert Schlüssel und Werte als Tuple in einer Liste"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### pop()\n",
"Auch Dictionaries besitzen eine `dict.pop()` Methode."
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{True: 'boolean', (0, 0): 'tuple', 's': 'strings'}\n"
]
}
],
"source": [
"dictionary = {0:\"integer\", True:\"boolean\", (0,0):\"tuple\", \"s\":\"strings\"}\n",
"value = dictionary.pop(0)\n",
"print(dictionary)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wie wir sehen funktioniert die `dict.pop()` Methode ähnlich, wie bei den Listen. Der Wert mit dem angegebenen Schlüssel wird zurückgegeben und aus dem Dictionary entfernt."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Die for-Schleife\n",
"Die for-Schleife kann benutzt werden um über verschiedene Objekte zu iterieren. Dabei ist die Syntax einer for-Schleife die folgende:\n",
"```python\n",
"for variable in objekt:\n",
" Befehle\n",
"```\n",
"* _objekt_ ist dabei das Objekt, über das wir iterieren.\n",
"* _variable_ enthält jeweils ein Element aus dem Objekt.\n",
"\n",
"Wir kennen bereits Listen, Tuple, Dictionaries und Strings, über jeden dieser Typen können wir iterieren."
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"a\n",
"b\n",
"r\n",
"a\n",
"c\n",
"a\n",
"d\n",
"a\n",
"b\n",
"r\n",
"a\n"
]
}
],
"source": [
"# Iteration über einen string:\n",
"zauberwort = \"abracadabra\"\n",
"for zeichen in zauberwort:\n",
" print(zeichen)"
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0\n",
"True\n",
"foo\n",
"42\n"
]
}
],
"source": [
"# Iteration über eine Liste:\n",
"liste = [0, True, \"foo\", 42]\n",
"for element in liste:\n",
" print(element)"
]
},
{
"cell_type": "code",
"execution_count": 54,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n",
"2\n",
"3\n"
]
}
],
"source": [
"# Iteration über einen Tuple:\n",
"Tuple = (1,2,3)\n",
"for zahl in Tuple:\n",
" print(zahl)"
]
},
{
"cell_type": "code",
"execution_count": 55,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"name : Max\n",
"nachname : Mustermann\n",
"alter : 42\n"
]
}
],
"source": [
"# Iteration über ein Dictionary:\n",
"Max = {\"name\": \"Max\", \"nachname\": \"Mustermann\", \"alter\": 42}\n",
"for attribut in Max:\n",
" print(attribut, \":\", Max[attribut])"
]
},
{
"cell_type": "code",
"execution_count": 56,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"name : Max\n",
"nachname : Mustermann\n",
"alter : 42\n"
]
}
],
"source": [
"# Alternativ:\n",
"Max = {\"name\": \"Max\", \"nachname\": \"Mustermann\", \"alter\": 42}\n",
"for attribut, wert in Max.items():\n",
" print(attribut, \":\", wert)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### range()\n",
"Die `range()` Funktion ist in vielerlei Hinsicht praktisch. Sie ermöglicht es uns auf einfache, gut lesbare Art und Weise Zahlenfolgen zu erzeugen. Warum das so praktisch ist werden wir gleich sehen.\n",
"```python\n",
"range(stop)\n",
"range(start, stop[, step])\n",
"```\n",
"Wir können `range()` entweder nur mit einem _stop_ Wert aufrufen (dieser muss ein integer sein), oder mit einem _start_, einem _stop_ und einen optionalen _step_ Wert. Bei beiden Varianten erhalten wir ein `range` Objekt.\n",
"Diese verhalten sich ähnlich wie die Werte beim Slicing. Geben wir keinen Wert für `start` an startet unser `range` Objekt bei `0`, geben wir keinen Wert für `step` an, ist die Schrittweite `1`."
]
},
{
"cell_type": "code",
"execution_count": 57,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
]
}
],
"source": [
"# alle Zahlen von 0 bis 10:\n",
"r = range(10)\n",
"print(list(r))"
]
},
{
"cell_type": "code",
"execution_count": 58,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40]\n"
]
}
],
"source": [
"# jede zweite Zahl von 2 bis 42:\n",
"r = range(2, 42, 2)\n",
"print(list(r))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Genauso, wie beim Slicing können die Werte auch negativ sein."
]
},
{
"cell_type": "code",
"execution_count": 59,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0, -2, -4, -6, -8, -10, -12, -14, -16, -18, -20, -22, -24, -26, -28, -30, -32, -34, -36, -38, -40, -42, -44, -46, -48, -50, -52, -54, -56, -58, -60, -62, -64, -66, -68, -70, -72, -74, -76, -78, -80, -82, -84, -86, -88, -90, -92, -94, -96, -98]\n"
]
}
],
"source": [
"# von 0 bis -100 jede zweite Zahl:\n",
"r = range(0, -100, -2)\n",
"print(list(r))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ein range Objekt kann auch benutzt werden um sehr große Zahlenreihen zu erzeugen, da die Zahlen erst berechnet werden, wenn sie benötigt werden."
]
},
{
"cell_type": "code",
"execution_count": 60,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"range(0, 10000000000000000)\n"
]
}
],
"source": [
"r = range(10000000000000000)\n",
"print(r)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Dadurch, dass wir über ein `range` Objekt iterieren können, können wir `range()` gut in einer for-Schleife benutzen."
]
},
{
"cell_type": "code",
"execution_count": 61,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0\n",
"1\n",
"2\n",
"3\n",
"4\n",
"5\n",
"6\n",
"7\n",
"8\n",
"9\n"
]
}
],
"source": [
"for i in range(10):\n",
" print(i)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### break, continue und else\n",
"Die Schlüsselwörter `break`, `continue` und `else` können wir innerhalb einer for-Schleife genauso benutzen, wie in einer while-Schleife."
]
},
{
"cell_type": "code",
"execution_count": 62,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"brcdbr\n"
]
}
],
"source": [
"zauberwort = \"abracadabra#test\"\n",
"neuer_zauber = \"\"\n",
"for zeichen in zauberwort:\n",
" if zeichen == \"#\":\n",
" break\n",
" elif zeichen == \"a\":\n",
" continue\n",
" else:\n",
" neuer_zauber += zeichen\n",
"print(neuer_zauber)"
]
},
{
"cell_type": "code",
"execution_count": 63,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Kein 'Y' gefunden.\n"
]
}
],
"source": [
"string = \"Das ist ein Teststring.\"\n",
"for zeichen in string:\n",
" if zeichen == \"Y\":\n",
" break\n",
"else:\n",
" print(\"Kein 'Y' gefunden.\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"for-Schleifen können verschachtelt werden, was wir benutzen können um über ein verschachteltes Objekt zu iterieren."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"test\n",
"foo\n",
"bar\n",
"ham\n",
"spam\n",
"egg\n"
]
}
],
"source": [
"table = [\n",
" [\n",
" \"test\",\n",
" \"foo\",\n",
" \"bar\"\n",
" ],\n",
" [\n",
" \"ham\",\n",
" \"spam\",\n",
" \"egg\"\n",
" ]\n",
"]\n",
"for row in table:\n",
" for entry in row:\n",
" print(entry)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## sets\n",
"Sets sind Mengen im mathematischen Sinn. Das bedeutet ein Element kann entweder in einer Menge enthalten sein, oder eben nicht.\n",
"### Erstellen eines set\n",
"Ein Set kann entweder über die `set()` Funktion aus einem anderen Objekt erzeugt werden, oder über geschweifte Klammern `{}` welche die Literale eines Sets bilden."
]
},
{
"cell_type": "code",
"execution_count": 64,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"set()\n"
]
}
],
"source": [
"Set = set()\n",
"print(Set)"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{2, 3, 5, 7}\n"
]
}
],
"source": [
"Set = {2,3,5,7}\n",
"print(Set)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### in und len()"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n"
]
}
],
"source": [
"some_primes = {2, 3, 5, 7, 11, 13}\n",
"print(12 in some_primes)"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"6\n"
]
}
],
"source": [
"some_primes = {2, 3, 5, 7, 11, 13}\n",
"print(len(some_primes))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Elemente hinzufügen\n",
"Nach dem wir eine Menge erstellt haben, können wir mit der `set.add()` Methode Elemente hinzufügen."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{2, 3, 5, 7, 11, 13, 17}\n"
]
}
],
"source": [
"some_primes = {2, 3, 5, 7, 11, 13}\n",
"some_primes.add(17)\n",
"print(some_primes)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Um nicht nur einzelne Elemente, sondern mehrere Elemente an eine Menge anzuhängen, können wir die `set.update()` Methode benutzen."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{2, 3, 5, 7, 11, 13, 17, 19, 23}\n"
]
}
],
"source": [
"some_primes = {2, 3, 5, 7, 11, 13}\n",
"more_primes = [17, 19, 23]\n",
"some_primes.update(more_primes)\n",
"print(some_primes)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Elemente entfernen\n",
"Um Elemente zu entfernen gibt es zwei Möglichkeiten. Die `set.pop()` Methode entfernt ein Element aus der Menge und gibt es dabei zurück. Die `set.remove()` Methode kann dafür benutzt werden, um Elemente anhand ihres Wertes aus der Menge zu entfernen."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(1, 2)\n",
"{'test', 42, 'foo', 23}\n"
]
}
],
"source": [
"Set = {23, \"foo\", 42, \"test\", (1,2)}\n",
"element = Set.pop()\n",
"print(element)\n",
"print(Set)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{(1, 2), 'test', 42, 23}\n"
]
}
],
"source": [
"Set = {23, \"foo\", 42, \"test\", (1,2)}\n",
"Set.remove(\"foo\")\n",
"print(Set)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Mengenoperationen\n",
"Set-Objekte bieten Mengenoperationen an, die auch aus der Mathematik bekannt sind. Diese sind die Schnittmenge, die Vereinigungsmenge und die Differenzmenge.\n",
"\n",
"Die Schnittmenge enthält alle Elemente, die in beiden Mengen enthalten sind."
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{1, 3, 5}\n"
]
}
],
"source": [
"# Schnittmenge zweier Mengen:\n",
"set1 = {1, 3, 4, 5, 2}\n",
"set2 = {5, 8, 1, 3, 7, 9}\n",
"schnittmenge = set1 & set2\n",
"print(schnittmenge)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Alternativ können wir auch die `set.intersection()` Methode benutzen."
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{1, 3, 5}\n"
]
}
],
"source": [
"# Schnittmenge zweier Mengen:\n",
"set1 = {1, 3, 4, 5, 2}\n",
"set2 = {5, 8, 1, 3, 7, 9}\n",
"schnittmenge = set1.intersection(set2)\n",
"print(schnittmenge)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Die Vereinigungsmenge enthält alle Elemente, die in einer der Mengen enthalten sind."
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{1, 2, 3, 4, 5, 7, 8, 9}\n"
]
}
],
"source": [
"# Vereinigungsmenge zweier Mengen:\n",
"set1 = {1, 3, 4, 5, 2}\n",
"set2 = {5, 8, 1, 3, 7, 9}\n",
"vereinigung = set1 | set2\n",
"print(vereinigung)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Alternativ können wir auch die `set.union()` Methode benutzen."
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{1, 2, 3, 4, 5, 7, 8, 9}\n"
]
}
],
"source": [
"# Vereinigungsmenge zweier Mengen:\n",
"set1 = {1, 3, 4, 5, 2}\n",
"set2 = {5, 8, 1, 3, 7, 9}\n",
"vereinigung = set1.union(set2)\n",
"print(vereinigung)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Die Differenzmenge einer Menge S1 mit einer Menge S2 enthält alle Elemente, die in der Menge S1 aber nicht in der Menge S2 sind."
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{1, 2, 3}\n"
]
}
],
"source": [
"s1 = {1, 3, 4, 5, 2}\n",
"s2 = {4, 5}\n",
"differenz = s1 - s2\n",
"print(differenz)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Alternativ können wir auch die `set.difference()` Methode benutzen."
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{1, 2, 3}\n"
]
}
],
"source": [
"s1 = {1, 3, 4, 5, 2}\n",
"s2 = {4, 5}\n",
"differenz = s1.difference(s2)\n",
"print(differenz)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Es gibt auch noch die symmetrische Differenzmenge zweier Mengen. Diese enthält alle Elemente, die in einer der beiden Mengen, aber nicht in beiden Mengen enthalten sind."
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{1, 2, 3, 6}\n"
]
}
],
"source": [
"s1 = {1, 3, 4, 5, 2}\n",
"s2 = {4, 5, 6}\n",
"sym_differenz = s1 ^ s2\n",
"print(sym_differenz)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Alternativ können wir für die symmetrische Differenz auch die `set.symmetric_difference()` Methode benutzen."
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{1, 2, 3, 6}\n"
]
}
],
"source": [
"s1 = {1, 3, 4, 5, 2}\n",
"s2 = {4, 5, 6}\n",
"sym_differenz = s1.symmetric_difference(s2)\n",
"print(sym_differenz)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Mit der `set.isdisjoint()` Methode können wir testen ob zwei Mengen disjunkt sind. Zwei Mengen sind disjunkt, wenn ihre Schnittmenge leer ist."
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n",
"True\n"
]
}
],
"source": [
"s1 = {1, 3, 4, 5, 2}\n",
"s2 = {4, 5, 6}\n",
"s3 = {7, 8, 2}\n",
"print(s1.isdisjoint(s2))\n",
"print(s2.isdisjoint(s3))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Mit der `set.issubset()` und der `set.issuperset()` Methode können wir feststellen, ob eine Menge eine Teilmenge, beziehungsweise eine Obermenge einer anderen Menge ist. Eine Menge _s1_ ist Teilmenge einer Menge _s2_, wenn alle Elemente von _s1_ in der Menge _s2_ enthalten sind. _s2_ ist dann die Obermenge von s1."
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Ist s2 eine Teilmenge von s1:\n",
"True\n",
"Ist s1 eine Obermenge von s2:\n",
"True\n"
]
}
],
"source": [
"s1 = {1, 2, 3, 4, 5}\n",
"s2 = {1, 2}\n",
"print(\"Ist s2 eine Teilmenge von s1:\")\n",
"print(s2.issubset(s1))\n",
"print(\"Ist s1 eine Obermenge von s2:\")\n",
"print(s1.issuperset(s2))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Statt der `set.issubset()` Methode können wir auch den `<=` Operator benutzen, statt der `set.issuperset()` Methode können wir auch den `>=` Operator benutzen.\n",
"\n",
"Den `>` Operator können wir benutzen um zu ermitteln, ob eine Menge _s1_ eine _echte_ Obermenge von einer Menge _s2_ ist. Dies ist der Fall, wenn _s1_ eine Obermenge von _s2_ und nicht die gleiche Menge ist.\n",
"\n",
"Den `<` Operator können wir benutzen um zu ermitteln, ob eine Menge _s1_ eine _echte_ Teilmenge einer Menge _s2_ ist. Dies ist der Fall, wenn _s1_ eine Teilmenge von _s2_ ist und nicht die gleiche Menge ist."
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n",
"True\n"
]
}
],
"source": [
"s1 = {1, 2, 3, 4}\n",
"s2 = {1, 2}\n",
"print(s2 < s1)\n",
"print(s1 > s2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## frozenset\n",
"Ein frozenset ist eine 'eingefrorene' Menge, das heißt sie ist unveränderlich. Die grundsätzlichen, oben besprochenen Methoden sind jedoch auch für ein `frozenset` Objekt vorhanden."
]
}
],
"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.12.3"
}
},
"nbformat": 4,
"nbformat_minor": 2
}