{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Listen (Lösungenb)\n", "\n", "Eine Liste ist eine Datenstruktur, die es erlaubt, mehrere Elemente unter demselben Bezeichner abzulegen. Im Gegensatz dazu kann eine Variable genau einen Wert enthalten.\n", "\n", "Sie können sich Listen vorstellen wie eine Schublade mit mehreren Fächern. Auf diese Fächer können Sie zugreifen und deren Inhalte auslesen oder verändern. Der Zugriff auf die einzelnen Elemente der Liste erfolgt über Indizes, wobei das erste Element in den meisten Sprachen den Index 0 hat.\n", "\n", "Eine Liste wird mit eckigen Klammern markiert.\n", "\n", "---\n", "**Ziele**\n", "\n", "* Listen\n", " * Sie kennen das Konzept von Listen als sequentielle Datenstruktur zum Speichern mehrerer Werte.\n", "* Listen in Python\n", " * Sie können\n", " * Listen erstellen (auf zwei Arten), \n", " * Listen verändern (Elemente auslesen, einfügen, löschen),\n", " * auf Teilbereiche von Listen zugreifen sowie\n", " * über Listen iterieren.\n", " * Sie wissen, dass Strings wie Listen sequentielle Datentypen sind und auf Teile von Strings zugegriffen werden kann wie auf Listenelemente.\n", " \n", "* Weitere sequentielle Datentypen\n", " * Strings\n", " * Sie können auf Zeichen von Strings zugreifen wie auf Listenelemente.\n", " * Tupel\n", " * Sie kennen den Unterschied zwischen Listen und Tupel.\n", "---\n", "\n", "## Listen\n", "\n", "Die Sprache Python bietet anstelle der in anderen Sprachen üblichen Arrays **Listen** an. \n", "\n", "Speziell an Listen in Python ist, dass sie Elemente verschiedener Datentypen enthalten dürfen, was in den meisten Sprachen nicht erlaubt ist. Ausserdem kann mit Listen nicht gerechnet werden. Es gibt aber Bibliotheken, die Arrays zur Verfügung stellen, mit denen gerechnet werden kann. Diese werden hier noch nicht verwendet.\n", "\n", "Merken Sie sich einfach folgendes:\n", "\n", "**Listen in Python enthalten eine Sammlung von Elementen, die verändert werden kann.\n", "Die Elemente einer Liste müssen nicht zwingend vom gleichen Datentyp sein.**\n", "\n", "### Beispiele\n", "\n", "* Alphabet: \n", " ```Python \n", " alphabet = [\"a\", \"b\", \"c\", \"d\", \"e\", \"f\", \"g\", \"h\", \"i\", \"j\", \"k\", \"l\", \"m\", \"n\", \"o\", \"p\", \"q\", \"r\", \"s\", \"t\", \"u\", \"v\", \"w\", \"x\", \"y\", \"z\"]\n", "```\n", "* Fünferreihe: \n", "```Python \n", "fuenferreihe = [5, 10, 15, 20, 25, 30, 35, 40, 45, 50]\n", "```\n", "* Brüche (1/2 bis 1/10) als Fliesskommazahlen:\n", "```Python \n", "brueche = [0.5, 0.333, 0.25, 0.2, 0.1667, 0.143, 0.125, 0.111, 0.1]\n", "```\n", "* Aber auch das ist erlaubt:\n", "```Python \n", "ada_lovelaces_geburtstag = [10, Dezember, 1815] # Gilt als erste Programmiererin überhaupt\n", "```\n", " (Passend zu diesem Beispiel: Ein interessanter Film über Ada Lovelace auf [SRF MySchool](https://www.srf.ch/sendungen/myschool/ada-lovelace-die-erste-programmiererin-2))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Erstellen einer Liste\n", "\n", "Listen werden mit eckigen Klammern gekennzeichnet, die Elemente werden durch Kommata separiert.\n", "\n", "Die Namen (Bezeichner) der Listen fangen mit Kleinbuchstaben an. Das ist zwar nicht zwingend, aber da Ihr Code lesbar sein soll, sollten Sie sich von Anfang daran halten.\n", "\n", "**Aufgabe 1**\n", "\n", "Erstellen Sie eine Liste namens `dreierreihe`, welche die ersten zehn Elemente der Dreierreihe enthält.\n", "\n", "
\n", " Hinweis 1\n", "\n", "Listen sind zwar keine Variablen, werden aber ebenfalls durch einen Bezeichner benannt. Diesem sind anstelle eines einzelnen Werts eine Sammlung von Elementen zugeordnet.
\n", "\n", "
\n", " Hinweis 2\n", "\n", "Eine Liste namens `erste_buchstaben`, welche die Elemente \"A\" und \"B\" enthält, würde wie folgt erstellt:\n", " \n", "```Python\n", " erste_buchstaben = [\"A\", \"B\"]\n", "```\n", "
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Ihr Code..." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Lösung:\n", "\n", "dreierreihe = [3, 6, 9, 12, 15, 18, 21, 24, 27, 30]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Ausgabe einer Liste\n", "\n", "Listen können mit der Funktion `print()` ausgegeben werden.\n", "\n", "**Aufgabe 2**\n", "\n", "Geben Sie Ihre Liste `dreierreihe` aus." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Ihr Code..." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Lösung:\n", "\n", "print(dreierreihe)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Leere Liste\n", "\n", "Eine Liste muss nicht zwingend ein Element enthalten.\n", "\n", "*Eine Liste, die kein Element enthält, ist per Definition leer.*\n", "\n", "**Aufgabe 3**\n", "\n", "Erstellen Sie eine leere Liste namens `leere_liste` und geben Sie sie aus." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Ihr Code..." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Lösung:\n", "\n", "leere_liste = []\n", "print(leere_liste)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Länge einer Liste\n", "\n", "Die Funktion `len()` gibt die Länge einer Liste zurück.\n", "\n", "Eine leere Liste hat die Länge 0.\n", "\n", "**Aufgabe 4**\n", "\n", "Überprüfen Sie die Längen der bisher erstellten Listen `dreierreihe` und `leere_liste`. Welche Ausgaben erwarten Sie? Schreiben Sie sie entweder als Kommentar neben den Code, machen Sie eine Zelle oder schreiben Sie ans Ende dieser Zelle.\n", "\n", "Nutzen Sie die Funktion `print()`, um die Längen auszugeben." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Ihr Code..." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Lösung:\n", "\n", "laenge1 = len(dreierreihe) \n", "# Ich erwarte den Wert 10, da ich 10 Elemente in die Liste geschrieben habe.\n", "print(\"Länge dreierreihe:\", laenge1)\n", "\n", "laenge2 = len(leere_liste) \n", "# Ich erwarte den Wert 0, die Liste leer ist.\n", "print(\"Länge leere_liste:\", laenge2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Aufgabe 5**\n", "\n", "Erstellen Sie eine Liste `monate`, welche die Namen der Monate enthält und geben Sie sie aus.\n", "\n", "Die Ausgabe soll folgendermassen aussehen:\n", "\n", "\\['Januar', 'Februar', 'März', 'April', 'Mai', 'Juni', 'Juli', 'August', 'September', 'Oktober', 'November', 'Dezember'\\]\n", "\n", "\n", "
\n", " Hinweis\n", "\n", "Überlegen Sie sich, welchen Datentyp Sie für die Monatsnamen verwenden müssen.\n", "
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Ihr Code..." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Lösung:\n", "\n", "monate = ['Januar', 'Februar', 'März', 'April', 'Mai', 'Juni', 'Juli', 'August', 'September', 'Oktober', 'November', 'Dezember']\n", "\n", "print(monate)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Indexierung\n", "\n", "Listen sind **indexiert** – der **Zugriff auf Elemente einer Liste** erfolgt über Indizes.\n", "\n", "Das erste Element einer Liste `liste` hat den Index 0, das letzte den Index `len(liste)-1`.\n", "\n", "**Aufgabe 6**\n", "\n", "Geben Sie den ersten und den letzten Monat aus, indem Sie den folgenden Code ergänzen:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Ergänzen Sie den folgenden Code:\n", "\n", "erster_monat = ''\n", "letzter_monat = ''\n", "\n", "print(\"Das Jahr geht von\", erster_monat, \"bis\", letzter_monat + \".\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Lösung:\n", "\n", "erster_monat = monate[0] # die '' waren nur, damit die Variablen einen Wert hatten. Nun werden sie verändert:\n", "letzter_monat = monate[len(monate)-1]\n", "\n", "print(\"Das Jahr geht von\", erster_monat, \"bis\", letzter_monat + \".\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Zugriff vom Ende der Liste her\n", "\n", "Es ist auch möglich, mittels negativen Indizes von hinten her auf eine Liste zuzugreifen.\n", "\n", "Dabei entspricht das letzte Listenelement dem Index `-1`.\n", "\n", "```Python\n", "letzter_monat = monate[-1]\n", "print(letzter_monat)\n", "```\n", "Führt zur Ausgabe: `Dezember`." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Probieren Sie es aus..." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "letzter_monat = monate[-1]\n", "print(letzter_monat)\n", "zweitletzter_monat = monate[-2]\n", "print(zweitletzter_monat)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Zugriff auf Bereiche einer Liste mittels Teilbereichsoperator [start:stop:step]\n", "\n", "Es ist auch möglich, auf Bereiche einer Liste zuzugreifen. Listen lassen sich mit ':' aufteilen (splitten). Man spricht dabei auch von \"Slicing\".\n", "\n", "Der Teilbereichsoperator verwendet Defaultwerte (Standardwerte, die verwendet werden, wenn nichts anderes angegeben ist). Ist nichts angeben wird die ganze Liste mit einer Schrittlänge von `step=1` ausgegeben. `start` entspricht somit dem Index 0, `stop` der Länge. Somit entspricht `liste[:]`der ganzen Liste.\n", "\n", "\n", "\n", "Am Beispiel der Monate:\n", "\n", "* alle Monate:\n", " ```Python \n", " print(monate[:]) \n", " ``` \n", " Ausgabe: \\['Januar', 'Februar', 'März', 'April', 'Mai', 'Juni', 'Juli', 'August', 'September', 'Oktober', 'November', 'Dezember'\\]\n", " \n", "* die zweite Jahreshälfte: \n", " ```Python \n", " print(monate[len(monate)//2:]) # Ganzzahlige Division, weil Indizes ganzzahlig sein müssen.\n", " ``` \n", " Ausgabe: \\['Juli', 'August', 'September', 'Oktober', 'November', 'Dezember'\\]\n", "\n", "**Aufgabe 7**\n", "\n", "Geben Sie die verlangten Teile Ihrer Liste `monate` mit der Funktion `print()` aus:\n", "\n", "a) Monate mit Jahreszeitwechsel:\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Ihr Code..." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Lösung:\n", "\n", "# Der erste Monat mit Jahreszeitenwechsel ist der März. Er ist am Index 2. \n", "# Da es in 12 Monaten 4 Jahreszeitenwechsel gibt, muss die Schrittweite 3 betragen.\n", "\n", "print(monate[2::3]) # monate[2:12:3] oder monate[2:len(monate):3] wären ebenfalls korrekt." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "b) Jeden zweiten Monat, aber die mit den ungeraden Indizes:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Ihr Code..." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Lösung:\n", "\n", "# Da nur jeder zweite Monat ausgegeben werden soll, muss die Schrittweite 2 betragen.\n", "# Für die geraden Indizes könnte bei null angefangen werden.\n", "# Für die ungeraden Indizes muss bei eins angefangen werden.\n", "\n", "print(monate[1::2]) # monate[2:12:3] oder monate[2:len(monate):3] wären ebenfalls korrekt." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Iteration (Listendurchlauf) \n", "\n", "Da die Listenelemente aufsteigend indiziert sind, bietet es sich an, Listen mit Schleifen zu durchlaufen, deren Laufvariablen den Indizes entsprechen. \n", "\n", "Nicht umsonst wird die Laufvariable oft mit `i` (für Index) bezeichnet...\n", "\n", "#### Repetition For-Schleife\n", "\n", "Erinnern Sie sich an die Syntax einer `for`-Schleife:\n", "```Python\n", "for laufvariable in range (erstes_element, letztes_element):\n", " # Schleifenkörper\n", "```\n", "\n", "Beachten Sie:\n", "\n", "Die `laufvariable` durchläuft den Bereich `range` vom ersten *bis und ohne* das letzte Element, nimmt also die Werte `erstes_element` bis `letztes_element-1` an.\n", "\n", "\n", "\n", "**Aufgabe 8**\n", "\n", "Sie haben bereits die Liste `dreierreihe` erstellt. Durchlaufen Sie nun diese Liste (oft spricht man auch davon \"über eine Liste zu *iterieren*\") und geben Sie jedes Element aus." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Ihr Code..." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Lösung:\n", "\n", "# Variante 1: mit einer Laufvariable, die alle Werte aus dem BEREICH annimmt.\n", "print(\"Variante 1\")\n", "for i in range(len(dreierreihe)):\n", " print(dreierreihe[i])\n", "\n", "# Variante 2: mit einer Laufvariable, die alle Werte aus der LISTE annimmt.\n", "print(\"Variante 2\")\n", "for element in dreierreihe:\n", " print(element)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Erstellen einer Liste mit Einheitswerten\n", "\n", "Oft ist es nützlich eine Liste mit einer vorgegebenen Länge zu erstellen und diese mit Einheitswerten, beispielsweise Nullen, zu initialisieren.\n", "\n", "Dazu machen Sie sich den Listendurchlauf zunutze:\n", "\n", "```Python\n", "zehn_nullen = [0 for x in range(10)]\n", "print(zehn_nullen)\n", "```\n", "\n", "erstellt eine Liste mit Namen `zehn_nullen`, die zehn Nullen enthält: \\[0, 0, 0, 0, 0, 0, 0, 0, 0, 0\\].\n", "\n", "*`for x in range(10)` bedeutet, dass die Laufvariable $x$ alle Werte von 0 bis und ohne 10 annimmt*.\n", "\n", "Dieses Vorgehen wird Listenabstraktion (List Comprehension) genannt und eignet sich besonders zum Erstellen grosser Listen.\n", "\n", "**Aufgabe 9**\n", "\n", "Erstellen Sie eine Liste, die fünfmal Ihre Lieblingszahl enthält." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Ihr Code..." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Lösung:\n", "\n", "lieblingszahl = [2 for x in range(5)]\n", "\n", "print(lieblingszahl)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Erstellen einer Liste mit Werten, die anhand einer Funktion ermittelt werden\n", "\n", "Listenabstraktionen sind vor allem auch hilfreich, wenn die Liste Elemente enthalten soll, welche mit einer Funktion erstellt werden können.\n", "\n", "Anstelle des Einheitswertes kann auch eine Funktion verwenden werden, mit der die Listenwerte erstellt werden.\n", "\n", "Eine aufsteigende Liste \n", "```Python\n", "aufsteigend = [x for x in range(10)]\n", "print(aufsteigend)\n", "```\n", "erstellt eine Liste mit den Zahlen von 0 bis und ohne 10:\n", "\\[0, 1, 2, 3, 4, 5, 6, 7, 8, 9\\]\n", "\n", "**Aufgabe 10**\n", "\n", "Sortieralgorithmen möchte man oft auch an Listen testen, die entweder dem Idealfall entsprechen (also sortiert sind) oder die schlechtestmögliche Ausgangslage darstellen (also umgekehrt sortiert sind: nicht zwei Elemente innerhalb de Liste sind sortiert).\n", "\n", "Erstellen Sie eine absteigende Liste `absteigend`, die ebenfalls 10 Elemente enthält und geben Sie sie mit der `print()`-Funktion aus.\n", "\n", "
\n", " Hinweis\n", "\n", "Im Beispiel sehen Sie, wie eine aufsteigende Liste generiert wird: \n", "Für jedes Element entspricht der Wert dem Index `x`.\n", "
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Ihr Code..." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Lösung:\n", "\n", "absteigend = [-x for x in range(10)] # Dies könnte Ihnen reichen.\n", "print(absteigend)\n", "\n", "# Die Liste absteigend enthält nun die Werte y = f(x) mit f(x) = -x, x Element [0,10). \n", "# Falls Sie lieber Werte >= 0 in Ihrer Liste haben möchten, können Sie die Funktion entsprechend anpassen:\n", "\n", "absteigend2 = [9-x for x in range(10)] # Dies könnte Ihnen reichen.\n", "print(absteigend2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Challenge** \n", "\n", "Erstellen Sie die beiden Listen `gerade` und `ungerade`, welche die ersten zehn geraden bzw. ungeraden Ganzzahlen ($\\in {\\rm I\\!N}_0$) enthalten." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Ihr Code..." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Lösung:\n", "\n", "gerade = [2*x for x in range(10)]\n", "print(\"gerade: \", gerade)\n", "\n", "ungerade = [2*x+1 for x in range(10)]\n", "print(\"ungerade: \", ungerade)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Strings\n", "\n", "Strings, also Zeichenketten, verhalten sich genauso wie Listen.\n", "\n", "Dies ist interessant, da es dadurch möglich ist, auf einzelne Buchstaben (Elemente) des Strings zuzugreifen. Der erste Buchstabe ist wie bei der Liste am Index 0.\n", "\n", "Das folgende Beispiel gibt eine Initiale aus.\n", "\n", "```Python\n", "mein_name = \"\"\n", "meine_initiale = mein_name[0]\n", "print(meine_initiale)\n", "```\n", "**Aufgabe 11**\n", "\n", "Fragen Sie die Benutzerin (den Benutzer) nach seinem (ihrem) Namen und geben Sie anschliessend die Initiale aus." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Ihr Code..." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Lösung:\n", "\n", "name = input(\"Wie heissen Sie? \")\n", "initiale = name[0]\n", "print(\"Ihre Initiale ist\", initiale + \".\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Auch die Länge eines Wortes oder eines Satzes lässt sich wie im Falle der Liste mit der Funktion `len()` ermitteln." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Zusatzinformation zu Strings**\n", "\n", "Mit den Funktionen `upper()` und `lower()` können Zeichenketten in Gross- bzw. Kleinschreibung umgewandelt werden. Dies hat zwar nichts mit Listen zu tun, kann aber hilfreich sein, beispielsweise, wenn Sie sicherstellen möchten, dass jedes Wort grossgeschrieben ist.\n", "\n", "Die Funktionen `isupper()` und `islower()` liefern Booleans zurück, die sagen, ob es sich bei *allen* Zeichen im String um Gross- bzw. Kleinbuchstaben handelt.\n", "\n", "```Python\n", "string1 = \"abc\"\n", "string1.isupper() # gibt False zurück\n", "string1.islower() # gibt True zurück\n", "string1.upper() # ändert den Inhalt der Variable string1 auf `ABC`\n", "\n", "string2 = \"ABC\"\n", "string2.isupper() # gibt True zurück\n", "string2.islower() # gibt False zurück\n", "string2.lower() # ändert den Inhalt der Variable string2 auf `abc`\n", "\n", "string3 = \"AbC\"\n", "string3.isupper() # gibt False zurück\n", "string3.islower() # gibt False zurück\n", "string3.lower() # ändert den Inhalt der Variable string3 auf `abc`\n", "string3.upper() # ändert den Inhalt der Variable string3 auf `ABC`\n", "```" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Probieren Sie's aus." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Weiterführende Informationen\n", "\n", "Zu Listen in Python gibt es noch viel zu sagen.\n", "\n", "### Einfügen und Löschen von Listenelementen\n", "\n", "Es ist möglich, Listenelemente einzufügen oder zu löschen.\n", "\n", "Hierzu können Sie die folgenden Funktionen verwenden:\n", "\n", "* `append(element)`: Hängt ein Element `element` am Ende der Liste an.\n", "* `pop(index)`: Löscht das Element am Index `index` und gibt es zurück.\n", "* `insert(element, index)` Fügt ein Element `element` an der Stelle `index` in die Liste ein." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "wochentage = [\"Montag\", \"Dienstag\", \"Mittwoch\", \"Donnerstag\", \"Freitag\", \"Samstag\", \"Sonntag\"]\n", "print(wochentage)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Läuft Ihnen auch immer die Zeit davon? \n", "\n", "Sie möchten sich nun einen Gefallen machen und die Woche um einen Tag verlängern. Dazu fügen Sie am Ende der Liste einen Bonustag ein:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "wochentage.append(\"Bonustag\")\n", "print(wochentage)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Das Leben ist hart, der Bonustag muss wieder weg, weil er einfach keinen Platz hat in der Woche:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "wochentage.pop(len(wochentage)-1)\n", "print(wochentage)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Wie würden denn die Woche aussehen, wenn nach dem Dienstag ein Bonustag eingeschoben würde?" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "wochentage.insert(2, \"Bonustag\")\n", "print(wochentage)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Elemente von Listen\n", "\n", "Wie Sie bereits gesehen haben, müssen nicht alle Elemente einer Liste vom gleichen Datentyp sein. Es kommt aber noch dicker, denn es ist in Python auch möglich, dass einzelne (oder sämtliche) Elemente einer Liste selbst Listen oder auch Tupel beinhalten.\n", "\n", "Sehen Sie selbst:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "ziemlich_wirre_liste = [1, (2,3,4), \"a\", [\"ham\", \"spam\", \"pram\", 42], 1.05, True, [\"sowas aber auch!\", [], True, \"Das ist tatsächlich erlaubt...\"]]\n", "print(ziemlich_wirre_liste)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Dimensionalität\n", "\n", "Die Listen, die Sie bisher gesehen haben, waren bis auf das letzte Beispiel eindimensional. Listen können aber auch zwei- oder mehrdimensional sein. Sie werden dies in diesem Kurs nicht sehen, aber das Konzept ist nicht schwierig: In einer zweidimensionalen Liste besteht jedes Element aus einer Liste. Sie können damit eine Art Tabelle darstellen, die reihenweise aufgebaut wird.\n", "\n", "Da mehrdimensionale Listen hier nicht relevant sind, wird an dieser Stelle nicht weiter darauf eingegangen.\n", "\n", "\n", "### Tupel\n", "\n", "Wie Listen sind auch Tupel *sequentielle Datenstrukturen*. \n", "\n", "Im Gegensatz zu Listen können Sie nicht verändert werden. Sie können sich Tupel wie etwas gedrucktes vorstellen, das nicht veränderbar ist, aber das Sie anschauen können.\n", "\n", "Die Elemente der Tupel sind wie die Elemente der Liste indiziert, Sie greifen also auf Elemente eines Tupels gleich zu wie auf Elemente einer Liste.\n", "\n", "Syntaktisch besteht der Unterschied in der Art der Klammern: Tupel werden mit runden Klammern geschrieben:\n", "\n", "```Python\n", "mein_tupel = (1,2,3,4)\n", "```\n", "\n", "`mein_tupel[0]` würde somit 1 ausgeben." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "mein_tupel = (1,2,3,4)\n", "mein_tupel[0]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Tupel sind nicht veränderbar**\n", "\n", "Wenn Sie versuchen, ein Tupel zu verändern, bekommen Sie einen Fehler.\n", "\n", "```Python\n", "mein_tupel[0] = 10\n", "```\n", "\n", "Führt zu folgender Fehlermeldung:\n", "\n", "TypeError: 'tuple' object does not support item assignment" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Probieren Sie es aus." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Funktion Enumerate\n", "\n", "Sehr interessant ist auch die Funktion `enumerate(liste, startindex)`.\n", "\n", "```Python\n", "for index, wert in enumerate(liste, startindex):\n", " print(index, wert)\n", "```\n", "\n", "Der `startindex` ist optional, sein Defaultwert (Standardwert) ist 0.\n", "\n", "Die Funktion nimmt alle Index-Wert-Paare einer Liste an, beginnend mit dem `startindex`. Probieren Sie es am Beispiel der Monate aus:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# ohne Startwert werden alle Monate ausgegeben:\n", "\n", "for index, wert in enumerate(monate):\n", " print(index, wert)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Da Sie im Alltag nicht bei Null zu zählen beginnen, könnten Sie `enumerate()` nutzen, um die Indizes zu verschieben. Dazu müssten Sie `enumerate()` mit dem `startindex=1` aufrufen: " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "for index, wert in enumerate(monate, 1):\n", " print(index, wert)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Challenge 2 – Spielkarten**\n", "\n", "In dieser Challenge wollen Sie ein Kartenset abbilden. Es gibt \n", "\n", "* vier Farben: ♥️ (Herz), ♠️ (Schaufel), ♦️ (Ecke), ♣️ (Kreuz)\n", "* 11 Werte: 2, 3, 4, 5, 6, 7, 8, 9, 10, Bube, Dame, König, Ass\n", "\n", "Teil a) Bilden Sie die Karteneigenschaften in den Listen `farben` und `werte` ab:\n", "\n", "
\n", " Hinweis\n", "\n", "Die Symbole können Sie als Zeichen (\"♥️\" etc.) speichern oder die Namen als Zeichenketten (\"Herz\" etc.)\n", "\n", "
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Ihr Code..." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Lösung:\n", "\n", "farben = [\"♥️\", \"♠️\", \"♦️\", \"♣️\"]\n", "werte = [2, 3, 4, 5, 6, 7, 8, 9, 10, \"Bube\", \"Dame\", \"König\", \"Ass\"]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Teil b) Nun möchten Sie alle Kombinationen von Karten ausgeben, also für jede Farbe jeden Wert. \n", "\n", "Gewünschte Ausgabe: \n", "♥️ 2\n", "♥️ 3\n", "... \n", "♥️ Ass\n", "♠️ 2\n", "♠️ 3\n", "...\n", "♠️ Ass\n", "♦️2\n", "...\n", "\n", "
\n", " Hinweis 2\n", "\n", "Überlegen Sie sich zuerst, wie Sie die eine Liste (`werte`) durchgehen und jedes Element ausgeben können und tun Sie dies.\n", "\n", "
\n", "
\n", " Hinweis 3\n", "\n", "Erweitern Sie die Ausgabe um die Werte der Liste `farben`.\n", "\n", "
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Ihr Code..." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Lösung:\n", "\n", "# Die einfachste Lösung besteht darin, direkt über die Listenelemente zu iterieren:\n", "for farbe in farben:\n", " for wert in werte:\n", " print(farbe, wert)\n", " \n", "# Aber auch diese Lösung ist möglich:\n", "for i in range(len(farben)):\n", " for j in range(len(werte)):\n", " print(farben[i], werte[j])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Quiz\n", "\n", "Alles klar? \n", "\n", "Testen Sie Ihr Verständnis anhand der Fragen, die erstellt werden, wenn Sie die folgenden Zellen gemäss Ihrer Umgebung ausführen.\n", "\n", "### NUR FALLS SIE AUF GOOGLE COLAB ARBEITEN\n", "\n", "Führen Sie bitte die **beiden** folgenden Zellen aus, um die Bibliothek für das Quiz zu laden." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# NUR falls Sie AUF GOOGLE COLAB arbeiten:\n", "# Führen Sie diese Zelle aus, um das Quiz zu sehen.\n", "\n", "%%writefile quizclone.py\n", "import os\n", "from subprocess import getoutput\n", "getoutput(\"git clone -l -s https://github.com/donze-informatikunterricht/quiz.git cloned-repo\")\n", "os.chdir('cloned-repo')\n", "print('repo cloned successfully')" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# NUR falls Sie AUF GOOGLE COLAB arbeiten:\n", "# Führen Sie diese Zelle aus, um das Quiz zu sehen.\n", "\n", "import quizclone" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### Quiz erstellen (unabhängig von Ihrer Arbeitsumgebung)\n", "\n", "Nun können Sie das Quiz erstellen. Führen Sie dazu bitte die folgende Zelle aus.\n", "\n", "Teile des Quiz basieren auf dem folgenden Programm:\n", "\n", "```python\n", "a = -35\n", "\n", "b = [0.0 for x in range(10)]\n", "\n", "c = [1, 2, 3, 4]\n", "\n", "for i in range(1, len(c)):\n", " c[i] = c[i]**2\n", " \n", "print(c)\n", "```" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from IPython.display import display\n", "import quiz\n", "\n", "display(quiz.Q1_listen)\n", "display(quiz.Q2_listen)\n", "display(quiz.Q3_listen)\n", "display(quiz.Q4_listen)\n", "display(quiz.Q5_listen)\n", "display(quiz.Q6_listen)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "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.8.8" } }, "nbformat": 4, "nbformat_minor": 4 }