{ "cells": [ { "cell_type": "markdown", "id": "883f329a", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "# Vorkurs Tag 3\n", "\n", "Author: Janina Nehring" ] }, { "cell_type": "markdown", "id": "4210428f", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "Übersicht heutiges Programm:\n", "1. Schleifen\n", " * While-Schleifen\n", " * For-Schleifen\n", "2. Listen\n", "3. Tuples\n", "4. Dictionaries\n", "5. For-Each Schleifen " ] }, { "cell_type": "markdown", "id": "fc0c067f", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "# 1. Schleifen\n", "Schleifen (engl. loop) dienen dazu, einen bestimmten Programmteil mehrfach auszuführen. Dabei kann es sich um\n", "einzelne Programmzeilen aber auch um komplexere Einheiten handeln.\n", "\n", "Man unterscheidet oft zwei Schleifen-Arten: `for` und `while`-Schleifen." ] }, { "cell_type": "markdown", "id": "5fa415c9", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "### While-Schleifen\n", "\n", "Eine while-Schleife wird ausgeführt, solange ihre Bedingung wahr (`True`) ist.\n", "Definiert wird eine solche Schleife durch das Schlüsselwort `while`. \n", "\n", "Syntax:\n", "```python\n", "while bedingung:\n", " anweisung_1\n", " anweisung_2\n", " ...\n", "```\n", "Die Schleifenbedingung muss zu einem booleschen Wert auswerten (als `True` oder `False` sein), ansonsten könnt ihr\n", "hier boolesche Operatoren kombinieren wie ihr möchtet.\n", "\n", "Sie wird zu Beginn jedes Durchlaufs geprüft. Solange sie `True` ist, werden die Anweisungen ausgeführt.\n", "Das birgt aber auch ein Fehler, der häufiger auftritt, als einem lieb ist: unendliche Schleifen.\n", "\n", "Ein kleines Beispiel:" ] }, { "cell_type": "code", "execution_count": null, "id": "07f07124", "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "a = 0\n", "while a >= 0:\n", " print(a)\n", " a = a + 1" ] }, { "cell_type": "markdown", "id": "4ad01466", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "Was fällt auf? \n", "-> Die Schleife endet nie! \n", "\n", "Wir haben hier eine sogenannte **Endlos-Schleife** erstellt. \n", "Man muss darauf achten, dass die Schleifenbedingung im Programmverlauf erfüllt wird und die Schleife abbricht. Sonst passiert genau das hier. \n", "\n", "Das gleiche Beispiel mit einer korrekten Bedingung: " ] }, { "cell_type": "code", "execution_count": 2, "id": "34eb5214", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "1\n", "2\n", "3\n", "4\n" ] } ], "source": [ "a = 0\n", "while a < 5:\n", " print (a)\n", " a = a + 1" ] }, { "cell_type": "markdown", "id": "fa2275ca", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "Die Variable `a` wird auch **Schleifenvariable** oder **Laufvariable** genannt, weil die Ausführung der Schleife von ihrem Wert abhängt. \n", "Schleifenvariablen bringen uns schon zum nächsten Thema. " ] }, { "cell_type": "markdown", "id": "f85fcf66", "metadata": {}, "source": [ "### For-Schleifen\n", "\n", "Bei `for`-Schleifen ist im Vorfeld fest, wie oft sie ausgeführt werden. Das geschieht durch eine **Schleifenvariable** (engl. loop counter). \n", "\n", "Syntax: \n", "```python\n", "for index in range(n):\n", " anweisung_1\n", " anweisung_2\n", " ...\n", "``` \n", "`index` bezeichnet hier die Laufvariable, und `n` ist die Anzahl Durchläufe diese Schleife machen soll bevor sie abbricht. \n", "\n", "`range(n)` ist eine Python-Funktion, die dazu dient eine Reihe von Zahlen zu generieren. Die Reihe startet bei 0 und geht bis n: `0`,`1`, ... `n-1`. \n", "\n", "Das Beispiel unten ist äquivalent zu dem Beispiel mit `while` weiter oben:" ] }, { "cell_type": "code", "execution_count": 3, "id": "32b884bc", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "1\n", "2\n", "3\n", "4\n" ] } ], "source": [ "for a in range(5): \n", " print (a)" ] }, { "cell_type": "markdown", "id": "b910fab4", "metadata": {}, "source": [ "`range()` erlaubt es auch, sowohl Start- als auch Endpunkt und die Schrittweise festzulegen: \n", "* `range(start, stop)`: Für eine Zahl `z` ist `start` <= `z` < `stop`" ] }, { "cell_type": "code", "execution_count": 4, "id": "68bc3a6b", "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3\n", "4\n", "5\n", "6\n" ] } ], "source": [ "for index in range(3, 7):\n", " print(index)" ] }, { "cell_type": "markdown", "id": "19530958", "metadata": {}, "source": [ "* `range(start, stop, step)`: `step` gibt die Schrittweite an" ] }, { "cell_type": "code", "execution_count": 5, "id": "7d205990", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10\n", "9\n", "8\n", "7\n", "6\n", "5\n", "4\n", "3\n", "2\n", "1\n", "0\n", "-1\n", "-2\n", "-3\n", "-4\n", "-5\n", "-6\n", "-7\n", "-8\n", "-9\n" ] } ], "source": [ "for index in range(10, -10, -1):\n", " print(index)" ] }, { "cell_type": "markdown", "id": "05804cf0", "metadata": {}, "source": [ "Dabei belassen wir es auch erstmal bei Schleifen. Wir kommen später noch eine besondere Art For-Schleifen zurück. Aber erst betrachten wir einige wichtige Datenstrukturen. " ] }, { "cell_type": "markdown", "id": "0247b77f", "metadata": {}, "source": [ "# 2. Listen\n", "Eine Liste dient dazu, mehrere Elemente (z.B. Variablen) gemeinsam zu speichern. \n", "Listen sind geordnet, sprich die Reihenfolge der Elemente ist fest innerhalb der Liste. \n", "\n", "### Liste erstellen \n", "Eine Liste kann sehr einfach mit eckigen Klammern `[]` erstellt werden. Als Konvention werden oft die Namen der Listen im Plural geschrieben, da sie ja mehrere Elemente enthalten." ] }, { "cell_type": "code", "execution_count": 6, "id": "e0681abb", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[]\n" ] } ], "source": [ "leer = []\n", "print(leer)" ] }, { "cell_type": "code", "execution_count": 7, "id": "5be60c2a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['Fred', 'Yasmin', 'Kilian', 'Erkan']" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "namen = ['Fred', 'Yasmin', 'Kilian', 'Erkan']\n", "namen" ] }, { "cell_type": "markdown", "id": "e0693785", "metadata": {}, "source": [ "Im Gegensatz zu anderen Programmiersprachen erlaubt Python es, mehrere Elemente **unterschiedlichen Typs** in eine Liste zu speichern. " ] }, { "cell_type": "code", "execution_count": 8, "id": "de93566d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['Zero', 42, 0.3, False]" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "gemischt = ['Zero', 42, 0.3, False]\n", "gemischt" ] }, { "cell_type": "markdown", "id": "68763133", "metadata": {}, "source": [ "Eine Liste kann auch andere Listen und Objekte enthalten. " ] }, { "cell_type": "code", "execution_count": 9, "id": "875ef65b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[[49.01594, 8.390639], [48.84941, 2.31333], [30.040034, 31.23529]]" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "koordinaten = [[49.01594, 8.390639], [48.84941, 2.31333], [30.040034, 31.23529]]\n", "koordinaten" ] }, { "cell_type": "markdown", "id": "692d085e", "metadata": {}, "source": [ "### Zugreifen auf Listenelemente\n", "\n", "Um auf ein Element in einer Liste zuzugreifen, nutzt man den `[]`-Operator. " ] }, { "cell_type": "code", "execution_count": 10, "id": "4e3fbb9a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Apfel\n", "Banane\n", "Traube\n" ] } ], "source": [ "fruechte = ['Apfel', 'Banane', 'Maracuja', 'Traube']\n", "\n", "apfel = fruechte[0] # Erstes Element\n", "banane = fruechte[1] # Zweites Element\n", "traube = fruechte[3] # Viertes Element\n", "\n", "print(apfel)\n", "print(banane)\n", "print(traube)" ] }, { "cell_type": "markdown", "id": "08e9ffb0", "metadata": {}, "source": [ "Der Listenindex fängt bei 0 an, weshalb man beim Zugriff mit `list[i]` das `i-1` Element zurückbekommt. " ] }, { "cell_type": "markdown", "id": "a5e7bc19", "metadata": {}, "source": [ "### Listenelemente hinzufügen, verändern und löschen\n", "\n", "Listen sind **veränderbar**, es können Element hinzugefügt, geändert oder auch gelöscht werden, ohne eine neue Liste erstellen zu müssen. " ] }, { "cell_type": "markdown", "id": "79844514", "metadata": {}, "source": [ "#### Listenelemente verändern\n", "\n", "Listenelemente zu verändern ist möglich durch eine Zuweisung: " ] }, { "cell_type": "code", "execution_count": 11, "id": "90bed951", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['Apfel', 'Banane', 'Maracuja', 'Brombeere']" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fruechte = ['Apfel', 'Banane', 'Maracuja', 'Traube']\n", "\n", "fruechte[3] = 'Brombeere' # ersetze das Element an Index 3 (Traube) durch Brombeere\n", "fruechte" ] }, { "cell_type": "markdown", "id": "5caee83a", "metadata": {}, "source": [ "#### Listenelement hinzufügen\n", "\n", "* `.append()` fügt ein Element am Ende ein." ] }, { "cell_type": "code", "execution_count": 12, "id": "d6fe25d7", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['Apfel', 'Banane', 'Maracuja', 'Traube', 'Birne']" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fruechte = ['Apfel', 'Banane', 'Maracuja', 'Traube']\n", "fruechte.append('Birne') \n", "fruechte" ] }, { "cell_type": "markdown", "id": "a06ef68e", "metadata": {}, "source": [ "* `.insert()` fügt ein Element an einer bestimmten Stelle ein. Hier muss man einen Index angeben, an welchem eingefügt werden soll. " ] }, { "cell_type": "code", "execution_count": 13, "id": "17845e74", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['Apfel', 'Banane', 'Maracuja', 'Kiwi', 'Traube']" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fruechte = ['Apfel', 'Banane', 'Maracuja', 'Traube']\n", "fruechte.insert(3, 'Kiwi') # füge Kiwi an 4. Stelle ein\n", "fruechte" ] }, { "cell_type": "markdown", "id": "343b0f98", "metadata": {}, "source": [ "#### Listenelemente entfernen\n", "* `.pop()` entfernt das letzte Element einer Liste und gibt es zurück. " ] }, { "cell_type": "code", "execution_count": 14, "id": "75c01c26", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Traube\n" ] }, { "data": { "text/plain": [ "['Apfel', 'Banane', 'Maracuja']" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fruechte = ['Apfel', 'Banane', 'Maracuja', 'Traube']\n", "\n", "letztes = fruechte.pop()\n", "print(letztes)\n", "\n", "fruechte" ] }, { "cell_type": "markdown", "id": "ebf1fff8", "metadata": {}, "source": [ "`.pop(n)` entfernt das Element an Index `n`: " ] }, { "cell_type": "code", "execution_count": 15, "id": "09dba85a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Banane\n" ] }, { "data": { "text/plain": [ "['Apfel', 'Maracuja', 'Traube']" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fruechte = ['Apfel', 'Banane', 'Maracuja', 'Traube']\n", "\n", "geloescht = fruechte.pop(1)\n", "print(geloescht)\n", "\n", "fruechte" ] }, { "cell_type": "markdown", "id": "c77fb6be", "metadata": {}, "source": [ "* `.remove()` entfernt einen bestimmten Wert aus der Liste. Wenn er mehrmals vorkommt, dann wird nur das erste Vorkommen entfernt. " ] }, { "cell_type": "code", "execution_count": 16, "id": "a3c4bc74", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['Apfel', 'Banane', 'Traube', 'Maracuja']" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fruechte = ['Apfel', 'Banane', 'Maracuja', 'Traube', 'Maracuja']\n", "\n", "fruechte.remove('Maracuja')\n", "fruechte" ] }, { "cell_type": "markdown", "id": "52791966", "metadata": {}, "source": [ "Wenn man versucht, einen Wert zu entfernen, der nicht in der Liste ist, wird ein Fehler ausgegeben. " ] }, { "cell_type": "code", "execution_count": 17, "id": "0b036fbd", "metadata": {}, "outputs": [ { "ename": "ValueError", "evalue": "list.remove(x): x not in list", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", "\u001b[1;32mc:\\Users\\janin\\Documents\\vorkurs-python-content\\Tag_3\\Vorkurs_Tag_3.ipynb Cell 40\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m fruechte \u001b[39m=\u001b[39m [\u001b[39m'\u001b[39m\u001b[39mApfel\u001b[39m\u001b[39m'\u001b[39m, \u001b[39m'\u001b[39m\u001b[39mBanane\u001b[39m\u001b[39m'\u001b[39m, \u001b[39m'\u001b[39m\u001b[39mMaracuja\u001b[39m\u001b[39m'\u001b[39m, \u001b[39m'\u001b[39m\u001b[39mTraube\u001b[39m\u001b[39m'\u001b[39m]\n\u001b[1;32m----> 3\u001b[0m fruechte\u001b[39m.\u001b[39;49mremove(\u001b[39m'\u001b[39;49m\u001b[39mErdbeere\u001b[39;49m\u001b[39m'\u001b[39;49m)\n\u001b[0;32m 4\u001b[0m fruechte\n", "\u001b[1;31mValueError\u001b[0m: list.remove(x): x not in list" ] } ], "source": [ "fruechte = ['Apfel', 'Banane', 'Maracuja', 'Traube']\n", "\n", "fruechte.remove('Erdbeere')\n", "fruechte" ] }, { "cell_type": "markdown", "id": "980ef9d0", "metadata": {}, "source": [ "### Suche nach Listenelementen\n", "\n", "Mit der `.index()`-Funktion kann man gezielt nach einem Wert in einer Liste suchen. Die Funktion gibt dann den Index des gesuchten Werts in der Liste zurück." ] }, { "cell_type": "code", "execution_count": 18, "id": "61a24205", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fruechte = ['Apfel', 'Banane', 'Maracuja', 'Traube']\n", "fruechte.index('Traube')" ] }, { "cell_type": "markdown", "id": "c7968455", "metadata": {}, "source": [ "# 3. Tupel\n", "\n", "Tupel kennt ihr vielleicht aus der Mathematik. \n", "\n", "In Python sind Tupel (engl. tuple) ähnlich zu Listen, sie speichern eine **geordnete** Menge an Elementen. Allerdings können _sie nicht mehr verändert werden_, nachdem sie erstellt sind. Sie sind **unveränderbar**.\n", "\n", "Tupel werden mit runden Klammern `()` erstellt: " ] }, { "cell_type": "code", "execution_count": 19, "id": "3528c7f3", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "('Karlsruhe', 'Mannheim', 'Freiburg')" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "staedte = ('Karlsruhe', 'Mannheim', 'Freiburg')\n", "staedte" ] }, { "cell_type": "markdown", "id": "08b2c066", "metadata": {}, "source": [ "Der Zugriff auf die Elemente passiert analog zu Listen mit den eckigen Klammern `[]`: " ] }, { "cell_type": "code", "execution_count": 20, "id": "467ae9d9", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'Mannheim'" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "stadt = staedte[1]\n", "stadt" ] }, { "cell_type": "markdown", "id": "32a6eba5", "metadata": {}, "source": [ "Was hingegen nicht geht, ist das Verändern des Tupel und der darin gespeicherten Werte: " ] }, { "cell_type": "code", "execution_count": 21, "id": "7677d459", "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "'tuple' object does not support item assignment", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[1;32mc:\\Users\\janin\\Documents\\vorkurs-python-content\\Tag_3\\Vorkurs_Tag_3.ipynb Cell 48\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[0m staedte[\u001b[39m1\u001b[39m] \u001b[39m=\u001b[39m \u001b[39m'\u001b[39m\u001b[39mStuttgart\u001b[39m\u001b[39m'\u001b[39m\n", "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment" ] } ], "source": [ "staedte[1] = 'Stuttgart'" ] }, { "cell_type": "code", "execution_count": null, "id": "7fe4e885", "metadata": {}, "outputs": [ { "ename": "AttributeError", "evalue": "'tuple' object has no attribute 'append'", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", "\u001b[1;32mc:\\Users\\janin\\OneDrive\\Dokumente\\Workspace\\Studies\\22-23_WS\\Vorkurs\\vorkurs-python-content\\Tag_3\\Vorkurs_Tag_3.ipynb Cell 47\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[0m staedte\u001b[39m.\u001b[39;49mappend()\n", "\u001b[1;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'append'" ] } ], "source": [ "staedte.append()" ] }, { "cell_type": "markdown", "id": "6537ca45", "metadata": {}, "source": [ "# 4. Dictionaries\n", "\n", "Dictionaries speichern Schlüssel/Wert-Paare (engl. key-value-pairs). Jedem Schlüssel ist mit einem Wert assoziiert. Der Schlüssel darf deshalb **nicht verändert** werden und muss **einzigartig** sein. \n", "Der Wert kann hingegen beliebigen Typ haben und verändert werden. \n", "\n", "### Dictionary erstellen\n", "Dictionaries werden mit geschweiften Klammern `{}` definiert. Einzelne Paare müssen mit Kommas getrennt werden. \n" ] }, { "cell_type": "code", "execution_count": 22, "id": "d320ab94", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{}" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "leeres_dict = {}\n", "leeres_dict" ] }, { "cell_type": "code", "execution_count": 23, "id": "8011ab39", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'vorname': 'William',\n", " 'nachname': 'Schmidt',\n", " 'matrikelnummer': 80000,\n", " 'zurueckgemeldet': True,\n", " 'bestandene_faecher': ['Informatik 1', 'Mathematik 1']}" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "studi = {\n", " 'vorname': 'William',\n", " 'nachname': 'Schmidt',\n", " 'matrikelnummer': 80000,\n", " 'zurueckgemeldet': True,\n", " 'bestandene_faecher': ['Informatik 1', 'Mathematik 1']\n", "}\n", "studi" ] }, { "cell_type": "code", "execution_count": 24, "id": "34db73ac", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'vorname': 'Schmidt',\n", " 'matrikelnummer': 80000,\n", " 'zurueckgemeldet': True,\n", " 'bestandene_faecher': ['Informatik 1', 'Mathematik 1']}" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "studi = {\n", " 'vorname': 'William',\n", " 'vorname': 'Schmidt',\n", " 'matrikelnummer': 80000,\n", " 'zurueckgemeldet': True,\n", " 'bestandene_faecher': ['Informatik 1', 'Mathematik 1']\n", "}\n", "studi" ] }, { "cell_type": "markdown", "id": "6a572799", "metadata": {}, "source": [ "### Zugreifen auf Werte\n", "Der Zugriff auf gespeicherte Werte funktioniert über den Schlüssel und mit eckigen Klammern `[]`: " ] }, { "cell_type": "code", "execution_count": 25, "id": "f0e41000", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'Schmidt'" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "studi['vorname']" ] }, { "cell_type": "markdown", "id": "e2479002", "metadata": {}, "source": [ "### Dictionary verändern\n", "Wie Listen sind Dictionaries **veränderbar**.\n", "#### Ändern eines Wertes\n", "Werte in Dictionaries können ohne Probleme geändert werden. Das geht analog zur Liste mit dem `[]`-Operator und einer Zuweisung. \n", "\n", "Syntax: \n", "```python\n", "dict[key] = new_value\n", "```" ] }, { "cell_type": "code", "execution_count": 26, "id": "20d40ab3", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'vorname': 'William',\n", " 'nachname': 'Maier',\n", " 'matrikelnummer': 80000,\n", " 'zurueckgemeldet': True,\n", " 'bestandene_faecher': ['Informatik 1', 'Mathematik 1']}" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "studi = {\n", " 'vorname': 'William',\n", " 'nachname': 'Schmidt',\n", " 'matrikelnummer': 80000,\n", " 'zurueckgemeldet': True,\n", " 'bestandene_faecher': ['Informatik 1', 'Mathematik 1']\n", "}\n", "\n", "studi['nachname'] = 'Maier'\n", "studi" ] }, { "cell_type": "markdown", "id": "6c30db06", "metadata": {}, "source": [ "#### Löschen von Schlüssel-Wert-Paaren\n", "\n", "Um einen bestimmten Schlüssel und dessen assoziierten Wert zu löschen wird das `del`-Schlüsselwort verwendet. \n", "\n", "Syntax: \n", "```python\n", "del dict[key]\n", "```" ] }, { "cell_type": "code", "execution_count": 27, "id": "a6e3d342", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'vorname': 'William',\n", " 'nachname': 'Schmidt',\n", " 'matrikelnummer': 80000,\n", " 'bestandene_faecher': ['Informatik 1', 'Mathematik 1']}" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "studi = {\n", " 'vorname': 'William',\n", " 'nachname': 'Schmidt',\n", " 'matrikelnummer': 80000,\n", " 'zurueckgemeldet': True,\n", " 'bestandene_faecher': ['Informatik 1', 'Mathematik 1']\n", "}\n", "\n", "del studi['zurueckgemeldet'] \n", "studi" ] }, { "cell_type": "markdown", "id": "a53fe5f7", "metadata": {}, "source": [ "#### Hinzufügen von Schlüssel-Wert-Paaren\n", "Das Hinzufügen von neuen Paaren funktioniert relativ einfach mit einer Zuweisung auf einen neuen Schlüssel. Dieser darf allerdings noch nicht im Dictionary existieren, da sonst bei dem exisitierenden Schlüssel lediglich der Wert überschrieben wird. \n", "\n", "Syntax: \n", "```python\n", " dict[new_key] = new_value\n", "```" ] }, { "cell_type": "code", "execution_count": 28, "id": "1257fdfa", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'vorname': 'William',\n", " 'nachname': 'Schmidt',\n", " 'matrikelnummer': 80000,\n", " 'zurueckgemeldet': True,\n", " 'bestandene_faecher': ['Informatik 1', 'Mathematik 1'],\n", " 'geburtstag': '2000-10-21'}" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "studi = {\n", " 'vorname': 'William',\n", " 'nachname': 'Schmidt',\n", " 'matrikelnummer': 80000,\n", " 'zurueckgemeldet': True,\n", " 'bestandene_faecher': ['Informatik 1', 'Mathematik 1']\n", "}\n", "\n", "studi['geburtstag'] = '2000-10-21'\n", "\n", "studi" ] }, { "cell_type": "markdown", "id": "52c7a418", "metadata": {}, "source": [ "# 5. For-Each Schleifen\n", "\n", "For-Each-Schleifen sind eine besondere Art von For-Schleifen, die sich dadurch auszeichnen, dass man damit über Sammlungen von Elementen iterieren kann. Das können zum Beispiel Listen, Tupel oder auch Dictionaries sein. \n", "\n", "Die Syntax ist sehr ähnlich zu normalen For-Schleifen: \n", "```python\n", "for item in list:\n", " anweisung_1\n", " anweisung_2\n", "```\n", "Für jeden Durchlauf wird `item` sukzessive die verschiedenen Elemente der Liste zugewiesen. Innerhalb der Schleife kann man dann jedes Element bearbeiten.\n", "\n", "Beispiel: " ] }, { "cell_type": "code", "execution_count": 29, "id": "fcb812d8", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Apfel\n", "Banane\n", "Maracuja\n", "Traube\n" ] } ], "source": [ "fruechte = ['Apfel', 'Banane', 'Maracuja', 'Traube']\n", "\n", "for frucht in fruechte:\n", " print(frucht)\n", " " ] }, { "cell_type": "code", "execution_count": 30, "id": "8a49f40a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['Apfel', 'Banane', 'Maracuja', 'Traube']" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fruechte" ] }, { "cell_type": "markdown", "id": "14ff396f", "metadata": {}, "source": [ "Manchmal will man aber trotzdem Indizes in der Schleife haben. Dafür kann man die `enumerate()`-Funktion verwenden. Sie erstellt ein Tupel aus Index und Wert. " ] }, { "cell_type": "code", "execution_count": 31, "id": "98f216f5", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(0, 'Karlsruhe')\n", "(1, 'Mannheim')\n", "(2, 'Freiburg')\n" ] } ], "source": [ "staedte = ('Karlsruhe', 'Mannheim', 'Freiburg')\n", "\n", "for stadt in enumerate(staedte): \n", " print(stadt)" ] }, { "cell_type": "markdown", "id": "c490f9ba", "metadata": {}, "source": [ "Für Dictionaries muss man angeben, ob man über die Elemente, die Schlüssel oder die Werte iterieren möchte. \n", "\n", "Um über alle Elemente zu iterieren muss man die `.items()`-Funktion verwenden. Diese gibt die key-value-Paare als Tupel zurück. " ] }, { "cell_type": "code", "execution_count": 32, "id": "3eb79b73", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "('vorname', 'William')\n", "('nachname', 'Schmidt')\n", "('matrikelnummer', 80000)\n", "('zurueckgemeldet', True)\n", "('bestandene_faecher', ['Informatik 1', 'Mathematik 1'])\n" ] } ], "source": [ "studi = {\n", " 'vorname': 'William',\n", " 'nachname': 'Schmidt',\n", " 'matrikelnummer': 80000,\n", " 'zurueckgemeldet': True,\n", " 'bestandene_faecher': ['Informatik 1', 'Mathematik 1']\n", "}\n", "\n", "for item in studi.items():\n", " print(item)" ] }, { "cell_type": "markdown", "id": "5f4669d6", "metadata": {}, "source": [ "Über die Schlüssel zu iterieren funktioniert analog mit der `.keys()`-Funktion. Das ist das Standard-Verhalten wenn man über Dictionaries iteriert, ohne wie hier ein Verhalten zu bestimmen." ] }, { "cell_type": "code", "execution_count": 33, "id": "16397856", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "vorname\n", "nachname\n", "matrikelnummer\n", "zurueckgemeldet\n", "bestandene_faecher\n" ] } ], "source": [ "for key in studi.keys():\n", " print(key)" ] }, { "cell_type": "markdown", "id": "42dfc45b", "metadata": {}, "source": [ "Über die Werte zu iterieren geht mit der `.values()`-Funktion: " ] }, { "cell_type": "code", "execution_count": 34, "id": "66967777", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "William\n", "Schmidt\n", "80000\n", "True\n", "['Informatik 1', 'Mathematik 1']\n" ] } ], "source": [ "for value in studi.values():\n", " print(value)" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3.9.12 ('base')", "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.9.12" }, "vscode": { "interpreter": { "hash": "ad2bdc8ecc057115af97d19610ffacc2b4e99fae6737bb82f5d7fb13d2f2c186" } } }, "nbformat": 4, "nbformat_minor": 5 }