Newer
Older
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Kapitel 2: Variablen, Ausdrücke und Anweisungen\n",
"[Chapter 2: Variables, expressions and statements](http://greenteapress.com/thinkpython2/html/thinkpython2003.html).\n",
"\n",
"Eine der mächtigsten Fähigkeiten von Programmiersprachen ist, **Variablen** zu verändern. Variablen sind Namen, die auf einen Wert verweisen.\n",
"\n",
"\n",
"\n",
"**Bevor Sie mit diesem Notebook starten, sollten Sie wiederholen, was Sie im letzten Notebook gelernt haben. Gehen Sie zurück und schauen Sie sich mindestens das Glossar an und wiederholen Sie die dort genannten Begriffe.**"
]
},
{
"cell_type": "markdown",
"<h1>Inhalt<span class=\"tocSkip\"></span></h1>\n",
"<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Ihre-Lernziele\" data-toc-modified-id=\"Ihre-Lernziele-1\"><span class=\"toc-item-num\">1 </span>Ihre Lernziele</a></span></li><li><span><a href=\"#Exkurs:-Was-mir-an-Python-gefällt\" data-toc-modified-id=\"Exkurs:-Was-mir-an-Python-gefällt-2\"><span class=\"toc-item-num\">2 </span>Exkurs: Was mir an Python gefällt</a></span></li><li><span><a href=\"#Zuweisung\" data-toc-modified-id=\"Zuweisung-3\"><span class=\"toc-item-num\">3 </span>Zuweisung</a></span></li><li><span><a href=\"#(Variablen)Namen\" data-toc-modified-id=\"(Variablen)Namen-4\"><span class=\"toc-item-num\">4 </span>(Variablen)Namen</a></span></li><li><span><a href=\"#Ausdrücke-und-Anweisungen\" data-toc-modified-id=\"Ausdrücke-und-Anweisungen-5\"><span class=\"toc-item-num\">5 </span>Ausdrücke und Anweisungen</a></span></li><li><span><a href=\"#Reihenfolge-von-Operatoren\" data-toc-modified-id=\"Reihenfolge-von-Operatoren-6\"><span class=\"toc-item-num\">6 </span>Reihenfolge von Operatoren</a></span></li><li><span><a href=\"#Operatoren-für-Zeichenketten\" data-toc-modified-id=\"Operatoren-für-Zeichenketten-7\"><span class=\"toc-item-num\">7 </span>Operatoren für Zeichenketten</a></span></li><li><span><a href=\"#Kommentare\" data-toc-modified-id=\"Kommentare-8\"><span class=\"toc-item-num\">8 </span>Kommentare</a></span></li><li><span><a href=\"#Debugging\" data-toc-modified-id=\"Debugging-9\"><span class=\"toc-item-num\">9 </span>Debugging</a></span></li><li><span><a href=\"#Glossar\" data-toc-modified-id=\"Glossar-10\"><span class=\"toc-item-num\">10 </span>Glossar</a></span></li><li><span><a href=\"#print-Tutorial\" data-toc-modified-id=\"print-Tutorial-11\"><span class=\"toc-item-num\">11 </span><code>print</code> Tutorial</a></span></li><li><span><a href=\"#Übung\" data-toc-modified-id=\"Übung-12\"><span class=\"toc-item-num\">12 </span>Übung</a></span><ul class=\"toc-item\"><li><span><a href=\"#Aufgabe-1\" data-toc-modified-id=\"Aufgabe-1-12.1\"><span class=\"toc-item-num\">12.1 </span>Aufgabe 1</a></span></li><li><span><a href=\"#Aufgabe-2\" data-toc-modified-id=\"Aufgabe-2-12.2\"><span class=\"toc-item-num\">12.2 </span>Aufgabe 2</a></span></li></ul></li></ul></div>"
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"Beschreiben Sie in 2-3 Stichpunkten kurz was Sie im Seminar heute lernen wollen. Klicken Sie dazu doppelt auf diesen Text und bearbeiten Sie dann den Text:\n",
"\n",
"Dieses Programm durchsucht alle Jupyter Notebooks in dem Verzeichnis in dem dieses Notebook gespeichert ist. "
]
},
{
"cell_type": "code",
"execution_count": null,
"import os\n",
" \n",
"query = \"Experiment\"\n",
"\n",
"# Suche nach query in s; falls gefunden: Fundstelle + hervorgehobene Anfrage zurückgeben\n",
"def search(s, query, context = 20):\n",
" i = s.find(query)\n",
" if i >= 0:\n",
" return s[max(0, i-context):i] + \"*\" + s[i:i + len(query)] + \"*\" + s[i + len(query):min(len(s), i+context)]\n",
" return None\n",
"\n",
"print(\"Suche nach '\" + query + \"':\")\n",
"# alle Python-Notebooks im aktuellen Verzeichnis durchsuchen\n",
"for entry in os.listdir():\n",
" if entry.endswith(\".ipynb\"):\n",
" with open(entry, \"rt\") as f:\n",
" for line in f:\n",
" result = search(line, query)\n",
" if result:\n",
" print(entry + \":\", result)"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from IPython.lib.display import YouTubeVideo\n",
"YouTubeVideo('https://www.youtube.com/watch?v=jfOLXKPGXJ0&list=PL_pqkvxZ6ho3u8PJAsUU-rOAQ74D0TqZB&index=4')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from IPython.lib.display import YouTubeVideo\n",
"YouTubeVideo('https://www.youtube.com/watch?v=XKFQ2_et5k8&list=PL_pqkvxZ6ho3u8PJAsUU-rOAQ74D0TqZB&index=8')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Die **Zuweisung** ist eine besondere Form der Anweisung. Sie erzeugt eine neue Variable und gibt ihr einen Wert. \n",
"Wenn bereits eine Variable mit dem selben Namen existiert wird dieser nur ein Wert zugewiesen:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"nachricht = \"Das ist ein ganz einfacher Mechanismus.\"\n",
"n = 17\n",
"pi = 3.141592653589793"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In diesem Beispiel sehen wir drei Zuweisungen:\n",
" - die Erste weist die Zeichenkette `\"Das ist ein ganz einfacher Mechanismus.\"` einer Variable mit dem Namen `nachricht` zu\n",
" - die Zweite weist die Zahl `17` der Variablen `n` zu und\n",
" - die Dritte weist (einen Näherungswert für) Pi der Variablen `pi` zu.\n",
"\n",
"Legen Sie selbst ein paar Variablen an und weisen Sie Ihnen Werte zu:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Variablen (und auch Funktionen) benötigen Namen. Als Programmierer_innen sollten wir Namen wählen, die aussagekräftig sind und dokumentieren, wofür die Variable (oder Funktion) verwendet wird. Folgende Regeln gelten: \n",
" \n",
"\n",
" Variablennamen:\n",
"- dürfen beliebig lang sein"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"diesistabereinelangevariableundtrotzdemmeckertpythonnicht = 1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- dürfen Zahlen (0-9), Buchstaben (A-Z, a-z) und Unterstriche (`_`) enthalten"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"so_ist_es_besser_lesbar = \"richtig\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- aber nicht mit einer Zahl beginnen"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"0das_gibt_Aerger = 1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Der Name `0das_gibt_Aerger` ist nicht erlaubt, weil er mit einer Zahl beginnt. Probieren wir ein paar andere Namen aus. Führen Sie dafür den Code aus, um zu sehen was passiert. Dabei kann es zu Fehlermeldungen kommen, diese bedeuten nicht, dass Sie etwas falsch gemacht haben. Lesen Sie die Fehlermeldungen durch bevor Sie die anschließenden Erklärungen lesen."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"class = 'Advanced Theoretical Zymurgy'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Der Name `mehr@` ist nicht erlaubt, weil das Zeichen `@` nicht zu den Zeichen gehört, aus denen ein Name bestehen darf.\n",
"- Der Name `class` ist anders, denn er enthält nur erlaubte Zeichen. Warum gibt es dennoch einen Fehler? Der Grund ist, dass `class` ein sogenanntes **Schlüsselwort** ist. Schlüsselwörter helfen Python, die Struktur eines Programms zu erkennen und dürfen daher nicht als Namen für Variablen (und Funktionen) verwendet werden. In Python 3 gibt es die folgenden Schlüsselwörter: `False None True and as assert break class continue def del elif else except finally for from global if import in is lambda nonlocal not or pass raise return try while with yield`. Sie brauchen sich die Liste nicht zu merken. In den meisten Entwicklungsumgebungen (Programmen zum Bearbeiten von Quellcode - wie z.B. Jupyter) werden diese Wörter farblich hervorgehoben und Sie werden somit gewarnt, falls Sie eines dieser Wörter als Variablennamen verwenden wollen.\n",
"\n",
"\n",
"\n",
"([Keep it simple, stupid](http://www.commitstrip.com/en/2016/09/01/keep-it-simple-stupid/), CommitStrip.com)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ein **Ausdruck** ist eine Kombination von Werten, Variablen und Operatoren. Wir haben Ausdrücke bereits kennengelernt: In der Anweisung"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(1 + 2 + 3 + 4 + 5)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"weiter oben gibt die `print`-Funktion den Wert des Ausdrucks `1 + 2 + 3 + 4 + 5` aus. In diesem Beispiel ist der Ausdruck `1 + 2 + 3 + 4 + 5` eine Kombination von Werten (1, 2, 3, 4, und 5) und dem Operator `+`. \n",
"\n",
"Jeder Wert ist selbst ein Ausdruck und auch jede Variable ist ein Ausdruck. Das folgende sind also alles Ausdrücke: \n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wenn wir einen Ausdruck am Ende einer Code-Box in Jupyter eingeben, dann wird der Ausdruck **ausgewertet** (also dessen Wert berechnet) und das Ergebnis ausgegeben. Allerdings passiert sonst nicht viel - der Wert wird nicht gespeichert und kann so nicht weiterverwendet werden. Wir können aber beispielsweise mit einer Zuweisung (wie oben gesehen) den Wert eines Ausdrucks einer Variablen zuweisen.\n",
"**Anweisungen** haben wir in Kapitel 1 schon kennengelernt (als die Bausteine eines Programms). Anweisungen sind Codestücke, die eine Auswirkung haben - also z.B. einer Variablen einen Wert zuweisen oder ein Ergebnis anzeigen:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"n = 17\n",
"print(n)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Die erste Zeile ist eine Zuweisung, die der Variablen `n` einen Wert zuweist. Die zweite Zeile ruft die Funktion `print` auf, um den Wert von `n` auszugeben.\n",
"\n",
"Wenn wir eine Anweisung starten (mit \"Run Cell\" aus dem \"Cell\"-Menü, oder `STRG-ENTER`), dann wird die Anweisung **ausgeführt**, d.h., der Python-Interpreter tut, was immer die Anweisung verlangt. \n",
"\n",
"Schreiben Sie eine Folge von drei Anweisungen:\n",
"1. Weisen Sie einer Variable `radius` den Wert 3 zu.\n",
"2. Weisen Sie einer Variable `umfang` den (Wert des) Ausdrucks zu, der den Umfang eines Kreises mit dem Radius `radius` berechnet\n",
"3. Geben Sie den Wert der Variablen `umfang` mit der Funktion `print` aus.\n",
"\n",
" <summary type=\"button\" class=\"btn btn-info\">Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
"Die Formel für den Umfang lautet: $u=2π⋅r$\n",
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"source": [
"pi = 3.141592653589793\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Prüfen Sie ihr Ergebnis - ist alles korrekt? Notieren Sie hier kurz, welche Schwierigkeiten Ihnen begegnet sind:\n",
"- \n",
"- \n",
"- \n",
"\n",
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from IPython.lib.display import YouTubeVideo\n",
"YouTubeVideo('https://www.youtube.com/watch?v=VtiDkRDPA_c&list=PL_pqkvxZ6ho3u8PJAsUU-rOAQ74D0TqZB&index=2')\n",
"\n",
"# Ab Minute 3:45 bis zum Ende"
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Enthält ein Ausdruck mehrere Operatoren, so werden diese in der folgenden Reihenfolge ausgewertet:\n",
"- Zuerst werden Klammern ausgewertet (wie in der Mathematik dürfen wir Klammern verwenden, um die Reihenfolge bei der Berechnung festzulegen)."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
" 2 * (3-1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" ist also 4 und"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
" (1+1)**(5-2) "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" ist 8\n",
"- Exponentiation hat die nächsthöhere Priorität, daher ergibt"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"1 + 2**3"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"9 (und nicht 27) und "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"2 * 3**2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" ergibt 18 (und nicht 36). \n",
"\n",
"- Multiplikation und Division haben eine höhere Priorität als Addition und Subtraktion. Daher ergibt "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"2*3-1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"5 und nicht 4 und "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"6+4/2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ergibt 8 und nicht 5. \n",
"\n",
"- Operatoren mit der gleichen Priorität werden von links nach rechts ausgewertet (außer Exponentiation). Im Ausdruck `degrees / 2 * pi` wird also zuerst dividiert und dann wird mit `pi` multipliziert. Um stattdessen durch `pi` zu dividieren, können wir Klammern verwenden oder stattdessen `degrees / 2 / pi` schreiben.\n",
"Wir müssen uns die Reihenfolge nicht merken. Wenn wir uns nicht sicher sind, verwenden wir einfach Klammern, um die Reihenfolge festzulegen. \n",
"Ändern Sie den folgenden Ausdruck so ab, dass zuerst 2 und 3.141 addiert werden und das Ergebnis mit 4 multipliziert wird:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Die Ausgabe sollte dann 20.564 statt 14.564 betragen.\n",
"\n",
"Im Allgemeinen können wir mathematische Operatoren nicht für Zeichenketten verwenden, auch wenn die Zeichenketten wie Zahlen aussehen:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from IPython.lib.display import YouTubeVideo\n",
"YouTubeVideo('https://www.youtube.com/watch?v=sTEf4_mrLvw&list=PL_pqkvxZ6ho3u8PJAsUU-rOAQ74D0TqZB&index=4')\n",
"\n",
"# Ab Minute 7:29 bis 9:03"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"'2' - '1'"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"'acht' / 'zwei'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Es gibt aber zwei Ausnahmen: `+` und `*`:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Mit dem Operator `+` können wir Zeichenketten verknüpfen (oder verketten). D.h., die Zeichenketten werden hinereinander geschrieben. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"a = \"Donau\"\n",
"b = \"dampf\"\n",
"c = \"schiff\"\n",
"a + b + c"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Mit dem Operator `*` können wir eine Zeichkette wiederholen: "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"c * 3"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Dabei muss einer der beiden Werte eine Zeichenkette sein und der andere eine ganze Zahl. Probieren Sie aus, ob die Reihenfolge von Zeichenkette und Zahl egal ist:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Die beiden Operatoren funktionieren ähnlich wie bei Zahlen: So wie `4*3` gleich `4+4+4` ist, ist `dampf*3` gleich `dampfdampfdampf`. Allerdings gibt es einen wichtigen Unterschied: Welche Eigenschaft erfüllt die Addition bei Zahlen, die die Verknüpfung von Zeichenketten nicht erfüllt?\n",
"Sobald Programme größer und komplexer werden, wird es schwer, sie zu verstehen. Die Information, die im Programmcode steckt, ist sehr dicht und es fällt oft schwer, nur durch einen Blick auf den Programmcode herauszufinden, was der Code macht und warum. \n",
"Daher ist es eine gute Idee, Notizen in natürlicher Sprache einzufügen, die erklären, was das Programm macht. Diese Notizen heißen **Kommentare** und sie beginnen mit dem Zeichen `#`:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"radius = 7\n",
"# die Fläche eines Kreises berechnen\n",
"flaeche = 2 * pi * radius**2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wir können Kommentare auch am Ende einer Zeile hinzufügen:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"flaeche = 2 * pi * radius**2 # die Fläche eines Kreises berechnen"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Alles ab `#` bis zum Ende der Zeile wird ignoriert und hat keine Auswirkung auf die Ausführung des Programms.\n",
"\n",
"- Kommentare werden in der Entwicklungsumgebung oft farblich hervorgehoben, was zusätzlich die Orientierung erleichtert.\n",
"- Kommentare sind am hilfreichsten, wenn sie das nicht-Offensichtliche erklären\n",
"- Wir können davon ausgehen, dass der/die Leser/in herausfinden kann, *was* das Programm macht, daher sollten wir eher erklären *warum* das an der Stelle gemacht wird.\n",
"\n",
"Der folgende Kommentar ist beispielsweise redundant und daher nutzlos:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Dieser Kommentar dagegen enthält nützliche Information, die sich nicht im Quellcode befindet:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"v = 5 # Geschwindigkeit in Meter pro Sekunde"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Mit aussagekräftigen Variablennamen können wir uns Kommentare sparen, allerdings werden Ausdrücke durch sehr komplexe oder lange Namen schwer lesbar. Wir müssen also einen guten Mittelweg finden.\n",
"Finden Sie heraus, was das folgende Programm tut und fügen Sie aussagekräftige Kommentare hinzu:\n",
"\n",
"(Tipp: math.sqrt() berechnet die Quadratwurzel, sqrt=square root)"
"execution_count": null,
"\n",
"x1 = 5\n",
"y1 = 4\n",
"x2 = 1\n",
"y2 = 1\n",
"\n",
"distance_h = x1 - x2\n",
"distance_v = y1 - y2\n",
"\n",
"distance = math.sqrt(distance_h**2 + distance_v**2)\n",
"\n",
"print(\"distance((x1, y1), (x2, y2)) = \", distance)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wieviele Kommentare in einem Programm gut und notwendig sind ist durchaus umstritten. Wenn Sie mögen, können Sie einen Ausschnitt des Diskurses dazu hier verfolgen:\n",
"\n",
"\n",
"- [\"Good code is its own best documentation.\" (Steve McConnell)](http://de.wikipedia.org/wiki/Steve_McConnell)\n",
"- [\"Yes your Code does need comments\" (Mike Grouchy)](http://mikegrouchy.com/blog/2013/03/yes-your-code-does-need-comments.html)\n",
"- [Funny comments](https://stackoverflow.com/questions/184618/what-is-the-best-comment-in-source-code-you-have-ever-encountered)\n",
"\n",
"\n",
"([Programming Elements – Comments](https://prairieworldcomicsblog.wordpress.com/2018/01/26/programming-elements-comments/), William Wise)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"Programme können drei Arten von Fehlern enthalten:\n",
"\n",
"- Syntax-Fehler (\"syntax error\") – Fehler in der **Syntax**, also der Struktur, des Programmes. Das Programm ist nicht ausführbar bis der Fehler behoben ist. Vor allem zu Beginn, werden Sie vermutlich viele Syntax- Fehler machen, zum Beispiel in dem Sie eine Klammer vergessen. Je mehr Übung Sie haben, desto weniger Syntax-Fehler werden Sie machen. Zudem werden Sie diese auch schneller finden. \n",
"- Laufzeit-Fehler (\"runtime error\") – Laufzeit-Fehler treten erst auf, während das Programm läuft. Sie werden auch **exceptions** genannt, da sie üblicherweise bedeuten, dass etwas außergewöhnliches (und schlechtes) passiert ist. In einfachen Programmen sind Laufzeitfehler selten, Sie werden Ihnen vermutlich noch eine Weile nicht begegnen. \n",
"- Semantische Fehler sind Fehler in der **Semantik** – also Fehler, die mit der Bedeutung des Programms zusammenhängen. Das Programm läuft ohne eine Fehlermeldung auszugeben, aber das Ergebnis ist nicht so wie erwartet. Das Programm tut genau das, was Sie ihm gesagt haben. Semantische Fehler zu finden ist schwierig, da von der Ausgabe aus rückwärts durch das Programm gearbeitet werden muss. Häufig ist es hilfreich zusätzliche `print`-Anweisungen einzufügen, die Zwischenergebnisse ausgeben, sodass der Punkt gefunden werden kann, an dem die erwarteten Ergebnisse von den tatsächlichen abweichen. \n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"Legen wir uns eine Liste mit den wichtigsten Begriffen an, die wir im Kapitel 2 gelernt haben:\n",
"- Variable:\n",
"- Zuweisung: Eine Zuweisung ist eine Anweisung, bei der einer Variable ein Wert zugewiesen wird\n",
"- Schlüsselwort:\n",
"- Ausdruck:\n",
"- Zeichenketten verknüpfen:\n",
"- Kommentar:\n",
"- Syntaxfehler:\n",
"- Laufzeitfehler:\n",
"- semantischer Fehler:\n",
"- `print`-Funktion:\n",
"Ergänzen Sie die Liste in eigenen Worten. Das ist eine gute Erinnerungs- und Übungsmöglichkeit.\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Hier lernen Sie einige Tricks kennen, um mit der `print`-Funktion ihre Ausgabe formatieren können.\n",
"Bis jetzt haben Sie gelernt, dass man sich mit Hilfe der `print`-Funktion Zeichenketten, Zahlen, Variablen, etc. ausgeben lassen kann. \n",
"Zeichenketten müssen dabei immer in Anführungszeichen stehen. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(\"Hallo Welt!\")\n",
"\n",
"print(42)\n",
"print(52-10)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Man kann auch mehrere Argumente übergeben, diese müssen durch ein Komma getrennt werden.\n",
"Die Ausgabe erfolgt mit einem Leerzeichen getrennt."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"source": [
"print(42, 35.32-9.0, \"Hallo Welt\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"und natürlich können Sie sich auch Variablen ausgeben lassen:\n",
" "
]
},
{
"cell_type": "code",
"execution_count": null,
"a = 42\n",
"b = \"Die Antwort lautet:\"\n",
" \n",
"print(b,a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Um längere Ausgaben, mehrere Variablen ,etc. schöner zu formatieren, gibt es einige Tricks.\n",
"Einmal kann man der Funktionen einen extra Parameter übergeben, der einstellt, durch welches Zeichen die verschiedenen Argumente getrennt werden sollen.\n",
"\n",
"Standardmäßig und wie oben gesehen, wird die Ausgabe mehrerer Argumente jeweils durch ein Leerzeichen getrennt.\n",
"Durch Hinzufügen des Parameter `print(b,a ,sep=\" \")` (MERKE: `sep` steht für `separator`) können Sie spezifizieren, welches Zeichen als Trennzeichen genommen wird. Schauen wir uns einige Beispiele an:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"a = 42\n",
"b = \"Die Antwort lautet:\"\n",
"\n",
"# wenn `sep` nicht angegeben ist, wird standardmäßig ein Leerzeichen zwischen den Argumenten in `print` verwendet\n",
"print(b,a)\n",
"# Jetzt geben wir explizit an, dass der separator ein Leerzeichen sein soll, d.h., die Ausgabe ändert sich nicht.\n",
"print(b,a, sep = \" \")\n",
"# Jetzt soll der separator zwei Leerzeichen sein:\n",
"print(b,a, sep = \" \")\n",
"# und jetzt soll der separator ein `tab` (4 Leerzeichen) sein, das wird durch `\\t`angegeben\n",
"print(b,a, sep = \"\\t\")\n",
"# nun soll der separator ein Zeilenumbruch sein, das wird durch `\\n`angegeben\n",
"print(b,a, sep = \"\\n\")\n",
"# zum schluss kann man noch triple quotes (drei Anführungszeichen am Anfang und drei am Ende) nutzen,\n",
"# um Text in mehreren Zeilen zu schreiben: ''' '''\n",
"print(''' \n",
"Erste Zeile\n",
"Zweite Zeile\n",
"''')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Die Befehle `\\t`und `\\n` funktionieren auch innerhalb einer Zeichenkette:"
]
},
{
"cell_type": "code",
"execution_count": null,
"print(\"Hallo \\t Welt,\\n die Antwort lautet\\n42\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wenn wir etwas neues lernen, sollten wir es immer gleich ausprobieren. Wir sollten auch versuchen absichtlich ein paar Fehler einzubauen, um zu schauen, was dann passiert und zu lernen, wie die Fehlermeldungen aussehen. \n",
"- Wir haben gesehen, dass `n = 42` erlaubt ist. Was ist mit `42 = n`?"
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Und wie sieht es mit `x = y = 1` aus? (Lassen Sie sich danach die Werte für `x` und `y` mit Hilfe der `print`-Funktion ausgeben.)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- In einigen Programmiersprachen müssen Anweisungen mit einem Semikolon (;) beendet werden. Was passiert, falls wir in Python ein Semikolon ans Ende einer Anweisung schreiben?"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Und was passiert, wenn wir einen Punkt (.) ans Ende einer Anweisung schreiben?"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Aufgabe 2\n",
"\n",
"Nutzen Sie Python als Taschenrechner. Denken Sie auch hier wieder daran, dass wir nicht zwingend Ihre mathematischen Fähigkeiten testen wollen. Nutzten Sie erst die Hinweise und versuchen Sie einander zu helfen aber zögern Sie nicht uns zu fragen. Es ist wichtiger, dass Sie verstehen, wie Sie die Aufgabe in Python umsetzen als die mathematischen Grundlagen zu verstehen.\n",
"\n",
"\n",
"- Wie groß ist das Volumen einer Kugel mit dem Radius 5?\n",
"\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-info\">Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
"\n",
"Die Formel zum Berechnen des Volumens ist: $v = 4/3⋅π⋅r^3$ \n",
"\n",
" \n",
" </div> \n",
"</details>"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Geben Sie hier Ihren Ausdruck zur Berechnung ein\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<details>\n",
" <summary type=\"button\" class=\"btn btn-success\">Lösung</summary>\n",
" <div class=\"alert alert-success\" role=\"alert\">\n",
" \n",
" </div> \n",
"</details>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Angenommen, der Preis des Buches \"Once upon an Algorithm\" ist 29,99€, aber wir bekommen es mit 40% Rabatt, weil wir eine Bildungseinrichtung sind. Der Versand kostet 3€ für das erste Buch und 0,75€ für jedes weitere Buch. Wir wollen 60 Exemplare für das IBI bestellen - was kostet uns das insgesamt?\n",
"\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-info\">Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
"\n",
"1. Berechnen Sie wieviel ein Buch mit 40% Rabatt kostet. \n",
" 1.1 Wieviel sind 40% des Buches? Berechnen Sie zuerst 1%.\n",
" 1.2 Ziehen Sie den Rabatt vom Preis des Buches ab. \n",
"2. Wieviel kosten dementsprechened 60 Bücher mit diesem Preis? \n",
" 3.1 Berechnen Sie die Versandkosten für Bücher 2-60 \n",
" 3.2 Vergessen Sie nicht das erste teurere Buch ebenfalls zu beachten. \n",
" \n",
" </div> \n",
"</details>"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Geben Sie hier Ihren Ausdruck zur Berechnung ein\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<details>\n",
" <summary type=\"button\" class=\"btn btn-success\">Lösung</summary>\n",
" <div class=\"alert alert-success\" role=\"alert\">\n",
" \n",
" Die gesamte Bestellung würde 1126,89€ kosten;\n",
" </div> \n",
"</details>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Wenn ich mein Haus um 6:52 Uhr verlasse und 1 Kilometer gemütlich laufe (8:15 Minuten pro Kilometer), dann 3 Kilometer schneller (7:12 Minuten pro Kilometer) und dann nochmal 1 Kilometer gemütlich, wann komme ich dann zum Frühstück an?\n",
"\n",
"\n",