Newer
Older
"source": [
"def area_triangle(a, b, c):\n",
" # Formulieren Sie hier den Rumpf der Funktion\n",
" \n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Testen Sie Ihr Ergebnis mit einem Dreieck mit den Seitenlängen 3, 4 und 5. Der Flächeninhalt sollte 6 ergeben:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(area_triangle(3, 4, 5))"
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wir werden uns Funktionen mit Rückgabewert später noch genauer anschauen."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
Miriam Brauer
committed
"Eine der wichtigsten Fähigkeiten des Programmierens ist **Debugging**. Obwohl es manchmal frustrierend ist, ist es einer der intellektuell anspruchsvollsten, herausforderndsten und interessantesten Aspekte des Programmierens.\n",
"Debugging ist wie **Detektiv spielen**: Wir haben ein paar Hinweise und wir müssen die Vorgänge und Ereignisse herausfinden, die zu den Ergebnissen geführt haben, die wir sehen.\n",
"\n",
Miriam Brauer
committed
"Debugging ist aber auch wie eine **experimentelle Wissenschaft**: Wenn wir erstmal eine Idee haben, was schiefgelaufen sein könnte, können wir unser Programm verändern und es noch einmal versuchen. Wenn unsere Annahme richtig war, können wir das Ergebnis unserer Veränderung vorhersagen. Damit kommen wir hoffentlich einem richtig funktionierendem Programm näher. Wenn unsere Annahme falsch war, müssen wir uns eine neue überlegen. Wie schon Sherlock Holmes sagte: *\"Wenn man das Unmögliche ausgeschlossen hat, muss das, was übrig bleibt — wie unwahrscheinlich auch immer —, die Wahrheit sein\"* (A. Conan Doyle, *The Sign of Four*).\n",
Miriam Brauer
committed
"Für einige Menschen ist Programmieren und Debugging das gleiche. Das heißt, Programmieren bedeutet, dass man ein Programm solange debuggt bis es das tut, was man möchte. Die Idee ist, dass man mit einem kleinen, einfachen - und vor allem funktionierenden- Programm beginnt und solange kleine Änderungen vornimmt bis es tut was es soll. Währenddessen muss man natürlich konstant debuggen.\n",
"\n",
"\n",
"Ein Beispiel ist **Linux**: ein Betriebssystem, welches auf Millionen von Rechnern verwendet wird und Millionen von Codezeilen enthält. Linux begann als ein einfaches Programm welches der finnische Student Linus Torvalds geschrieben hat, um den Intel 386 Prozessor besser zu verstehen. Laut Larry Greenfield war einer der ersten Versuche von Linus ein Programm, welches abwechselnd \"AAAA\" und \"BBBB\" ausgab. Daraus wurde später Linux. (*The Linux Users’ Guide Beta Version 1*). "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"Legen wir uns eine Liste mit den wichtigsten Begriffen an, die wir im Kapitel 3 gelernt haben:\n",
"- Funktion:\n",
"- Funktionsdefinition:\n",
"- Funktionsobjekt:\n",
Miriam Brauer
committed
"- Kopf: Der Kopf einer Funktionsdefinition gibt den Namen der Funktion sowie alle geforderten Argumente in Klammern an und wird von einem Doppelpunkt abgeschlossen.\n",
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
"- Rumpf:\n",
"- Parameter:\n",
"- Funktionsaufruf:\n",
"- Argument:\n",
"- lokale Variable:\n",
"- Rückgabewert:\n",
"- `None`:\n",
"- Modul:\n",
"- `import`-Anweisung:\n",
"- Modul-Objekt:\n",
"- Punkt-Schreibweise:\n",
"- Verknüpfung:\n",
"- Kontrollfluss:\n",
"- Stapel-Diagramm:\n",
"- Box:\n",
"- Traceback:\n",
"\n",
"Ergänzen Sie die Liste in eigenen Worten. Das ist eine gute Erinnerungs- und Übungsmöglichkeit.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"### Aufgabe 1\n",
"\n",
Miriam Brauer
committed
"\n",
"#### Aufgabe 1a\n",
"Diese Aufgabe ist etwas schwieriger, daher haben Sie zwei Möglichkeiten:\n",
"\n",
"1. Lösen Sie die Aufgabe selbständig.\n",
"2. Scrollen Sie etwas herunter und lösen Sie die Aufgabe mit etwas Hilfe (\"Lückentext\").\n",
"\n",
"Schreiben Sie eine Funktion `right_justify` die eine Zeichenkette als Parameter `s` erwartet und diese Zeichenkette rechtsbündig ausgibt. Konkret heißt das, dass so viele Leerzeichen vor der Zeichenkette ausgibt, dass der letzte Buchstabe der Zeichenkette in Spalte 70 angezeigt wird. \n",
"\n",
"Beispiel: wenn wir die fertige Funktion mit dem Wert `monty` aufrufen, soll folgendes passieren:\n",
"```python\n",
"right_justify('monty')\n",
" monty\n",
"```\n",
"\n",
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
"Zunächst ein allgemeiner Hinweis, der Elemente von Python aufzeigt, die für die Lösung des Problems wichtig sind: \n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-info\">Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Nutzen Sie die Zeichenkettenverknüpfung und -wiederholung. Python bietet uns auch eine Funktion an, mit der wir die Länge einer Zeichenkette ermitteln können. Diese Funktion heißt `len`. Sie erwartet als Argument eine Zeichenkette und gibt ihre Länge zurück. Der Rückgabewert von `len('monty')` ist also `5`.\n",
" \n",
" </div> \n",
"</details> \n",
"\n",
"\n",
"Jetzt ein paar Tipps, wie Sie das Problem angehen könnten. Lesen Sie nicht alles auf einmal durch, sondern nur jeweils einen Tipp und versuchen Sie dann erstmal wieder, das Problem zu zweit zu lösen. Wenn Sie mit diesen Tipps nicht weiterkommen, finden Sie ein wenig weiter Unten einen Lückentext, den Sie vervollständigen sollen. Die Beste Übung für Sie ist es diese Aufgabe mit so wenigen Hinweisen wie möglich zu lösen.\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">1. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Fangen Sie damit an den Kopf der Funktion zu schreiben, welche Elemente benötigen Sie hier?\n",
" \n",
" </div> \n",
"</details> \n",
" \n",
" \n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">2. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Lösen Sie die Aufgabe zunächst für die Zeichenkette 'monty' und verallgemeinern Sie diese Lösung anschließend.\n",
" \n",
" </div> \n",
"</details> \n",
" \n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">3. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Wie können Sie die Anzahl an benötigten Leerzeichen berechnen? Welche Werte und Funktionen benötigen Sie?\n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">4. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Geben Sie das Wort 'monty' rechtsbündig aus, verwenden Sie dabei nicht die konkret berechneten Zahlen, sondern die Berechnungen, die Sie durchgeführt haben. \n",
" \n",
" </div> \n",
"</details>\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">5. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Wenn Sie unsicher sind, wie Sie mehrere Elemente in einer 'print' Anweisung ausgeben können, schauen Sie sich noch einmal das 'print'- Tutorium aus dem 2. Notebook an. \n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">6. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Mit dem '*' Operator können Sie ein Leerzeichen beliebig oft ausgeben, nutzen Sie das um die korrekte Anzahl an Leerzeichen zu drucken.\n",
" \n",
" </div> \n",
"</details>\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">7. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"An welchen Stellen wird der Parameter 's' eingesetzt um eine beliebige Zeichenkette ausgeben zu können?\n",
" \n",
" </div> \n",
"</details>\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">8. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Ersetzen Sie 'monty' durch den Buchstaben s. (Dies müsste an 2 Stellen notwendig sein, einmal in der Berechnung der Leerzeichen und einmal in der print- Anweisung.)\n",
" \n",
" </div> \n",
"</details>"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Definieren Sie hier die Funktion right_justify:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Wenn Sie fertig sind, rufen Sie die Funktion hier auf:\n",
"right_justify(\"Monty Python's\")\n",
"right_justify('The Ministry of Silly Walks')\n",
"# (und testen Sie die Funktion zwischendurch immer mal)"
]
},
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Macht Ihre Funktion auch wirklich, was sie soll? Ein paar Ideen zum Testen:\n",
"- Zählen Sie die Leerzeichen bis zum Wort. Das ist schwierig, da Leerzeichen schwer zu sehen sind. Zum Zählen können Sie das Leerzeichen durch ein anderes Zeichen — zum Beispiel einen Punkt — ersetzen.\n",
"- Bei kurzen Wörtern sind es recht viele Punkte; als Abhilfe könnten Sie, statt in der 70. Spalte, alles rechtsbündig in der 10. Spalte ausgeben, also 70 Zeichen auf 10 reduzieren. Dann lässt es sich leichter zählen.\n",
"\n",
"Wenn Ihre Funktion so richtig funktioniert, sollte sie auch mit Leerzeichen statt Punkten und rechtsbündig in Spalte 70 statt Spalte 10 korrekt funktionieren. Das ist auch Debugging und Testen — es ist wichtig, um Fehler zu finden und hilft Ihnen, mit Ihrem Programm vertrauter zu werden."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Abschlussfrage: was passiert, wenn Sie die Funktion mit einer Zeichenkette aufrufen, die länger als 70 Zeichen ist? Probieren Sie es aus:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"right_justify('Abschlussfrage: was passiert, wenn Sie die Funktion mit einer Zeichenkette aufrufen, die länger als 70 Zeichen ist?')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
Miriam Brauer
committed
"##### Lückentext\n",
"\n",
"\n",
"\n",
"\n",
"Bitte hier nur weiterlesen, wenn Sie weitere Hilfe benötigen. Versuchen Sie es aber vorher unbedingt erst einmal zu zweit. Es lohnt sich die Lösung selber herauszufinden; so lernen Sie am meisten dazu. \n",
"\n",
"So sollte der Kopf Ihrer Funktion ausehen (alle notwendigen Informationen dazu stehen im ersten Teil des ersten Satzes der Aufgabe):\n",
"\n",
"```python\n",
"def right_justify(s):\n",
"```\n",
"\n",
".\n",
"\n",
". \n",
"\n",
". \n",
"\n",
"Daraus resultiert dann dieser Lückentext:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def right_justify(s):\n",
" # Anzahl Leerzeichen berechnen\n",
" anzahl_leerzeichen = \n",
" # Zeichenkette erzeugen\n",
" ergebnis =\n",
" # und ausgeben\n",
" print()"
]
},
Miriam Brauer
committed
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Jetzt ein paar Tipps, wie Sie das Problem angehen könnten. Lesen Sie nicht alles auf einmal durch, sondern nur jeweils einen Tipp und versuchen Sie dann erstmal wieder, das Problem zu zweit zu lösen: \n",
"1. Wieviele Leerzeichen benötigen Sie, um 'monty' rechtsbündig auszugeben? (Falls Sie die Frage nicht beantworten können, lesen Sie sich die Aufgabe nochmal genau durch.)\n",
"2. Wie können Sie diese Anzahl berechnen? Welche Werte benötigen Sie dafür?\n",
"3. Das alles können Sie jetzt schon in Ihre Funktion packen.\n",
"4. Funktioniert das was Sie geschrieben haben auch für andere Werte als 'monty', insbesondere für den Parameter `s` der Funktion?\n",
"5. Wenn Sie jetzt ausgerechnet haben, wie viele Leerzeichen Sie benötigen, müssen Sie diese noch erzeugen.\n",
"6. Dafür können Sie den Operator `*` für Zeichenkettenwiederholung verwenden. \n",
"7. `' ' * 10` ergibt z.B. 10 Leerzeichen\n",
"8. Jetzt haben Sie genug Leerzeichen, aber die müssen ja noch vor die Zeichenkette `s`.\n",
"9. Sie können Zeichenketten mittels `+` verknüpfen.\n",
"10. `' ' * 65 + 'monty'` wäre die Zeichenkette, die Sie für 'monty' bräuchten. Wie können Sie das allgemein formulieren, sodass es auch für den Parameter `s` (mit beliebiger Länge) funktioniert?\n",
"11. Schließlich müssen Sie das Ergebnis noch ausgeben - dafür gibt es die `print`-Funktion."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Macht ihre Funktion auch wirklich, was sie soll? Ein paar Ideen zum Testen:\n",
Miriam Brauer
committed
"- Zählen Sie die Leerzeichen bis zum Wort. Das ist schwierig, da Leerzeichen schwer zu sehen sind. Zum Zählen können Sie das Leerzeichen durch ein anderes Zeichen — zum Beispiel einen Punkt — ersetzen.\n",
"- Bei kurzen Wörtern sind es recht viele Punkte; als Abhilfe könnten Sie, statt in der 70. Spalte, alles rechtsbündig in der 10. Spalte ausgeben, also 70 Zeichen auf 10 reduzieren. Dann lässt es sich leichter zählen.\n",
Miriam Brauer
committed
"Wenn Ihre Funktion so richtig funktioniert, sollte sie auch mit Leerzeichen statt Punkten und rechtsbündig in Spalte 70 statt Spalte 10 korrekt funktionieren. Das ist auch Debugging und Testen — es ist wichtig, um Fehler zu finden und hilft Ihnen, mit Ihrem Programm vertrauter zu werden.\n",
"\n",
"([Spoiler Alert](https://xkcd.com/109/), Randall Munroe)\n",
"\n",
".\n",
"\n",
".\n",
"\n",
".\n",
"\n",
"Wenn Sie Ihren Lösungsweg mit einer möglichen Lösung vergleichen wollen können Sie diese hier finden. Allerdings gibt es häufig mehr als einen Lösungsweg, wenn Ihre Lösung anders aussieht ist dies nicht zwingend falsch. Wenn Sie sich unsicher sind, fragen Sie bitte nach:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def right_justify(s):\n",
" # Anzahl Leerzeichen berechnen\n",
" anzahl_leerzeichen = 70 - len(s)\n",
" # Zeichenkette erzeugen\n",
" ergebnis = \" \" * anzahl_leerzeichen + s\n",
" # und ausgeben\n",
" print(ergebnis)"
{
"cell_type": "markdown",
"metadata": {},
"source": [
Miriam Brauer
committed
"#### Aufgabe 1b\n",
"Testen Sie folgendermaßen, ob Sie verstanden haben, wie die Funktion `right_justify` funktioniert: Schreiben Sie eine Funktion `center`, die eine als Argument übergebene Zeichenkette zentriert ausgibt (bei einer angenommen maximalen Spaltenbreite von 70, wie gerade eben):"
]
},
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<details>\n",
" <summary type=\"button\" class=\"btn btn-info\">Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Mit dem Operator `//` können wir zwei ganze Zahlen so teilen, dass eine ganze Zahl (*integer*) herauskommt. Während `7 / 2` die Gleitkommazahl `3.5` ergibt, erhalten wir bei `7 // 2` die ganze Zahl `3` (es wird stets abgerundet).\n",
" \n",
" </div> \n",
"</details> \n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wie auch schon in der vorherigen Aufgabe finden Sie anschließend Hinweise, die einzelne Schritte der Lösung erklären und aufzeigen, versuchen Sie zunächst die Aufgabe ohne Hilfe zu lösen und schauen Sie die Hinweise wenn nötig Schritt für Schritt an."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">1. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Diese Aufgabe ist eine Abwandlung der Aufgabe 1a, überlegen Sie an welcher Stelle die Aufgaben sich unterscheiden.\n",
" \n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">2. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Benötigen Sie insgesamt die selbe Anzahl an Leerzeichen um die Zeichenkette zu zentrieren? Wie viele davon müssen vor der Zeichenkette stehen? Wie können Sie diese Anzahl berechnen?\n",
" \n",
" </div> \n",
"</details> \n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
Miriam Brauer
committed
"source": [
"# Schreiben Sie hier Ihre Funktion"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
Miriam Brauer
committed
"*Hinweis: Mit dem Operator `//` können wir zwei ganze Zahlen so teilen, dass eine ganze Zahl (*integer*) herauskommt. Während `7 / 2` die Gleitkommazahl `3.5` ergibt, erhalten wir bei `7 // 2` die ganze Zahl `3` (es wird stets abgerundet).*\n",
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
"\n",
"Ein Aufruf der Funktion mit den folgenden Argumenten:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"center('Diese Wörter')\n",
"center('stehen')\n",
"center('in')\n",
"center('der Mitte')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"sollte folgendes Ergebnis liefern:\n",
"\n",
"```\n",
" Diese Wörter\n",
" stehen\n",
" in\n",
" der Mitte\n",
"```"
]
},
Miriam Brauer
committed
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"([Spoiler Alert](https://xkcd.com/109/), Randall Munroe)\n",
"\n",
"\n",
"Wenn Sie Ihren Lösungsweg mit einer möglichen Lösung vergleichen wollen, können Sie diese hier finden. Allerdings gibt es häufig mehr als einen Lösungsweg; wenn Ihre Lösung anders aussieht, ist dies nicht zwingend falsch. Wenn Sie sich unsicher sind, fragen Sie bitte nach:"
Miriam Brauer
committed
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def center(s):\n",
" space=(70 - len(s)) // 2\n",
" print(' ' * space + s)\n",
Miriam Brauer
committed
" \n",
"center (\"Das ist der Test\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
Miriam Brauer
committed
"Ein Funktionsobjekt ist ein Wert, den wir einer Variablen zuweisen oder auch einer Funktion als Argument übergeben können. Zum Beispiel ist `do_twice` eine Funktion, die ein Funktionsobjekt als Argument erwartet und die Funktion dann zweimal aufruft:"
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def do_twice(f):\n",
" f()\n",
" f()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Im Folgenden ein Beispiel, in dem die Funktion `do_twice` genutzt wird, um die Funktion `print_spam` zweimal aufzurufen:\n",
"\n",
"```python\n",
"def print_spam():\n",
" print('spam')\n",
"\n",
"do_twice(print_spam)\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<details>\n",
" <summary type=\"button\" class=\"btn btn-info\">Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Mit der Tastenkombination `SHIFT STRG -` können wir einen Block teilen - also `SHIFT` und `STRG` gleichzeitig gedrückt halten und dann die Minustaste drücken. So können Sie Ihren Code direkt hinter jeder der folgenden Teilaufgaben einfügen.\n",
"\n",
" </div> \n",
"</details> "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"1. Geben Sie dieses Beispiel in einen Code-Block ein und testen Sie es.\n",
"2. Ändern Sie `do_twice`, so dass \n",
" - es zwei Argumente erwartet: ein Funktionsobjekt und einen Wert und\n",
" - die übergebene Funktion zweimal aufruft und ihr den Wert als Argument übergibt.\n",
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
" \n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">1. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Wenn die Funktion Argumente erwartet, müssen diese in den Funktionskopf eingefügt werden.\n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">2. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Die Argumente sollten in der Funktionsdefinition Platzhalter und daher Variablen sein.\n",
"\n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">3. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
"\n",
"Verwenden Sie dieselben Platzhaltervariablen im Rumpf der Funktion, um der Funktion zu sagen, was sie mit den Argumenten tun soll.\n",
"\n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">4. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
"\n",
"Haben Sie den Platzhalter für das 'Wertargument' an den Platzhalter der Funktion übergeben?\n",
"\n",
" </div> \n",
"</details>\n",
"\n",
"\n",
"3. Rufen Sie mit der geänderten Funktion `do_twice` die Funktion `print_twice` (die wir weiter vorne definiert hatten) auf und übergeben Sie ein Wort Ihrer Wahl als Argument.\n",
"4. Definieren Sie eine Funktion `do_four`, die ein Funktionsobjekt und einen Wert erwartet und die übergebene Funktion viermal aufruft und ihr dabei den Wert als Parameter übergibt. Die Funktion `do_four` sollte dabei aus nur zwei Zeilen im Rumpf bestehen, nicht aus vier!\n",
"\n",
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">1. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Schreiben Sie den Funktionsaufruf für `do-twice` und übergeben Sie die korrekte Anzahl an Argumenten.\n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">2. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Überlegen Sie wo genau Sie das Wort übergeben müssen, damit `print_twice` es innerhalb der Funktion `do-twice` verwenden kann.\n",
" \n",
" \n",
" </div> \n",
"</details>\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">3. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Schreiben Sie `print_twice` und den Wert mit Kommas getrennt hintereinander in den Funktionsaufruf.\n",
" </div> \n",
"</details>\n",
"\n",
"\n",
"4. Definieren Sie eine Funktion `do_four`, die ein Funktionsobjekt und einen Wert erwartet und die übergebene Funktion viermal aufruft und ihr dabei den Wert als Parameter übergibt. Die Funktion `do_four` sollte dabei aus nur zwei Zeilen im Rumpf bestehen, nicht aus vier! Rufen Sie die Funktion auf und testen Sie diese!\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">1. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Wir überschreiben hier keine der bereits definierten Funktionen und können alle Funktionen, die wir schon verwendet haben, wiederverwenden.\n",
" \n",
" </div> \n",
"</details>\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">2. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Was passiert wenn Sie `do_twice` zweimal hintereinander ausführen? \n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">3. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Wie müssen Sie die Werte übergeben, sodass diese an der korrekten Stelle verwendet werden können? \n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">4. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"`do_four` muss die Werte lediglich direkt an `do_twice` weiterreichen, `do_twice` sollte bereits korrekt mit den Werten umgehen, wenn Sie die Aufgabe schrittweise gelöst haben.\n",
" \n",
" </div> \n",
"</details>"
Miriam Brauer
committed
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Hier finden Sie die Lösung. Versuchen Sie es erst einmal zu zweit und gehen Sie Schritt für Schritt vor!\n",
Miriam Brauer
committed
"\n",
"([Spoiler Alert](https://xkcd.com/109/), Randall Munroe)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def print_spam():\n",
" print('spam')\n",
Miriam Brauer
committed
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
"do_twice(print_spam)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def do_twice(f,wert):\n",
" f(wert)\n",
" f(wert)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"do_twice(print_twice,\"test\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def do_four(f,wert):\n",
" do_twice(f,wert)\n",
" do_twice(f,wert)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Aufgabe 3\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-info\">Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Nutzen Sie nur Anweisungen und Funktionen, die wir bereits kennengelernt haben.\n",
" \n",
" </div> \n",
"</details>\n",
Miriam Brauer
committed
"\n",
Miriam Brauer
committed
"\n",
"Schreiben Sie eine Funktion, die das folgende Gitter \"zeichnet\":\n",
"\n",
"```\n",
"+ - - - - + - - - - +\n",
"| | |\n",
"| | |\n",
"| | |\n",
"| | |\n",
"+ - - - - + - - - - +\n",
"| | |\n",
"| | |\n",
"| | |\n",
"| | |\n",
"+ - - - - + - - - - +\n",
"```\n",
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
"<details>\n",
" <summary type=\"button\" class=\"btn btn-info\">Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Zeichenketten lassen sich durch den Plus-Operator `+` verbinden.\n",
"Außerdem nimmt die `print()`-Funktion auch mehrere Argumente entgegen. Diese müssen durch Kommata getrennt werden:\n",
"`print(\"+\", Variable, \"-\")`.\n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"\n",
"\n",
"------------------------\n",
"\n",
"\n",
"Wenn Sie nicht wissen, wie Sie an die Aufgabe herangehen können, können Sie die folgenden Hinweise nutzen um den Anfang zu finden. Schauen Sie sich dabei immer so wenige Hinweise an, wie möglich.\n",
"\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">1. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Schreiben Sie die verschiedenen Zeilentypen auf, die Sie für das Gitter brauchen.\n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">2. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Überlegen Sie sich, in welchem Muster die verschiedenen Zeilentypen angeordnet sind. \n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">3. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Überlegen Sie sich, in welchem Muster die verschiedenen Zeilentypen angeordnet sind. Haben Sie bereits eine Funktion definiert, mit der Sie dieselbe Zeile mehrfach hintereinander ausgeben lassen können? \n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">4. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
" Wenn Sie eine Funktion definieren, die genau eine der Seiten (`| | |`) ausgibt, können Sie `do_four()` verwenden, um diese viermal hintereinander ausgeben zu lassen. Sie können sich dann noch überlegen, ob Sie die Querbalken manuell in der `grid()` Funktion aufschreiben oder ob Sie diese auch in eine Funktion packen und dann an der entsprechenden Stelle diese Funktion aufrufen. \n",
" </div> \n",
"</details>\n",
"\n",
"\n",
"Beachten Sie bitte, dass es fast immer mehr als einen Weg gibt, die Aufgaben zu lösen. Solange die Ausgabe stimmt, haben Sie wahrscheinlich alles richtig gemacht.\n",
"\n",
"#### Aufgabe 3.2 \n",
"\n",
"Schreiben Sie eine ähnliche Funktion, die ein Gitter mit je 4 Reihen und Zeilen zeichnet.\n",
"\n",
"Bevor Sie anfangen Ihre eigene Lösung zu entwickeln, schauen Sie sich den folgenden Code an und versuchen Sie zu verstehen, was er macht. Führen Sie ihn aus und beschreiben Sie, warum er die Aufgabe nicht löst."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def do_two(f):\n",
" f()\n",
" f()\n",
" \n",
"def setup():\n",
" print(\"+ - + - +\")\n",
" print(\"| | |\")\n",
"\n",
"\n",
"def minigrid():\n",
" do_two(setup)\n",
" print(\"+ - + - +\")\n",
" \n",
"minigrid()\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",
"Hier wird ein Gitter gezeichnet, welches auch aus 4 Kästchen besteht, die aber viel kleiner sind als die Kästchen in Aufgabenteil 1. In dieser Aufgabe wird nicht verlangt, dass die Kästchengröße verändert wird. Es sollen stattdessen insgesamt 16 Kästchen gezeichnet werden, das Muster soll sich also vergrößern, nicht verkleinern. \n",
" </div> \n",
"</details>\n",
"\n",
"\n",
"Wenn Sie verstanden haben, warum die obige Lösung nicht korrekt ist, können Sie versuchen, eine korrekte Lösung zu entwickeln.\n",
"\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">1. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Überlegen Sie zunächst, wie das gewünschte Gitter aussehen soll. Wie unterscheidet es sich von dem ersten Gitter? Erstellen Sie eventuell per Hand eine grobe Skizze, damit Sie sich anschauen können, wo sich das Muster wiederholt. \n",
" \n",
" </div> \n",
"</details>\n",
"\n",
Miriam Brauer
committed
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">2. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Zuerst müssen wir die beiden Zeilentypen korrekt erstellen. Dafür könnten wir schlicht und ergreifend jeweils die Zeile einmal aufschreiben. Dieser Ansatz ist aber sehr fehleranfällig, stattdessen ist es besser, wenn wir mit der Verkettung durch `*` und `+` arbeiten.\n",
" </div> \n",
"</details>\n",
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">3. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Um die Zeile optimiert aufzuschreiben, können Sie eine Variable erstellen und ihr das erste Viertel der Zeile zuweisen. Dann können Sie mit Hilfe von Verkettung dieses Viertel vier mal ausgeben und mit dem Schlusszeichen abschließen.\n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">4. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Überlegen Sie sich, was Sie aus der vorherigen Lösung übernehmen können, um das Gitter darzustellen. Wie müssen Sie die Zeilenwiederholung anpassen, damit das korrekte Ergebnis angezeigt wird?\n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">5. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Sie müssen je 4 mal *den horizontal Balken gefolgt von 4 Seitenwänden* ausgeben lassen und zum Schluss noch einen horizontalen Balken zeichnen.\n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">6. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Auch wenn diese Version funktioniert, ist sie doch nicht sehr effektiv und wir können Sie verbessern. Eine Folge von Anweisungen wird 4 mal ausgeführt. Wenn wir diese Folge in eine eigene Funktion packen, können wir `do_four()` verwenden, um diese Folge viermal auszuführen und unseren Code somit beträchtlich kürzen.\n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wie gehabt, folgt jetzt die Lösung. Lesen Sie erst weiter, wenn Sie die Aufgabe gelöst haben und sich eine Musterlösung anschauen wollen. Nutzen Sie zunächst die Hinweise, die Sie weiter oben im Text finden, um Ihre eigene Lösung zu entwickeln.\n",
Miriam Brauer
committed
"\n",
"\n",
"([Spoiler Alert](https://xkcd.com/109/), Randall Munroe)\n",
"Zuerst ein paar Tipps, um die Aufgabe selber zu lösen. Lesen Sie nicht alle Tipps auf einmal durch:\n",
Miriam Brauer
committed
"\n",
"1. Welche Zeilen müssen wir überhaupt ausgeben? Schreiben Sie die Zeilen einzeln auf.\n",
"2. Wie sieht das Gitter aus? Können Sie es mit einer Reihe von `print`-Statements darstellen?\n",
"3. Welche Zeilen wiederholen sich? Können Sie diese mit Hilfe von Funktionen zusammenfassen?\n",
Miriam Brauer
committed
"\n",
"\n",
"Dies ist nur eine mögliche Lösung, weitere Lösungsmöglichkeiten finden sie [hier](http://greenteapress.com/thinkpython2/code/grid.py)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#Für Aufgabe 3.1 ein 2*2 Grid:\n",
"\n",
"# Wir verwenden vorher definierte Funktionen, um uns Aufwand zu sparen.\n",
"def do_twice(f):\n",
" f()\n",
" f()\n",
"\n",
"def do_four(f):\n",
" do_twice(f)\n",
" do_twice(f)\n",
Miriam Brauer
committed
"\n",
"def print_innerSide(): \n",
" '''Die Funktion definiert eine der mittleren Seiten (| | |) und gibt diese aus.'''\n",
" print(\"|\" + \" \" * 9 + \"|\" + \" \" * 9 + \"|\")\n",
" \n",
"def print_edge(): \n",
" '''Die Funktion definiert die Kanten (+ - - - - + - - - - +) und gibt diese aus.''' \n",
" print (\"+ \" + \"- \" * 4 + \"+ \" + \"- \" * 4 + \"+\") \n",
" \n",
" \n",
Miriam Brauer
committed
"def print_grid():\n",
" '''Wir nutzen die vorher definierten Funktionen, um das Gitter zu definieren und auszugeben.''' \n",
" print_edge()\n",
" do_four(print_innerSide)\n",
" print_edge()\n",
" do_four(print_innerSide)\n",
" print_edge()\n",
Miriam Brauer
committed
" \n",
"print_grid()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#Für Aufgabe 3.2 ein 4*4 Grid:\n",
Miriam Brauer
committed
" \n",
"def print_innerSide_bigGrid():\n",
" '''Ausgabe einer inneren Seite'''\n",
" \n",
" side_part = \"|\" + \" \" * 9\n",
" print(side_part * 4 + \"|\")\n",
Miriam Brauer
committed
"\n",
" \n",
"\n",
"def print_edge_bigGrid():\n",
" '''Ausgabe einer Kante'''\n",
" edge_part = \"+ \" + \"- \" * 4\n",
" print(edge_part * 4 + \"+\")\n",
Miriam Brauer
committed
"\n",
" \n",
"def print_gridRow():\n",
" '''Ausgabe einer Gitterzeile'''\n",
" print_edge_bigGrid()\n",
" do_four(print_innerSide_bigGrid)\n",
"\n",
"def print_row():\n",
" '''Ausgabe des vollständigen Gitters'''\n",
" do_four(repeat)\n",
" print_edge_bigGrid()\n",
" \n",
"fullgrid()\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
Miriam Brauer
committed
" Finden Sie einen Algorithmus zur Lösung des folgenden Problems:\n",
" *Gegeben sei eine positive ganze Zahl `n`. Finden Sie eine Liste\n",
" von positiven ganzen Zahlen, so dass das Produkt der Zahlen am\n",
" größten unter allen positiven ganzen Zahlen ist, deren Summe\n",
" gleich `n` ist.*\n",
"\n",
" Zum Beispiel: \n",
" - Für `n = 4` ist die gesuchte Liste `(2,2)`, denn `2 * 2` ist größer als `1 * 1 * 1 * 1`, `2 * 1 * 1` und `3 * 1`.\n",
" - Für `n = 5` ist die gesuchte Liste `(2,3)`.\n",
"\n",
Miriam Brauer
committed
"Erklären Sie, wie Sie \"einen Fuß in die Tür bekommen\" haben.\n",
"\n",
"Wie lautet die Liste für `n = 2001`?\n",
"\n",
"\n",
"\n",
"Versuchen Sie es zunächst ohne Hilfe. Wie kann Ihnen Python dabei helfen? \n",
"\n",
".\n",
"\n",
".\n",
"\n",
".\n",
"\n",
"\n",
"([Spoiler Alert](https://xkcd.com/109/), Randall Munroe)\n",
"\n",
".\n",
"\n",
".\n",
"\n",
".\n",
"\n",
"Mein \"Fuß in der Tür\" war, dass ich von Hand eine Tabelle mit den Ergebnissen für die ersten `n` Zahlen gebaut habe:\n",
"\n",
"| n | Liste | Produkt |\n",
"|----|-----------|---------|\n",
"| 2 | 1 1 | 1 | \n",
"| 3 | 1 2 | 3 | \n",