Newer
Older
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Kapitel 1: Die Ersten Programme\n",
"__[Chapter 1 The Way of the Program](http://greenteapress.com/thinkpython2/html/thinkpython2002.html)__\n",
"\n",
"**Wichtig:** Bevor Sie anfangen dieses Jupyter-Notebook zu bearbeiten schauen Sie sich bitte zuerst [das Einführungsnotebook](einführung_jn.ipynb) sowie [das 0. Seminarnotebook](seminar00.ipynb) an. Diese enthalten wichtige Hinweise für das Verwenden von Jupyter-Notebooks. Wenn Sie die Notebooks in das selbe Verzeichnis heruntergeladen und nicht umbenannt haben, können Sie die Links verwenden um die entsprechenden Notebooks zu öffnen, andernfalls können Sie die Notebooks ebenfalls auf [Gitlab](https://scm.cms.hu-berlin.de/ibi/python/-/tree/master/notebooks) finden."
"<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=\"#Programme\" data-toc-modified-id=\"Programme-3\"><span class=\"toc-item-num\">3 </span>Programme</a></span><ul class=\"toc-item\"><li><span><a href=\"#Eine-erste-Anweisung\" data-toc-modified-id=\"Eine-erste-Anweisung-3.1\"><span class=\"toc-item-num\">3.1 </span>Eine erste Anweisung</a></span></li><li><span><a href=\"#Python-Programme-starten\" data-toc-modified-id=\"Python-Programme-starten-3.2\"><span class=\"toc-item-num\">3.2 </span>Python-Programme starten</a></span></li><li><span><a href=\"#Arithmetik\" data-toc-modified-id=\"Arithmetik-3.3\"><span class=\"toc-item-num\">3.3 </span>Arithmetik</a></span></li></ul></li><li><span><a href=\"#Werte-und-Datentypen\" data-toc-modified-id=\"Werte-und-Datentypen-4\"><span class=\"toc-item-num\">4 </span>Werte und Datentypen</a></span></li><li><span><a href=\"#Formale-und-natürliche-Sprachen\" data-toc-modified-id=\"Formale-und-natürliche-Sprachen-5\"><span class=\"toc-item-num\">5 </span>Formale und natürliche Sprachen</a></span></li><li><span><a href=\"#Exkurs:-Programmierer\" data-toc-modified-id=\"Exkurs:-Programmierer-6\"><span class=\"toc-item-num\">6 </span>Exkurs: Programmierer</a></span></li><li><span><a href=\"#Debugging\" data-toc-modified-id=\"Debugging-7\"><span class=\"toc-item-num\">7 </span>Debugging</a></span></li><li><span><a href=\"#Glossar\" data-toc-modified-id=\"Glossar-8\"><span class=\"toc-item-num\">8 </span>Glossar</a></span></li><li><span><a href=\"#Übung\" data-toc-modified-id=\"Übung-9\"><span class=\"toc-item-num\">9 </span>Übung</a></span><ul class=\"toc-item\"><li><span><a href=\"#Aufgabe-1\" data-toc-modified-id=\"Aufgabe-1-9.1\"><span class=\"toc-item-num\">9.1 </span>Aufgabe 1</a></span></li><li><span><a href=\"#Aufgabe-2\" data-toc-modified-id=\"Aufgabe-2-9.2\"><span class=\"toc-item-num\">9.2 </span>Aufgabe 2</a></span></li></ul></li></ul></div>"
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Beschreiben Sie in 2-3 Stichpunkten was Sie heute lernen wollen. Sie können diesen Text durch Doppelklick bearbeiten.\n",
" \n",
" - \n",
" - \n",
" - \n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Exkurs: Was mir an Python gefällt:\n",
"Ich finde toll, dass mir Python Berechnungen mit Datumsangaben sehr vereinfacht:\n",
"\n",
"Bitte beachten Sie, dass Sie **erst den Code ausführen (Strg + Enter)** und anschließend in das neue Eingabefeld Ihren Geburtstag eingeben."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import datetime\n",
"\n",
"datum = input(\"Geben Sie Ihr Geburtsdatum im Format TT.MM.JJJJ an: \")\n",
"\n",
"# Zahlen für Tag, Monat und Jahr extrahieren\n",
"(tag, monat, jahr) = (int(d) for d in datum.split('.'))\n",
"# Datumsobjekt anlegen\n",
"datum = datetime.datetime(jahr, monat, tag)\n",
"\n",
"print(\"You were born on a\", datum.strftime(\"%A\"),)"
{
"cell_type": "markdown",
"metadata": {},
"source": [
"> Eine Folge von Anweisungen, die genau beschreibt wie eine \"Berechnung\" ausgeführt werden muss\n",
"In jeder Programmiersprache sind die Details etwas anderes, aber es gibt ein paar grundlegende Instruktionen, die es in so gut wie jeder Programmiersprache gibt:\n",
" - **Eingabe (input)** Daten von der Tastatur, einer Datei, dem Netzwerk oder von irgendeinem anderen Gerät werden eingegeben\n",
" - **Ausgabe (output)** Darstellung von Daten auf dem Bildschirm, Speichern in einer Datei, Verschicken über das Netzwerk und so weiter\n",
" - **Berechnung (math)** Durchführen grundlegender mathematischer Operationen (Addition, Multiplikation, ...)\n",
" - **bedingte Ausführung (conditional execution)** Prüfe bestimmte Bedingungen und führe den entsprechenden Code aus\n",
" - **Wiederholung (repetition)** Führe eine beliebige Aktion wiederholt aus, normalerweise mit einigen Abweichungen\n",
"Das ist es im Wesentlichen. Jedes Programm, dass Sie schon verwendet haben, besteht im Grunde nur aus diesen Bausteinen. Programmieren heißt also, ein großes Problem in viele kleine Aufgaben zu zerlegen, die sich mit diesen Bausteinen lösen lassen."
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from IPython.lib.display import YouTubeVideo\n",
"YouTubeVideo('https://www.youtube.com/watch?v=oxXAb8IikHM&list=PL_pqkvxZ6ho3u8PJAsUU-rOAQ74D0TqZB')\n",
"\n",
"# Ab Minute 9:31 bis zum Ende"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Diese Bausteine bestehen aus kleineren Zeilen Code. Der Grundbaustein jedes Programms ist die **Anweisung**. Jedes Programm ist im Wesentlichen eine Folge von Anweisungen. Das erste Programm, das man häufig in Programmiersprachen schreibt heißt __[Hello World](https://de.wikipedia.org/wiki/Hallo-Welt-Programm)__. Es ist ein einfaches Programm mit nur einer Anweisung."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(\"Hello World!\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Diese Anweisung ruft die **Funktion** `print` auf und übergibt ihr das **Argument** \"Hello World!\", was in diesem Fall eine **Zeichenkette** ist (das erkennen wir an den Gänsefüßchen). Die **Argumente** einer Funktion werden immer nach dem Namen der Funktion in Klammern übergeben. \n",
Prof. Dr. Robert Jäschke
committed
"\n",
"Das Ergebnis dieses Funktionsaufrufs ist, dass die Zeichenkette auf dem Bildschirm ausgegeben wird. \n",
"Probieren Sie es nun selber und geben Sie eine Zeichenkette Ihrer Wahl aus, indem Sie die Zeichenkette in Gänsefüßchen der `print`-Funktion als **Argument** übergeben: "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Zusammengefasst: Die **Anweisung** ruft eine **Funktion** mit dem Namen `print` auf, der das **Argument** `Hello World!` mit `()` und Gänsefüßschen eingeschlossen übergeben wurde."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Python-Programme starten\n",
"\n",
"Wenn wir ein Programm (hier einer der Blöcke mit Python-Code) starten, dann starten wir im Hintergrund den sogenannten **Python-Interpreter**. Das ist ein Programm, welches den Python-Code liest, für den Computer übersetzt und ausführt. Wir können den Python-Interpreter auch ohne Jupyter aufrufen und dort direkt Python-Anweisungen eingeben oder Programme starten, die wir in einer Datei gespeichert haben. Für den Anfang bleiben wir aber bei Jupyter, weil wir hier Programme und Erklärungen leicht kombinieren können.\n",
"\n",
"**Tipp**: Nutzen Sie http://pythontutor.com, um Ihren Code nachvollziehen zu können und Fehler zu finden!\n",
"### Arithmetik\n",
"\n",
"Neben Zeichenketten sind Zahlen ein wichtiges Mittel zur Informationsdarstellung. Wir können mit der `print`-Funktion auch Zahlen ausgeben, diese müssen wir nicht in Gänsefüßchen einschließen:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(17)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Siebzehn ist eine **ganze Zahl** (*Englisch: Integer*), wir können aber auch **Gleitkommazahlen** (*Englisch: Float*) also Zahlen mit Dezimalanteil darstellen:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Dazu verwenden wir - anders als in Deutschland üblich - einen Punkt als Dezimaltrennzeichen anstelle eines Kommas. (Dies ist in den Ländern in denen Python entwickelt wurde so üblich.)\n",
"Arithmetische **Operatoren** ermöglichen die Verknüpfung von Zahlen durch Rechnen, z.B. `+` (Addition), `-` (Subtraktion), `*` (Multiplikation), `/` (Division), `**` (Exponentiation), `//` (ganzzahlige Division) und `%` (Modulo/Restoperator).\n",
"\n",
"Modulo ist das Gegenstück zur ganzzahligen Division (//). Es wird immer der \"Rest\" berechnet. Schauen wir uns ein Beispiel an:\n",
"Wir teilen 14 durch 4.\n",
"\n",
"- normale Division: `14 / 4 = 3.5`\n",
"- ganzzahlige Division: `14 // 4 = 3`\n",
"- modulo: `14 % 4 = 2`\n",
"\n",
"Es wird also immer die Restzahl angegeben. Die 4 passt 3mal in die 14, allerdings bleiben dann 2 \"Rest\" übrig. (also 3 Rest 2). \n",
"\n",
"Wir können eine Berechnung direkt mit `print` ausgeben:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Probieren Sie es selbst für folgende Berechnungen aus:\n",
"\n",
"- 40 + 2\n",
"- 43 - 1\n",
"- 6 * 7\n",
"- 84 / 2\n",
"Sie können die folgende Anweisung ändern oder ergänzen."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Tipp: Wir können mehrere Anweisungen hintereinander ausführen, indem wir sie als **Folge** von Anweisungen zeilenweise untereinander schreiben"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(\"Der Umfang eines Kreises mit dem Radius 3 ist:\")\n",
"print(2 * 3.1415926 * 3)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from IPython.lib.display import YouTubeVideo\n",
"YouTubeVideo('https://www.youtube.com/watch?v=1WqFJ5wsA4o&list=PL_pqkvxZ6ho3u8PJAsUU-rOAQ74D0TqZB&index=5')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ein **Wert**, also z.B. eine Zahl oder eine Zeichenkette, ist eines der grundlegenden Dinge, die in einem Programm verarbeitet werden. Beispiele für Werte, die wir schon gesehen haben sind `\"Hello World!\"`, `17` und `3.1415926`. Diese Werte haben verschiedenen **Datentypen**:\n",
"- `\"Hello World!\"` ist eine **Zeichenkette** (Englisch: *string*)\n",
"- `17` ist eine **ganze Zahl** (Englisch: *integer*)\n",
"- `3.1415926` ist eine **Gleitkommazahl** (Englisch: *float*)\n",
"\n",
"Wenn wir uns nicht sicher sind, welchen Datentyp ein Wert hat, können wir es mit der Funktion `type` herausfinden:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"type(\"Hello World!\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Diese gibt uns - je nach Datentyp - zum Beispiel die englischen Abkürzungen `str`, `int` und `float` zurück (die *string*, *integer* und *float* entsprechen). Probieren Sie es selbst mit verschiedenen Werten (z.B. 2, 42.0) aus:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Übrigens: `type` funktioniert auch mit anderen Arten von \"Typen\". Probieren Sie es mal aus, indem Sie der `type`-Funktion die `print`-Funktion übergeben: "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"type(print)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Was passiert, wenn wir Werte wie `\"42\"` und `\"3.14\"`mit Gänsefüßchen einfassen wie Zeichenketten? Sind es Zeichenketten oder Zahlen? Finden Sie es heraus indem Sie den folgenden Codeblock nutzen."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In Python gibt es noch weitere Datentypen, die wir später kennenlernen werden. Hier schon einmal ein Überblick: \n",
"\n",
""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Besonders ausführlich wird der Unterschied zwischen natürlicher und formaler Sprache in [Abschnitt 1.6](http://greenteapress.com/thinkpython2/html/thinkpython2002.html#sec11) des englischen Buchs behandelt.\n",
"\n",
"Grundsätzlich jedoch sind **natürliche Sprachen** Sprachen, die gesprochen werden, wie zum Beispiel Deutsch, Englisch oder Französisch. Sie werden nicht von Menschen entworfen und entwickeln sich natürlich.\n",
"\n",
"**Formale Sprachen** sind von Menschen für bestimmte Zwecke entworfene Sprachen. Das hier relevanteste Beispiel sind **Programmiersprachen**.\n",
"Sie haben meist sehr strenge **Syntax-Regeln**, die ihre Struktur bestimmen. Dabei gibt es Regeln zu den erlaubten Zeichen und zu der erlaubten Struktur. Während der menschliche **Parser** häufig mit sprachlichen Regelbrüchen umgehen kann, kann es der **Parser** im Computer nicht.\n",
"\n",
">Die§ ist ein gr@mmatikalisch k0rrekter S@tz mit ungültigen Zeichen. Satz dieser nur erlaubte Zeichen aber Grammatik falsche hat. \n",
"\n",
"Wichtige Unterschiede sind, dass natürliche Sprache zweideutig, redundant und voller Symbolismus sein darf, formale Sprache aber nicht."
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wir können effektiver programmieren, wenn wir eine **Entwicklungsumgebung** benutzen. Meistens ist das ein Texteditor, der einem das Programmieren erleichtert, indem z.B. der Quelltext farblich hervorgehoben wird - wie hier in Jupyter auch. Es gibt einen [seit Jahren schwelenden \"Streit\"](https://en.wikipedia.org/wiki/Editor_war), welcher Editor der beste ist: Emacs oder Vi. Randall Munroe (Autor des Webcomics [XKCD](https://xkcd.com/)) hat das auf seine ganz eigene Art verarbeitet:\n",
"\n",
"\n",
"\n",
"([Real Programmers](https://xkcd.com/378/), Randall Munroe)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Als Programmierer/innen machen wir häufiger Fehler. Diese Fehler werden **bugs** genannt und der Vorgang, Sie zu finden und zu beheben **debugging**. Dies kann zu starken (negativen) Gefühlen führen. \n",
"Es lässt sich darauf zurückführen, dass wir Computer unterbewusst wie Menschen behandeln und darum auf unkooperative Computer genauso reagieren wie auf unkooperative Mitmenschen. Es kann helfen darauf vorbereitet zu sein und den Computer als Mitarbeiter zu sehen, der sehr schnell und gut rechnen kann aber sehr genaue Anweisungen braucht.\n",
"Obwohl es sehr frustrierend sein kann zu lernen wie man diese Fehler findet und behebt ist es eine wertvolle Fähigkeit und in dieser Kategorie werden wir uns regelmäßig Tipps und Strategien des Debugging anschauen, die Ihnen hoffentlich helfen. \n",
"\n",
""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"Legen wir uns eine Liste mit den wichtigsten Begriffen an, die wir im Kapitel 1 gelernt haben:\n",
"- Anweisung: \n",
"- Programm: \n",
"- **`print`-Funktion**:\n",
"- Argument:\n",
"- Operator:\n",
"- Wert: \n",
"- Datentyp: \n",
"- Zeichenkette:\n",
"- ganze Zahl:\n",
"- Gleitkommazahl:\n",
"- bug:\n",
"- debugging:\n",
"\n",
"Ergänzen Sie die Liste in eigenen Worten. Das ist eine gute Erinnerungs- und Übungsmöglichkeit. \n",
"Sollten Sie einmal nicht weiterkommen, schauen Sie im Glossar von *Think Python* nach oder fragen Sie noch einmal nach."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Diese Übung ist ein wichtiger Teil des Seminars. Bitte fahren Sie erst fort, wenn Sie die Aufgaben selbständig lösen konnten. Sie geben Ihnen die Möglichkeit, das Gelernte zu überprüfen und zu vertiefen.\n",
"Wann immer wir etwas neues ausprobieren, sollten wir versuchen, absichtlich einen Fehler zu machen. Probieren Sie z.B. \n",
"- Was passiert, wenn Sie im \"Hello World\"-Programm eines der Gänsefüßchen weglassen?\n",
"- Was passiert, wenn Sie beide weglassen?\n",
"- Was passiert, wenn Sie `print` falsch schreiben?\n",
"- Was passiert, wenn Sie beim Aufruf der `print`-Funktion eine oder beide der Klammern weglassen?\n",
"Probieren Sie es aus:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Solche Experimente helfen uns dabei das Gelesene einzuprägen. Zusätzlich werden mit Fehlermeldungen vertraut und haben eine Ahnung, was sie bedeuten könnten. Lieber jetzt ein paar Fehler absichtlich machen, als später unabsichtlich. Und letztlich lernen wir Programmieren nur, indem wir programmieren.\n",
"\n",
"- Negative Zahlen können wir mit einem Minuszeichen darstellen: `-2`. Was passiert, wenn wir ein Plus-Zeichen vor eine Zahl stellen? Was ergibt `2++2`? Was ergibt `2+-+2`? Probieren Sie es mit verschiedenen Kombinationen von Plus- und Minus-Zeichen aus, bis Ihnen klar ist, was passiert:\n",
"\n",
"- In der Mathematik ist es kein Problem, eine Null vor einer Zahl zu schreiben: 02 ist gleich 2. Was passiert, wenn wir das in Python probieren?\n",
"- Was passiert, wenn wir zwei Werte ohne Operator dazwischen haben?"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Nutzen Sie Python als Taschenrechner: Keine Sorge, während Sie hier zwar Textaufgaben lösen müssen ist dies nicht das Ziel der Übung. Wenn Sie nicht weiterkommen schauen Sie sich zuerst die Hinweiße an und fragen Sie gegebenenfalls um Hilfe. Es geht hier darum zu verstehen, wie man diese Aufgabe in Python lösen kann, der Rechenweg ist eher Zweitrangig.\n",
"\n",
"- Wieviele Sekunden entsprechen 42 Minuten und 42 Sekunden?"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"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",
"2562 Sekunden\n",
" \n",
" </div> \n",
"</details>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Wieviele Meilen entsprechen 10 Kilometer \n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-info\">Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
"\n",
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-success\">Lösung</summary>\n",
" <div class=\"alert alert-success\" role=\"alert\">\n",
"\n",
"6.21 Meilen\n",
" \n",
" </div> \n",
"</details>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Wenn Sie ein Rennen über 10 Kilometer in 42 Minuten und 42 Sekunden beenden, was ist Ihre Durchschnittsgeschwindigkeit (**Zeit pro Meile** in Minuten und Sekunden)? Was ist Ihre Durchschnittsgeschwindigkeit in **Meilen pro Stunde**?\n",
"\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-info\">Hinweise</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
"1. Zuerst müssen Sie herausfinden wie viele Meilen das Rennen lang ist. Das können Sie im vorherigen Teil der Aufgabe erfahren. <br> \n",
"2. Rechnen Sie zudem die Zeit in Sekunden um. Dazu können Sie wieder die Lösung aus dem vorherigen Teil der Aufgabe nehmen. <br>\n",
"3. Um die Zeit pro Meile zu errechnen, müssen Sie die Gesamtzeit durch die Anzahl an Meilen teilen. Rechnen Sie anschließend die Zeit von Sekunden in Minuten pro Meile um. <br>\n",
"4. Um dann die Geschwindigkeit in Meilen pro Stunde zu berechnen gehen Sie analog vor. Teilen Sie die Gesamtzahl an Meilen durch die Gesamtdauer des Rennens. Rechnen Sie anschließend das Ergebnis von **Meilen pro Sekunde** in **Meilen pro Stunde** um.\n",
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"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 Durchschnittsgeschwindigkeit beträgt 6,88 Minuten pro Meile bzw. 8,73 Meilen pro Stunde.\n",
]
},
{
"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",
"Herzlichen Glückwunsch! Sie haben das erste Kapitel geschafft!"
]
}
],
"metadata": {
"language_info": {
"name": "python",
}
},
"nbformat": 4,
"nbformat_minor": 2
}