Newer
Older
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Seminar Problemorientierte Programmierung\n",
"\n",
"## 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",
"### Ihre Lernziele\n",
"\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",
"### Exkurs: Was mir an Python gefällt\n",
"\n",
"Dieses Programm durchsucht alle Jupyter Notebooks in dem Verzeichnes 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",
"### Zuweisung\n",
"\n",
"Die **Zuweisung** ist eine besondere Form der Anweisung. Sie erzeugt eine neue Variable und gibt ihr einen Wert. Wenn bereits eine Variable mit dem selben Namen existiert wird dieser nur ein Wert zugewiesen:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"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,
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### (Variablen)Namen\n",
"\n",
"Variablen (und auch Funktionen) benötigen Namen. Als Programmierer/in sollten wir Namen wählen, die aussagekräftig sind und dokumentieren, wofür die Variable (oder Funktion) verwendet wird. Folgende Regeln gelten: Variablennamen\n",
"- dürfen beliebig lang sein"
]
},
{
"cell_type": "code",
"execution_count": null,
"outputs": [],
"source": [
"diesistabereinelangevariableundtrotzdemmeckertpythonnicht = 1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- dürfen Zahlen (0-9), Buchstaben (A-Z, a-z) und Unterstrich (`_`) enthalten"
]
},
{
"cell_type": "code",
"execution_count": null,
"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,
"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 den Code aus, um die Fehlermeldungen zu sehen):"
]
},
{
"cell_type": "code",
"execution_count": null,
"outputs": [],
"source": [
]
},
{
"cell_type": "code",
"execution_count": null,
"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."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Ausdrücke und Anweisungen\n",
"\n",
"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,
"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,
"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,
"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",
"\n",
"*Hinweis: Die Formel ist* $U=2π⋅r$"
]
},
{
"cell_type": "code",
"execution_count": null,
"outputs": [],
"source": []
},
{
"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",
"### Reihenfolge von Operatoren\n",
"\n",
"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,
"outputs": [],
"source": [
" 2 * (3-1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" ist also 4 und"
]
},
{
"cell_type": "code",
"execution_count": null,
"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,
"outputs": [],
"source": [
"1 + 2**3"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"9 (und nicht 27) und "
]
},
{
"cell_type": "code",
"execution_count": null,
"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,
"outputs": [],
"source": [
"2*3-1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"5 und nicht 4 und "
]
},
{
"cell_type": "code",
"execution_count": null,
"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 (ausser Exponentiation). Im Ausdruck $ degrees/2*π$ wird also zuerst dividiert und dann wird mit $π$ multipliziert. Um stattdessen durch $π$ zu dividieren, können wir Klammern verwenden oder stattdessen $degrees / 2 /π$ 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,
"outputs": [],
"source": [
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Die Ausgabe sollte dann 20.564 statt 14.564 betragen.\n",
"\n",
"### Operatoren für Zeichenketten\n",
"\n",
"Im allgemeinen können wir mathematische Operatoren nicht für Zeichenketten verwenden, auch wenn die Zeichenketten wie Zahlen aussehen:"
]
},
{
"cell_type": "code",
"execution_count": null,
"outputs": [],
"source": [
"'2' - '1'"
]
},
{
"cell_type": "code",
"execution_count": null,
"outputs": [],
"source": [
"'acht' / 'zwei'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Es gibt aber zwei Ausnahmen: `+` und `*`:"
]
},
{
"cell_type": "code",
"execution_count": null,
"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 Zeichenketten verknüpfen (oder verketten). D.h., die Zeichenketten werden hinereinander geschrieben. \n",
"\n",
"Mit dem Operator `*` können wir eine Zeichkette wiederholen: "
]
},
{
"cell_type": "code",
"execution_count": null,
"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,
},
{
"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,
"outputs": [],
"source": [
"pi = 3.1415926\n",
"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,
"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,
"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,
"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:"
]
},
{
"cell_type": "code",
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"distance((x1, y1), (x2, y2)) = 5.0\n"
]
}
],
"import math \n",
"#Ich verstehe auch nicht genau, was sie hier berechnen. Eventuell ist ein anderes, eindeutigeres Beispiel besser\n",
"\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)"
]
},
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"x1,x2= -0.2857142857142857 -1.0\n"
]
}
],
"source": [
"import math\n",
"#Alternativ Vorschlag. Natürlich deutlich simpler aber fast genauso viele Berechnungen und vielleicht offensichtlicher.\n",
"#Sie sollen ja nur kommentieren üben?\n",
"a=7\n",
"b=9\n",
"c=2\n",
"\n",
"x1=((-b)+math.sqrt((b**2)-(4*a*c)))/(2*a)\n",
"x2=((-b)-math.sqrt((b**2)-(4*a*c)))/(2*a)\n",
"\n",
"print (\"x1,x2=\", x1, x2)"
]
},
{
"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)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Debugging\n",
"\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 und 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 ausergewöhnliches (und schlechtes) passiert ist. In einfachen Problemen 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": [
"### Glossar\n",
"\n",
"Legen wir uns eine Liste mit den wichtigsten Begriffen an, die wir im Kapitel 2 gelernt haben:\n",
"- Variable:\n",
"- Zuweisung:\n",
"- Schlüsselwort:\n",
"- Ausdruck:\n",
"- Zeichenketten verknüpfen:\n",
"- Kommentar:\n",
"- Syntaxfehler:\n",
"- Laufzeitfehler:\n",
"- semantischer Fehler:\n",
"Ergänzen Sie die Liste in eigenen Worten. Das ist eine gute Erinnerungs- und Übungsmöglichkeit.\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Übung\n",
"\n",
"#### Aufgabe 1\n",
"\n",
"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. \n",
"\n",
"- Wir haben gesehen, dass `n = 42` erlaubt ist. Was ist mit `42 = n`?"
]
},
{
"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,
"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,
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Aufgabe 2\n",
"\n",
"Nutzen Sie Python als Taschenrechner:\n",
"- Das Volumen einer Kugel mit dem Radius r ist 4/3 π r³. Wie groß ist das Volumen einer Kugel mit dem Radius 5?"
]
},
{
"cell_type": "code",
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"523.5987755982989\n"
]
}
],
"# Geben Sie hier Ihren Ausdruck zur Berechnung ein\n",
"import math\n",
"\n",
"m= 4/3*math.pi*5**3\n",
"print (m)"
]
},
{
"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?"
]
},
{
"cell_type": "code",
"execution_count": null,
"outputs": [],
"source": [
"# Geben Sie hier Ihren Ausdruck zur Berechnung ein"
]
},
{
"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?"
]
},
{
"cell_type": "code",
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2286\n"
]
}
],
"#Geben Sie hier Ihren Ausdruck zur Berechnung ein"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a data-flickr-embed=\"true\" href=\"https://www.flickr.com/photos/jasoneppink/4964471335\" title=\"Spoiler Alert\"><img src=\"https://farm5.staticflickr.com/4110/4964471335_1f86a923f3_n.jpg\" width=\"320\" height=\"213\" alt=\"Spoiler Alert\"></a><script async src=\"//embedr.flickr.com/assets/client-code.js\" charset=\"utf-8\"></script>\n",
"\n",
"(Quelle: Jason Eppink, Flickr)\n",
"\n",
"Volumen 523.599; Die gesamte Bestellung würde 1126,89€ kosten; Ankunft ist 7:30 Uhr und 6 Sekunden"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" Speichern Sie dieses Notebook, so dass Ihre Änderungen nicht verlorengehen (nicht auf einem Pool-Rechner). Rufen Sie dazu im Menü \"File\" den Punkt \"Download as\"->\"Notebook\" auf und nutzen Sie beispielsweise einen USB-Stick, E-Mail, Google Drive, Dropbox oder Ihre [HU-Box](https://box.hu-berlin.de/). \n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"Herzlichen Glückwunsch! Sie haben das 2. Kapitel geschafft!"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.6.2"
}
},
"nbformat": 4,
"nbformat_minor": 2
}