From 10803745cc6a667af24cfd8a6019a3c5ed5de045 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robert=20J=C3=A4schke?= <jaeschke@l3s.de>
Date: Mon, 9 Jul 2018 17:51:56 +0200
Subject: [PATCH] aktualisierung von Frau Brauer
---
notebooks/seminar01.ipynb | 224 ++++++++++++++------------------------
1 file changed, 80 insertions(+), 144 deletions(-)
diff --git a/notebooks/seminar01.ipynb b/notebooks/seminar01.ipynb
index f1ca714..9933d89 100644
--- a/notebooks/seminar01.ipynb
+++ b/notebooks/seminar01.ipynb
@@ -6,27 +6,23 @@
"source": [
"# Seminar Problemorientierte Programmierung\n",
"\n",
+ "## Kapitel 1: Die Ersten Programme\n",
+ "__[Chapter 1 The Way of the Program](http://greenteapress.com/thinkpython2/html/thinkpython2002.html)__\n",
"\n",
- "## 1: Die ersten Programme\n",
- "\n",
- "siehe http://greenteapress.com/thinkpython2/html/thinkpython2002.html\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",
- "- \n",
- "- \n",
- "- "
+ "### Ihre Lernziele:\n",
+ "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",
- "\n",
- "In dieser Rubrik, die immer am Anfang eines Kapitels steht, möchte ich Ihnen zeigen, wofür ich Python nutze und warum ich es mag. Sie werden vielleicht noch nicht verstehen, was ich genau mache, aber Sie sehen damit schon einmal die Möglichkeiten von Python und können später darauf zurückgreifen. Da dies auch ein Exkurs ist, können Sie diese Rubrik gerne auch erst einmal überspringen.\n",
+ "## Exkurs: Was mir an Python gefällt:\n",
"\n",
"Ich finde toll, dass mir Python Berechnungen mit Datumsangaben sehr vereinfacht:"
]
@@ -46,7 +42,7 @@
"# Datumsobjekt anlegen\n",
"datum = datetime.datetime(jahr, monat, tag)\n",
"\n",
- "print(\"Sie wurden an einem\", datum.strftime(\"%A\"), \"geboren.\")\n"
+ "print(\"You were born on a\", datum.strftime(\"%A\"),)"
]
},
{
@@ -57,29 +53,26 @@
"\n",
"Was ist ein Programm?\n",
"\n",
- "> a sequence of instructions that speci\u001c",
- "es how to perform a computation\n",
+ "> Eine Folge von Anweisungen, die genau beschreibt wie eine \"Berechnung\" ausgeführt werden muss\n",
"\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",
"\n",
- "- **input:** get data from keyboard, \u001c",
- "le, network, or some other device\n",
- "- **output:** display data on screen, save in a \u001c",
- "file, send over network, etc.\n",
- "- **math:** perform basic mathematical operations (addition, multiplication, ... )\n",
- "- **conditional execution:** check for certain conditions and run appropriate code\n",
- "- **repetition:** perform some action repeatedly, usually with some variation\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",
"\n",
- "Das ist's im Wesentlichen. Jedes Programm welches Sie schon einmal 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 damit lösen lassen."
+ "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": "markdown",
"metadata": {},
"source": [
- "### eine erste Anweisung\n",
+ "### Eine erste Anweisung\n",
"\n",
- "Der Grundbaustein eines jeden Programms ist die **Anweisung**, denn jedes Programm ist im Wesentlichen eine Folge von Anweisungen. Ein einfaches Programm mit nur einer Anweisung ist das berühmte *Hello World* (Exkurs: [Warum \"Hello World\"?](https://en.wikipedia.org/wiki/%22Hello,_World!%22_program)):"
+ "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."
]
},
{
@@ -95,15 +88,13 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "(Sie können das Programm aufrufen, indem Sie in den Block mit dem Programm klicken und dann auf den \"Play\"-Button oben klicken oder die Tastenkombination `STRG+ENTER` drücken oder \"Run Cells\" im \"Cell\"-Menü aufrufen.)\n",
- "\n",
- "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",
+ "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",
"\n",
"\n",
"\n",
"Das Ergebnis dieses Funktionsaufrufs ist, dass die Zeichenkette auf dem Bildschirm ausgegeben wird.\n",
"\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 (zwischen den Klammern) übergeben: "
+ "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: "
]
},
{
@@ -119,22 +110,17 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Zusammengefasst: `print(\"Hello World!\")` ist eine Anweisung, die eine Funktion aufruft und aus den folgenden Bestandteilen besteht:\n",
- "- dem Namen der Funktion, die aufgerufen wird - `print`\n",
- "- den Argumenten, die der Funktion übergeben werden - in Klammern `()` eingeschlossen\n",
- "- konkret, dem Argument `\"Hello World!\"` - einer Zeichenkette, die mit Gänsefüßchen `\"\"` eingeschlossen ist\n",
- "\n",
- "Jeglicher Aufruf einer Funktion besteht im Wesentlichen aus diesen Bestandteilen. \n",
- "\n",
- "### Python-Programme starten\n",
- "\n",
- "Wenn wir ein Programm (einen der vielen Blöcke mit Python-Code hier) 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 dann 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."
+ "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",
"### 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:"
@@ -153,7 +139,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Die 17 ist eine **ganze Zahl** (Englisch: *Integer*), wir können aber auch Zahlen mit Dezimalanteil, sogenannte **Gleitkommazahlen** (Englisch: *Float*) verwenden:"
+ "Siebzehn ist eine **ganze Zahl** (*Englisch: Integer*), wir können aber auch **Gleitkommazahlen** (*Englisch: Float*) also Zahlen mit Dezimalanteil darstellen:"
]
},
{
@@ -162,14 +148,14 @@
"metadata": {},
"outputs": [],
"source": [
- "print(3.149265)"
+ "print(3.14159)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "Dazu verwenden wir als Dezimaltrennzeichen den Punkt `.`, nicht das Komma. (Weil das Komma eher in Deutschland verbreitet ist und der Punkt in den Ländern, in denen Python entwicklt wurde.)\n",
+ "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",
"\n",
"Arithmetische **Operatoren** ermöglichen die Verknüpfung von Zahlen durch Rechnen, z.B. `+` (Addition), `-` (Subtraktion), `*` (Multiplikation), `/` (Division) und `**` (Exponentiation). \n",
"\n",
@@ -182,21 +168,22 @@
"metadata": {},
"outputs": [],
"source": [
- "print(1 + 2 + 3 + 4 + 5)"
+ "print(1+2+3-4+5)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "Probieren Sie es selbst aus für folgende Berechnungen:\n",
+ "Probieren Sie es selbst für folgende Berechnungen aus:\n",
+ "\n",
"- 40 + 2\n",
"- 43 - 1\n",
"- 6 * 7\n",
"- 84 / 2\n",
- "- `6**2 + 6`\n",
+ "- 6**2 + 6\n",
"\n",
- "indem Sie die folgende Anweisung ändern oder ergänzen:"
+ "Sie können die folgende Anweisung ändern oder ergänzen."
]
},
{
@@ -205,14 +192,14 @@
"metadata": {},
"outputs": [],
"source": [
- "print(40 + 2)"
+ "print(40+2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "Tipp: Wir können auch mehrere Anweisungen hintereinander ausführen, indem wir sie als **Folge** von Anweisungen zeilenweise untereinander schreiben:"
+ "Tipp: Wir können mehrere Anweisungen hintereinander ausführen, indem wir sie als **Folge** von Anweisungen zeilenweise untereinander schreiben"
]
},
{
@@ -232,9 +219,9 @@
"### Werte und Datentypen\n",
"\n",
"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** (*string* auf Englisch)\n",
- "- `17` ist eine **ganze Zahl** (*integer* auf Englisch)\n",
- "- `3.1415926` ist eine **Gleitkommazahl** (*float* auf Englisch)\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:"
]
@@ -252,7 +239,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Diese gibt uns - je nach Datentyp - die englischen Abkürzungen `str`, `int` und `float` zurück (die *string*, *integer* und *float* entsprechen). Probieren Sie es selbst aus, mit verschiedenen Werten, z.B. 2, 42.0, usw.:"
+ "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:"
]
},
{
@@ -261,7 +248,7 @@
"metadata": {},
"outputs": [],
"source": [
- "type(2)"
+ "type()"
]
},
{
@@ -284,7 +271,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Was ist mit Werten wie z.B. `\"42\"` oder `\"3.14\"`? Sie sehen wie Zahlen aus, aber wir haben sie mit Gänsefüßchen umfasst wie bei Zeichenketten? Finden Sie heraus, welchen Typ diese beiden Werte haben, indem Sie sie als Argument in den folgenden Funktionsaufruf einsetzen: "
+ "Was passiert, wenn wir Werte wie `\"42\"` und `\"3.14\"`mit Gänsefüßchen einfassen wie Zeichenketten? Finden Sie es heraus indem Sie den folgenden Codeblock nutzen."
]
},
{
@@ -292,9 +279,7 @@
"execution_count": null,
"metadata": {},
"outputs": [],
- "source": [
- "type()"
- ]
+ "source": []
},
{
"cell_type": "markdown",
@@ -303,7 +288,7 @@
"Sind es Zeichenketten oder Zahlen?\n",
"\n",
"\n",
- "Exkurs: In Python gibt es noch weitere Datentypen, die wir später kennenlernen werden. Hier schon einmal ein Überblick: \n",
+ "In Python gibt es noch weitere Datentypen, die wir später kennenlernen werden. Hier schon einmal ein Überblick: \n",
"\n",
""
]
@@ -314,7 +299,16 @@
"source": [
"### Formale und natürliche Sprachen\n",
"\n",
- "Exkurs: Wenn Ihnen der Unterschied zwischen einer natürlichen Sprache (z.B. Englisch) und einer formalen Sprache (z.B., der Programmiersprache Python) noch nicht ganz klar ist, lesen Sie den [Abschnitt 1.6](http://greenteapress.com/thinkpython2/html/thinkpython2002.html#sec11) im Python-Kurs. "
+ "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 menschenliche **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 näturliche Sprache zweideutig, redundant und voller Symbolismus sein darf, formale Sprache aber nicht."
]
},
{
@@ -336,9 +330,10 @@
"source": [
"### Debugging\n",
"\n",
- "Unter der Rubrik \"Debugging\" werden wir uns regelmäßig am Ende eines Kapitels Tipps zum Finden und Beheben von Fehlern anschauen.\n",
+ "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ück fü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",
"\n",
- "Exkurs: Als Programmierer/innen machen wir häufiger Fehler. Diese Fehler werden **bugs** genannt und der Vorgang, Sie zu finden und zu beheben **debugging**. Fehler sind ärgerlich und können zu bösartigen Gefühlen dem Computer gegenüber führen ... lesen Sie im [Abschnitt 1.7](http://greenteapress.com/thinkpython2/html/thinkpython2002.html#sec12), wie Sie damit umgehen können.\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",
""
]
@@ -350,9 +345,10 @@
"### Glossar\n",
"\n",
"Legen wir uns eine Liste mit den wichtigsten Begriffen an, die wir im Kapitel 1 gelernt haben:\n",
+ "\n",
"- Anweisung: \n",
"- Programm: \n",
- "- `print`-Funktion: gibt den übergebenen Wert auf dem Bildschirm aus\n",
+ "- `print`-Funktion:\n",
"- Argument:\n",
"- Operator:\n",
"- Wert: \n",
@@ -363,19 +359,8 @@
"- bug:\n",
"- debugging:\n",
"\n",
- "Ergänzen Sie die Liste in eigenen Worten. Das ist eine gute Erinnerungs- und Übungsmöglichkeit.\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Zusammenfassung\n",
- "\n",
- "Neben vielen neuen Begriffen haben wir folgende wichtige Programmierfähigkeiten gelernt:\n",
- "- wir können Werte und Berechnungen durchführen und mit Hilfe der `print`-Funktion ausgeben\n",
- "- wir können die Datentypen Zeichenkette, ganze Zahl und Gleitkommazahl voneinander unterscheiden und den Datentyp eines gegebenen Wertes mit Hilfe der `type`-Funktion herausfinden\n",
- "- wir können mehrere Anweisungen hintereinanderausführen, indem wir sie als Folge zeilenweise untereinander schreiben"
+ "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."
]
},
{
@@ -392,6 +377,7 @@
"- 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:"
]
},
@@ -400,66 +386,18 @@
"execution_count": null,
"metadata": {},
"outputs": [],
- "source": [
- "print(\"Hello World!\")"
- ]
+ "source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "Solche Experimente helfen uns das einzuprägen, was wir gelesen haben. Und wir werden mit Fehlermeldungen vertraut und haben eine Ahnung, was sie bedeuten können. Lieber jetzt ein paar Fehler absichtlich machen, als später unabsichtlich. Und letztlich lernen wir Programmieren nur, indem wir es tun.\n",
+ "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",
"\n",
- "Probieren Sie folgendes aus:\n",
- "- Was passiert, wenn Sie beim Aufruf der `print`-Funktion eine oder beide der Klammern weglassen?"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "print(\"Hello World!\")\n",
- "print(42)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "- 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:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "print(-2)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "- 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?"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "print() "
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
"- Was passiert, wenn wir zwei Werte ohne Operator dazwischen haben?"
]
},
@@ -468,9 +406,7 @@
"execution_count": null,
"metadata": {},
"outputs": [],
- "source": [
- "print()"
- ]
+ "source": []
},
{
"cell_type": "markdown",
@@ -494,8 +430,6 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "(Ergebnis: 2562 Sekunden)\n",
- "\n",
"- Wieviele Meilen entsprechen 10 Kilometer (Hinweis: eine Meile ist 1.61 Kilometer lang)"
]
},
@@ -510,9 +444,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "(Ergebnis: 6.21 Meilen)\n",
- "\n",
- "- 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"
+ "- 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?"
]
},
{
@@ -526,19 +458,23 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "(Die Durchschnittsgeschwindigkeit beträgt 6,88 Minuten pro Meile bzw. 8,73 Meilen pro Stunde.)\n",
+ "##### Ergebnisse\n",
+ "\n",
+ "([Spoiler Alert](https://xkcd.com/109/), Randall Munroe)\n",
"\n",
- " 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"
+ "\n",
+ "\n",
+ "2562 Sekunden, 6.21 Meilen, Die Durchschnittsgeschwindigkeit beträgt 6,88 Minuten pro Meile bzw. 8,73 Meilen pro Stunde"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "\n",
+ " 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",
"\n",
- "Herzlichen Glückwunsch! Sie haben das 1. Kapitel geschafft. Weiter geht es in [2: Variablen, Ausdrücke und Anweisungen](seminar02.ipynb)."
+ "Herzlichen Glückwunsch! Sie haben das erste Kapitel geschafft!"
]
}
],
--
GitLab