{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Python Basics\n", "Ein Python Notebook besteht aus einer Abfolge von Zellen. Jede Zelle kann ausführbaren Code oder formatierten Text enthalten. Um eine Zelle mit Code auszuführen, klicke auf die Zelle und drücke den ► Button oder `Strg` + `Enter` auf der Tastatur. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(\"You've successfully executed some Python code.\")\n", "print(\"Congratulations!\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Versuche eine weitere Codezeile in der oberen Zelle hinzuzufügen und führe diese erneut aus. Füge nun eine neue Codezelle hinzu, indem du auf eine vorhandene Codezelle klickst, die Escape-Taste drückst und dann die Taste `a` oder `b` drückst. Die Taste `a` fügt eine Zelle über der aktuellen Zelle hinzu, und mit `b` wird eine Zelle darunter hinzugefügt. Weitere Grundlagen sowie eine Tour durch die Bedienoberfläche finden sich im Hilfsmenü von Jupyter. \n", "\n", "## 1 Erste Schritte\n", "Nach der kleinen Einführung in Jupyter Notebooks, geht es in diesem Abschnitt um die Python-Syntax, Variablendeklarationen, den Umgang mit Zahlen, usw. Der Kurs behandelt die grundlegenden Python-Skills, die für das Praktikum benötigt werden. Wenn du bereits Erfahrungen mit Python gemacht hast, kannst du direkt mit den Übungen starten. \n", "\n", "Folgende Konzepte werden in diesem Abschnitt gelernt:\n", "- Variablen,\n", "- Zahlen und arithmetische Operationen,\n", "- Funktionen,\n", "- Boolische Operationen und Bedingungen,\n", "- Listen und Schleifen." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.1 Variablenzuweisung\n", "In Python kannst du einer Variable `spam` mit dem `=` Operator einen Wert zuweisen:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "spam = 0" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Eine Variable kann jeden Namen annehmen, solange die folgenden drei Regeln beachtet werden: \n", "1. Es muss ein Wort sein.\n", "2. Es dürfen nur Buchstaben, Zahlen und Unterstriche `_` verwendet werden.\n", "3. Die Variable kann nicht mit einer Zahl beginnen.\n", "\n", "**Hinweis:** Im Vergleich zu anderen Sprachen (wie Java oder C++), ist folgendes in Python nicht notwendig:\n", "- Die Variable `spam` muss nicht *deklariert* werden, bevor ihr ein Wert zugewiesen wird.\n", "- Der Variablentyp von `spam` muss nicht definiert werden. Tatsächlich kann `spam` neu zugewiesen werden, um auf eine Zeichenkette oder ein Boolean zu verweisen." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.2 Zahlen und arithmetische Operationen\n", "Wir haben bereits ein Beispiel für eine Variable gesehen, die eine Zahl enthält:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "spam = 0" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Mit Hilfe der Funktion `type` können wir Python fragen, wie es die Variable `spam` beschreiben würde:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "type(spam)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ähnlich wie in andere Programmiersprachen ist eine ganzzahlige Zahl ein int - kurz für Integer. Eine andere Art von Zahl, der wir in Python häufig begegnen, ist der Typ `float`: " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "spam = 42.314\n", "type(spam)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Um arithmetische Operationen mit den Zahlen durchzuführen, stellt Python neben dem `+`-Operator für die Addition und den `*`-Operator für die Multiplikation die unten aufgeführten Operationen bereit." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "32 + 8 * 4" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "| Operator | Name | Beschreibung |\n", "|--------------|----------------|--------------------------------------------------------|\n", "| ``a + b`` | Addition | Summe von ``a`` und ``b`` |\n", "| ``a - b`` | Subtraktion | Differenz von ``a`` und ``b`` |\n", "| ``a * b`` | Multiplikation | Produkt von ``a`` und ``b`` |\n", "| ``a / b`` | Division | Quotient von ``a`` und ``b`` |\n", "| ``a // b`` | Floor division | Quotient von ``a`` und ``b``(gerundet) |\n", "| ``a % b`` | Modulo | Integer Rest nach der Division von ``a`` durch ``b`` |\n", "| ``a ** b`` | Potenz | ``a`` hoch ``b`` |\n", "| ``-a`` | Negation | Das Negativ von ``a`` |\n", "\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Klammern können in Python benutzt werden, um Unterausdrücke in beliebiger Reihenfolge auszuwerten." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "(32 + 8) * 4" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Hinweis:** In Python gibt es bereits integrierte Funktionen. Z.B. ist `print` eine Python-Funktion, die einen an sie übergebenen Wert auf dem Bildschirm anzeigt. Die Funktion wird aufgerufen, indem Klammern hinter dem Namen gesetzt werden und die Argumente für diese Funktion in die Klammern gesetzt werden. Einige Integrierte Funktionen für die Verwendung mit Zahlen werden unten kurz beschrieben. Eine Übersicht über die Python Funktionen findest du [hier](https://docs.python.org/3/library/functions.html).\n", "\n", "`min` und `max` geben das Minimum und Maximum ihrer Argumente zurück: " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(min(1, 2, 3))\n", "print(max(1, 2, 3))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`abs` gibt den absoluten Wert des Arguments zurück:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(abs(8))\n", "print(abs(-8))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`int` und `float` können auch als Funktionen aufgerufen werden, die ihre Argumente in den entsprechenden Typ umwandeln:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(int(8.54))\n", "print(float(8))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2 Funktionen\n", "In den vorherigen Zellen hast du die ersten Python-Funktion wie `print` oder `min` gesehen und angewendet. Neben diesen integrierten Funktionen ist die Definition deiner eigener Funktionen ein großer Teil der Python-Programmierung. Nachfolgend findest du ein einfaches Beispiel. Die Funktion beginnt mit dem Schlüsselwort `def` und der eingerückte Codeblock nach dem `:` wird beim Aufruf der Funktion ausgeführt. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def least_difference(a, b, c):\n", " diff1 = abs(a - b)\n", " diff2 = abs(b - c)\n", " diff3 = abs(a - c)\n", " return min(diff1, diff2, diff3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Diese Codezelle erstellt eine Funktion mit dem Namen `least_difference`, die drei Eingabeargumente `a`, `b` und `c` besitzt. Ein weiteres Schlüsselwort ist `return`, welches die Funktion sofort beendet und den Wert auf der rechten Seite an den jeweiligen Kontext übergibt. \n", "\n", "Ist es klar, was `least_difference` aus dem Quellcode macht? Wenn du dir nicht sicher bist, kannst du es jederzeit an einigen Beispielen ausprobieren:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Versuche hier die Funktion least_difference mit geeigneten Argumenten aufzurufen und gib das Ergebnis mit print aus.\n", "# Codezeilen die mit einem '#' beginnen sind Kommentare und werden nicht ausgeführt. \n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Hinweis:** Eine `return`-Anweisung ist nicht immer erforderlich. Ein Beispiel dafür ist die `print` Funktion, diese schreibt nur Text auf den Bildschirm. Weitere Beispiele für Funktionen ohne eine `return` Anweisung sind das Schreiben in eine Datei oder das Ändern einer Eingabe." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Hilfe erhalten:** Die `help` Funktion ist einer der wichtigsten Funktionen in Python. Wenn du z.B. vergessen hast was die `abs`-Funktion in `least_difference` bewirkt, kannst du mit Hilfe von `help` eine kurze Beschreibung der Funktion erhalten. Leider kann Python deinen Code in der Funktion `least_difference` nicht automatisch lesen und ihn in eine Beschreibung verwandeln. Beschreibungen von Funktionen werden in *docstrings* angegeben. Ein docstring für die Funktion `least_difference` kann z.B. wie folgt aussehen:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def least_difference(a, b, c):\n", " \"\"\"Gibt den kleinsten Abstand zwischen den Nummern a, b und c aus. \n", " \n", " Beispiel:\n", " >>> least_difference(1, 5, -5)\n", " 4\n", " \"\"\"\n", " diff1 = abs(a - b)\n", " diff2 = abs(b - c)\n", " diff3 = abs(a - c)\n", " return min(diff1, diff2, diff3)\n", "\n", "help(least_difference)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3 Boolesche Operationen und Bedingungen\n", "### 3.1 Boolesche Operationen\n", "Eine Variable vom Typ bool kann zwei Werte annehmen: Wahr (`True`) oder falsch (`False`)." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "spam = True\n", "print(spam)\n", "type(spam)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Neben der Möglichkeit True oder False direkt im Code zu verwenden, können boolesche Werte auch das Ergebniss von booleschen Operatoren sein. Eine Auflistung häufig verwendeter Operatoren findest du unten. \n", "\n", "| Operator | Beschreibung |\n", "|--------------|------------------------------------|\n", "| `a == b` | ``a`` gleich ``b`` |\n", "| `a < b` | ``a`` kleiner ``b`` |\n", "| `a <= b` | ``a`` kleiner gleich ``b`` |\n", "| `a != b` | ``a`` ungleich ``b`` |\n", "| `a > b` | ``a`` größer ``b`` |\n", "| `a >= b` | ``a`` größer gleich ``b`` |\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Boolesche Operatoren können mit den arithmetischen Operatoren kombiniert werden. Zum Beispiel können wir überprüfen, ob eine Zahl ungerade ist, indem wir den Modulo-Operator verwenden und das Ergebnis überprüfen:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def is_odd(n):\n", " return (n % 2) == 1\n", "\n", "print(\"Ist die Zahl 20 ungerade?\", is_odd(20))\n", "print(\"Ist die Zahl 3 ungerade?\", is_odd(3))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Boolesche Operationen kombinieren:** In Python können boolesche Werte mit den Schlüsselwörtern `and`, `or` und `not` kombiniert werden. Bei der Auswertung der oben aufgeführten boolischen Operationen ist zu beachten, dass `and` eine höhere Priorität hat als `or`. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "True or True and False" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Hinweis:** Boolesche Operationen können schnell unübersichtlich werden. Schau dir zum Beispiel den folgenden Ausdruck an: " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "prepared_for_weather = have_umbrella or rain_level < 5 and have_hood or not rain_level > 0 and is_workday" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Der Ausdruck soll bewerten, ob eine Person auf die aktuelle Wetterlage vorbereitet ist. Die Aussage ist wahr, wenn...\n", "- du einen Regenschirm hast ...\n", "- `or` es nicht stark regnet `and` du eine Kapuze hast ...\n", "- `or` wenn es regnet und du lernen musst.\n", "\n", "Du kannst den Ausdruck leichter lesbar machen und auch Fehler vermeiden, indem du einige Klammern hinzufügst:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "prepared_for_weather = have_umbrella or (rain_level < 5 and have_hood) or not (rain_level > 0 and is_workday)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Du kannst den Ausdruck auch über mehere Zeilen verteilen: " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "prepared_for_weather = (\n", " have_umbrella \n", " or ((rain_level < 5) and have_hood) \n", " or (not (rain_level > 0 and is_workday))\n", " )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.2 Bedingungen\n", "Bedingte Anweisungen werden oft als if-then-Anweisungen bezeichnet und ermöglichen es bestimmte Codeabschnitte abhängig von einer booleschen Bedingung auszuführen. Für eine if-then-Anweisung werden die Schlüsselwörter `if`, `elif` und `else` benötigt. Ein grundlegendes Beispiel für eine bedingte Python-Anweisung ist unten aufgeführt:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def inspect(x):\n", " if x == 0:\n", " print(x, \"ist null\")\n", " elif x > 0:\n", " print(x, \"ist positiv\")\n", " elif x < 0:\n", " print(x, \"ist negativ\")\n", " else:\n", " print(x, \"kenn ich nicht...\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Hinweis:** In Python wird `elif` als eine Abkürzung von \"else if\" verwendet. Die Doppelpunkte `:` kennzeichnen seperate Codeblöcke. Ahnlich wie bei der Definition einer Funktion, gehören alle nachfolgenden eingerückten Linien zur definierten Bedingung. Die erste nicht eingerückte Codezeile beendet die Bedingung." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 4 Listen und Schleifen\n", "### 4.1 Listen" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Listen stellen geordnete Abfolgen von Werten dar. Hier sind einige Beispiele:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Eine Liste mit ungeraden Zahlen\n", "odd_numbers = [1, 3, 5, 7, 9]\n", "\n", "# Eine Liste mit Strings\n", "planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']\n", "\n", "# Eine Liste von Listen\n", "hands = [\n", " ['J', 'Q', 'K'], # Die Zeilenumbrüche sind optional, erhöhen aber die Lesbarkeit\n", " ['2', '2', '2'],\n", " ['6', 'A', 'K'], # Das Komma nach jedem letzten Listenelement ist optional\n", " ]\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Indexing:** Auf die Listenelemente kann über eckige Klammern zugegriffen werden. Python verwendet dabei für das erste Element den Index 0: " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(\"First planet: \" + planets[0])\n", "print(\"Second planet: \" + planets[1])\n", "\n", "# Auf Elemente am Ende der Liste kann mit negativen Zahlen zugegriffen werden, beginnend mit -1\n", "print(\"Last planet: \" + planets[-1])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Sclicing:** Mit `slicing` kann auf einen bestimmten Bereich in der Liste zugegriffen werden. Verschiedene Beispiele sind unten aufgeführt:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "planets[0:3] # Die ersten drei Planeten " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "planets[:3] # Der Index 0 kann auch weggelassen werden" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "planets[3:] # Alle Planeten ab dem dritten Index" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "planets[-3:] # Die letzten drei planeten" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Änderungen in einer Liste:** Listen sind veränderbar. Nehmen wir zum Beispiel an, wir wollen den Mars umbenennen:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "planets[3] = 'Malacandra'\n", "planets" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Integrierte Funktionen:** Python bietet mehrere nützliche Funktionen für die Arbeit mit Listen. Z.B. gibt die Funktion `len` die Länge einer Liste wieder, `sorted` gibt eine sortierte Version der Liste zurück und `sum` addiert alle Elemente in der Liste." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(len(planets))\n", "print(sum(odd_numbers))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Hinweis:** In Python ist alles ein Objekt, d.h. einige Objekte haben bereits vordefinierte Methoden implementiert. Auf die Methoden kann über die Punkt-Syntax zugegriffen werden. Zum Beispiel tragen Zahlen in Python eine zugehörige Variable mit dem Namen `imag`, die den Imaginärteil einer Zahl darstellt." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x = 42 \n", "# x ist eine reelle Zahl, also ist der Imaginärteil 0.\n", "print(x.imag) \n", "\n", "# Hier ist ein Beispiel für eine komplexe Zahl.\n", "x_j = 42 + 12j\n", "print(x_j.imag)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Die obigen Beispiele waren völlig unsinnig und können mit Listen nicht verwendet werden. Aber es gibt sinnvollere Methoden, die auch mit listen verwendet werden können. `list.append` ändert z.B. eine Liste, indem es ein Element am Ende hinzufügt." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "planets.append(\"Pluto\")\n", "planets" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`list.pop` löscht das letzte Element aus einer Liste und gibt es gleichzeitig aus: " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "planets.pop()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Mit Hilfe von `list.index` kann nach der Position eines Eintrags in einer Liste gesucht werden. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "planets.index(\"Mars\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Mit dem Operator `in` kann bestimmt werden, ob eine Liste einen bestimmten Wert enthält." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\"Pluto\" in planets" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 4.2 Schleifen\n", "Mit Schleifen kannst du einen Code wiederholt ausführen: " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']\n", "for planet in planets:\n", " print(planet)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Eine Schleife beginnt mit dem Schlüsselwort `for`, einer Variable (in diesem Fall `planet`) und eine Menge an Werten (`planets`). Das Wort `in` verbindet die beiden Variablen miteinander. Das Objekt rechts neben dem `in` kann jedes Objekt sein, das die Iteration unterstützt." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "multiplicands = (2, 2, 2, 3, 3, 5) # Tupels sind wie Listen. Um sie zu erstellen, verwendet \n", " # man runde Klammern anstelle von eckigen Klammern. \n", " # Im gegesatz zu Listen können sie nicht geändert werden.\n", "product = 1\n", "for mult in multiplicands:\n", " product = product * mult\n", "product" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Mit `range()` kannst du eine Folge von Zahlen ausgeben. Diese Funktion ist sehr nützlich für das Schreiben von Schleifen." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Die Schleife wiederholt sich 5-mal\n", "for i in range(5):\n", " print(\"Doing some work. i =\", i)\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**While Schleifen:** While-Schleife werden solange wiederholt, bis eine Bedingung erfüllt ist. Das Argument der while-Schleife wird als boolesche Anweisung ausgewertet. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "i = 0\n", "while i < 10:\n", " print(i, end=' ')\n", " i += 1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**List comprehensions:** List comprehensions beschreibt eines der beliebtesten und einzigartigsten Funktionen von Python. Nachfolgend einige Bespiele: " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Normaler Code\n", "squares = []\n", "for n in range(10):\n", " squares.append(n**2)\n", "print(squares)\n", "\n", "# List comprehensions\n", "squares = [n**2 for n in range(10)]\n", "print(squares)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In Kombination mit der `if`-Anweisung:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "short_planets = [planet for planet in planets if len(planet) < 6]\n", "short_planets" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ein letztes Beispiel:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Normaler Code\n", "def count_negatives(nums):\n", " \"\"\"Gibt die Anzahl der negativen Zahlen in der Liste zurück.\n", " \n", " >>> count_negatives([5, -1, -2, 0, 3])\n", " 2\n", " \"\"\"\n", " n_negative = 0\n", " for num in nums:\n", " if num < 0:\n", " n_negative = n_negative + 1\n", " return n_negative\n", "\n", "# List comprehensions\n", "def count_negatives(nums):\n", " return len([num for num in nums if num < 0])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Übungen" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1. Variablen, Zahlen und arithmetische Operationen\n", "**Aufgabe 1.1:** Vertausche die Variablen `a` und `b`, so dass `a` auf das zuvor von `b` erwähnte Objekt verweist und umgekehrt." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Setup code\n", "a = \"Bob\"\n", "b = \"Alice\"\n", "\n", "# Dein Code kommt hierhin. Vertausche die Werte, auf die sich a und b beziehen.\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Aufgabe 1.2:** Füge dem folgenden Ausdruck Klammern hinzu, so dass er zu 0 wird." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "8 - 3 * 2 - 1 + 1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Aufgabe 1.3:** Alice, Bob und Carol haben sich bereit erklärt, ihre Halloween-Bonbons zusammenzulegen und gleichmäßig unter sich aufzuteilen. Im Namen ihrer Freundschaft werden die übrig gebliebenen Süßigkeiten zerschlagen. \n", "\n", "Beispiel:\n", "Gemeinsam haben Alice, Bob und Carol 121 Bonbons nach Hause gebracht, jeder erhält 40 Bonbons pro Person und sie zerschlagen gemeinsam ein Bonbon." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Setup code. Die Variablen beschreiben die gesammelten Bonbons von Alice, Bob und Carol.\n", "alice_candies = 42\n", "bob_candies = 38\n", "carol_candies = 41\n", "\n", "# Dein Code kommt hierhin. Schreibe einen Ausdruck, um zu berechnen, \n", "# wie viele Bonbons für eine bestimmte Menge zerschlagen werden müssen.\n", "to_smash = " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Funktionen\n", "\n", "\n", "**Aufgabe 2.1:** Vervollständige die Funktion `round_to_two_places()`. Nutze dazu die Beschreibung aus dem docstring." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def round_to_two_places(num):\n", " \"\"\"Rundet die übergebene Nummer auf zwei Dezimalstellen und gibt sie zurück.\n", " \n", " Beispiel:\n", " >>> round_to_two_places(3.14159)\n", " 3.14\n", " \"\"\"\n", " # Dein Code kommt hierhin.\n", " \n", " \n", " \n", " \n", "round_to_two_places(3.14159)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Aufgabe 2.2:** In Aufgabe 1.3 versuchten Alice, Bob und Carol, Bonbons gleichmäßig zu teilen. Schreibe nun eine Funktion, die die Anzahl der zu zerschlagenden Süßigkeiten für *eine* beliebige Anzahl von Süßigkeiten und eine beliebige Anzahl von Freunden berechnet. Schreibe auch einen den docstring, um das Verhalten deiner Funktion zu beschreiben." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Dein Code kommt hierhin. Schreibe einen Funktion, um zu berechnen, \n", "# wie viele Bonbons für eine bestimmte an Freunden zerschlagen werden müssen.\n", " def ...\n", "\n", "# Setup code. Die Variablen beschreiben die gesammelten Bonbons von Alice, Bob und Carol.\n", "total_candies = 314\n", "total_friends = 3\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Aufgabe 2.3:** Lese und verstehe die Fehlermeldungen der unten aufgeführten Codezellen. Jede Codezelle enthält einen Bug, versuche vorauszusehen was deiner Meinung nach passieren wird, wenn die Zelle ausgeführt wird. Schreibe anschließend einen Fix für den fehlerhaften Code. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x = -99\n", "y = 42\n", "# Welche der beiden Variablen hat den größten absoluten Wert?\n", "smallest_abs = min(abs(x, y))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def ruound_to_two_places(num):\n", " return round(num)\n", "\n", "# Runde die Zahl auf zwei Nachkommastellen\n", "ruound_to_two_places(9.9999)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Boolische Operationen und Bedingungen\n", "**Aufgabe 3.1:** Definiere in der Zelle unten eine Funktion namens `sign`, die ein numerisches Argument annimmt und -1 zurückgibt, wenn sie negativ ist, 1, wenn sie positiv ist, und 0, wenn sie 0 ist." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Dein Code kommt hierhin.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Aufgabe 3.2:** In dem Kapitel 3.1 sollte der folgende Ausdruck bewerten, ob du auf die aktuelle Wetterlage vorbereitet bist. Die Aussage ist wahr, wenn...\n", "- du einen Regenschirm hast ...\n", "- `or` es nicht stark regnet `and` du eine Kapuze hast ...\n", "- `or` wenn es regnet und du lernen musst.\n", "\n", "Leider gab es in dem Code einen Fehler, kannst du ihn Finden? Hierfür soll eine Reihe von Eingaben gemacht werden, bei denen die Antwort falsch ist." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def prepared_for_weather(have_umbrella, rain_level, have_hood, is_workday):\n", " # Setup code. Das Ziel ist es einen Bug zu finden, nicht ihn zu korrigieren.\n", " return have_umbrella or rain_level < 5 and have_hood or not rain_level > 0 and is_workday\n", "\n", "# Ändere die Parameter, so dass eine falsche Antwort gegeben wird.\n", "have_umbrella = True\n", "rain_level = 7.0\n", "have_hood = True\n", "is_workday = False\n", "\n", "# Ausgabe\n", "actual = prepared_for_weather(have_umbrella, rain_level, have_hood, is_workday)\n", "print(actual)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Listen und Schleifen\n", "**Aufgabe 4.1:** Vervollständige die untenstehende Funktion entsprechend ihrer Dokumentation." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def select_second(L):\n", " \"\"\"Gibt das zweite Element einer Liste zurück. Wenn kein zweitel Element voranden ist, \n", " wird \"None\" zurückgegeben. \n", " \"\"\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Aufgabe 4.2:** In der nächsten Version von Mario Kart wird es einen neuen und besonders ärgerlichen Gegenstand geben, die *Purple Shell*. Bei Verwendung wechselt es den letzten Platz auf den ersten Platz und den ersten Platz auf den letzten Platz. Implementiere den Effekt der *Purple Shell* in der unten aufgeführten Funktion." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def purple_shell(racers):\n", " \"\"\"Stellt den Erstplatzierten (am Anfang der Liste) auf \n", " den letzten Platz (Ende der Liste) und umgekehrt.\n", " \n", " >>> r = [\"Mario\", \"Bowser\", \"Luigi\"]\n", " >>> purple_shell(r)\n", " >>> r\n", " [\"Luigi\", \"Bowser\", \"Mario\"]\n", " \"\"\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Aufgabe 4.3:** Die unten aufgeführte Codezelle hat einen Bug. Versuche den Bug zu finden und behebe den Fehler." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def has_lucky_number(nums):\n", " \"\"\"Gibt an ob die übergebene Liste mindestens eine Zahl enthält die durch 7 teilbar ist.\n", " \n", " >>> nums = [2, 4, 89, 7, 56, 13]\n", " >>> is_lucky = has_lucky_number(nums)\n", " >>> is_lucky\n", " True\n", " \"\"\"\n", " for num in nums:\n", " if num % 7 == 0:\n", " return True\n", " else:\n", " return False\n", "\n", " " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Aufgabe 4.4:** Vervollständige die untenstehende Funktion entsprechend ihrer Dokumentation." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def elementwise_greater_than(L, thresh):\n", " \"\"\"Gibt eine Liste der Länge len(L) aus. Die Werte an der Stelle i \n", " sind True, wenn L[i] größer ist als thresh. Ansonsten ist der Wert False. \n", " \n", " >>> elementwise_greater_than([1, 2, 3, 4], 2)\n", " [False, False, True, True]\n", " \"\"\"" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.7" } }, "nbformat": 4, "nbformat_minor": 2 }