Initial push.
This commit is contained in:
@@ -0,0 +1,318 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"# Software Entwicklung \n",
|
||||
"\n",
|
||||
"## Kapitel 2: Kontrollfluss\n",
|
||||
"\n",
|
||||
"Unter dem *Kontrollfluss* eines Programms versteht man die Reihenfolge der Abarbeitung der\n",
|
||||
"Programmbefehle."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"### 2.1 Sequenz \n",
|
||||
"Die einfachste Form eines Kontrollflusses ist die lineare sequenzielle Ausführung der Befehle\n",
|
||||
"in der Reihenfolge, wie sie auch im Programmcode stehen. Dies ist das \"normale\"\n",
|
||||
"Verhalten eines Python-Programms. Ein Zeilenumbruch schließt die Anweisung ab.\n",
|
||||
"\n",
|
||||
"![Sequenz](../img/Sequenz.png \"Sequenz\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"name": "#%%\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "subslide"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"print(\"Anweisung 1\")\n",
|
||||
"print(\"Anweisung 2\")\n",
|
||||
"print(\"Anweisung 3\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"### 2.2 Bedingte Anweisung \n",
|
||||
"Gelegentlich ist es notwendig, die Abarbeitungsreihenfolge zu variieren. Im einfachsten\n",
|
||||
"Fall sind eine oder mehrere Anweisungen nur auszuführen, wenn eine *Bedingung* erfüllt ist.\n",
|
||||
"\n",
|
||||
"![Bedingte Anweisung](../img/Bedingung.png \"Bedingte Anweisung\") "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Eine bedingte Anweisung wird in Python mit dem Schlüsselwort <code>if</code> eingeleitet. Danach folgt ein\n",
|
||||
"Ausdruck, der zu einem booleschen Wert evaluiert. Das kann z.B. ein Vergleich sein\n",
|
||||
"oder auch eine Variable mit einem Boolean-Wert."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"name": "#%%\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "-"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"a = 3\n",
|
||||
"b = 2\n",
|
||||
"c = (a < b)\n",
|
||||
"print(\"Anweisung\", c)\n",
|
||||
"if c:\n",
|
||||
" print(\"Optionale Anweisung\")\n",
|
||||
" print(\"Optionale Anweisung\")\n",
|
||||
"print(\"Anweisung\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Die optionale Anweisung folgt nach einem Doppelpunkt. Soll mehr als eine Anweisung optional ausgeführt werden,\n",
|
||||
"so müssen diese eingrückt ab der nachfolgenden Zeile aufgeführt werden. Leerzeichen haben in Python also eine\n",
|
||||
"Bedeutung!"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"a = 3\n",
|
||||
"b = 2\n",
|
||||
"print(\"Anweisung 1\")\n",
|
||||
"if a <= b:\n",
|
||||
" print(\"Anweisung 2\")\n",
|
||||
" if a == b:\n",
|
||||
" print(\"Anweisung 3\")\n",
|
||||
" print(\"Anweisung 4\")\n",
|
||||
"print(\"Anweisung 5\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"### 2.3 Verzweigung \n",
|
||||
"\n",
|
||||
"Soll nicht nur bei der Erfüllung eine Bedingung optionaler Code ausgeführt werden, sondern auch bei der \n",
|
||||
"Nichterfüllung, so spricht man von einer *Verzweigung*.\n",
|
||||
"\n",
|
||||
"![Verzweigung](../img/Verzweigung.png \"Verzweigung\") "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Die Alternative, die ausgeführt wird, wenn die Bedingung nicht zutrifft, wird mit dem Schlüsselwort \n",
|
||||
"<code>else</code> ergänzt. Auch hier folgt ein Doppelpunkt und die auszuführenden Anweisungen\n",
|
||||
"werden eingerückt."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"name": "#%%\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "-"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"a = 3\n",
|
||||
"b = 5\n",
|
||||
"print(\"Anweisung\")\n",
|
||||
"if a < b:\n",
|
||||
" print(\"Optionale Anweisung 1\")\n",
|
||||
"else:\n",
|
||||
" print(\"Optionale Anweisung 2\")\n",
|
||||
"print(\"Anweisung\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"### 2.4 Mehrfachverzweigung \n",
|
||||
"\n",
|
||||
"Existieren mehr als zwei Alternativen, spricht man von einer *Mehrfachverzweigung*.\n",
|
||||
"\n",
|
||||
"![Mehrfachverzweigung](../img/Mehrfach.png \"Mehrfachverzweigung\") "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Sollen mehrere Bedingungen überprüft werden, so können diese mit einer oder mehreren <code>elif</code>-Blöcken \n",
|
||||
"ergänzt werden. Ein evtl. vorhandener <code>else</code>-Block wird ausgeführt, wenn keine der Alternativen \n",
|
||||
"zum Zug gekommen ist."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"a = 5\n",
|
||||
"b = 2\n",
|
||||
"print(\"Anweisung\")\n",
|
||||
"if a < b:\n",
|
||||
" print(\"Optionale Anweisung 1\")\n",
|
||||
"elif a > b:\n",
|
||||
" print(\"Optionale Anweisung 2\")\n",
|
||||
"else:\n",
|
||||
" print(\"Optionale Anweisung 3\") \n",
|
||||
"print(\"Anweisung\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"### 2.5 If-Ausdruck\n",
|
||||
"\n",
|
||||
"Bei einem *If-Ausdruck* ist das Ergebnis von einer Bedingung abhängig. "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"a = 3\n",
|
||||
"b = 2\n",
|
||||
"\n",
|
||||
"min = a if a < b else b\n",
|
||||
"print(min)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"name": "#%% md\n"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Die Anweisung unmittelbar vor dem <code>if</code> wird nur ausgeführt, wenn die Bedingung erfüllt ist. Die Anweisung \n",
|
||||
"nach dem <code>else</code> wird ausgeführt, falls die Bedingung nicht erfüllt ist. Der <code>else</code>-Zweig\n",
|
||||
"ist bei diesem Konstrukt verpflichtend. Insgesamt entspricht das Ergebnis des Ausdrucks dem Wert der ausgeführten Operation.\n",
|
||||
" "
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"celltoolbar": "Slideshow",
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3 (ipykernel)",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.9.9"
|
||||
},
|
||||
"pycharm": {
|
||||
"stem_cell": {
|
||||
"cell_type": "raw",
|
||||
"metadata": {
|
||||
"collapsed": false
|
||||
},
|
||||
"source": []
|
||||
}
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
}
|
||||
@@ -0,0 +1,152 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"_Aufgabe 1_\n",
|
||||
"\n",
|
||||
"Schreiben Sie ein Python-Programm, das drei Zahlen von der Tastatur einliest und anschließend die\n",
|
||||
"größte von ihnen ausgibt."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "-"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"num1 = float(input(\"Erste Zahl:\"))\n",
|
||||
"num2 = float(input(\"Zweite Zahl:\"))\n",
|
||||
"num3 = float(input(\"Dritte Zahl:\"))\n",
|
||||
"\n",
|
||||
"maximum = num1 if num1 > num2 else num2\n",
|
||||
"maximum = maximum if maximum > num3 else num3\n",
|
||||
"print(maximum) \n",
|
||||
"\n",
|
||||
"\n",
|
||||
"if num1 > num2:\n",
|
||||
" if num1 > num3:\n",
|
||||
" print(num1)\n",
|
||||
" else:\n",
|
||||
" print(num3)\n",
|
||||
"else:\n",
|
||||
" if num2 > num3:\n",
|
||||
" print(num2)\n",
|
||||
" else:\n",
|
||||
" print(num3)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"_Aufgabe 2_\n",
|
||||
"\n",
|
||||
"Schreiben Sie ein Python-Programm, das zwei Zahlen von der Tastatur einliest. Anschließend soll\n",
|
||||
"nachgefragt werden, ob die beiden Zahlen addiert, subtrahiert, mulitpliziert oder dividiert werden sollen. \n",
|
||||
"Führen Sie die gewünschte Operation aus und geben Sie das Ergebnis aus. "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "-"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"name": "#%%\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"num1 = float(input(\"Erste Zahl:\"))\n",
|
||||
"num2 = float(input(\"Zweite Zahl:\"))\n",
|
||||
"\n",
|
||||
"op = input(\"Was soll gemacht werden (+,-,*,/):\")\n",
|
||||
"if op == \"+\":\n",
|
||||
" erg = num1 + num2\n",
|
||||
"elif op == \"-\":\n",
|
||||
" erg = num1 - num2\n",
|
||||
"elif op == \"*\":\n",
|
||||
" erg = num1 * num2\n",
|
||||
"elif op == \"/\":\n",
|
||||
" erg = num1 / num2\n",
|
||||
"else:\n",
|
||||
" erg = None\n",
|
||||
" \n",
|
||||
"print(f\"Unbekannter Operator <{op}>.\") if erg is None else print(f\"{num1} {op} {num2} = {erg}\")"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"celltoolbar": "Slideshow",
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3 (ipykernel)",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.9.9"
|
||||
},
|
||||
"pycharm": {
|
||||
"stem_cell": {
|
||||
"cell_type": "raw",
|
||||
"metadata": {
|
||||
"collapsed": false
|
||||
},
|
||||
"source": []
|
||||
}
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
}
|
||||
@@ -0,0 +1,260 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"name": "#%% md\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"# Software Entwicklung \n",
|
||||
"\n",
|
||||
"## Kapitel 2: Kontrollfluss"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"name": "#%% md\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"### 2.6 Schleife \n",
|
||||
"\n",
|
||||
"Häufig möchte man eine oder mehrere Anweisungen wiederholen, solange eine *Laufbedingung* erfüllt ist.\n",
|
||||
"Ein solcher Kontrollfluss wird auch als *Schleife* bezeichnet. Sofern die Bedingung geprüft wird, bevor\n",
|
||||
"die zu wiederholende Anweisung ausgeführt wird, spricht man von einer *kopfgesteuerten Schleife*.\n",
|
||||
"Wird erst nach der Ausführung überprüft, ob eine Wiederholung stattfinden soll, so handelt es\n",
|
||||
"sich um eine *fußgesteuerte Schleife*.\n",
|
||||
"\n",
|
||||
"![kopfgesteuerte Schleife](../img/SchleifeKopf.png \"Kopfgesteuerte Schleife\") "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"name": "#%% md\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Mit dem Schlüsselwort <code>while</code> wird in Python eine kopfgesteuerte Schleife begonnen. Die Laufbedingung\n",
|
||||
"folgt unmittelbar danach abgeschlossen mit einem Doppelpunkt. Die zu wiederholenden Anweisungen werden\n",
|
||||
"wieder als eingerückter Block angegeben. Diesen Block nennt man auch *Schleifenrumpf*."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"a = 1\n",
|
||||
"\n",
|
||||
"while a < 10:\n",
|
||||
" print(a)\n",
|
||||
" a = a + 1\n",
|
||||
" \n",
|
||||
"print(\"Fertig\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Eine Schleife kann jederzeit abgebrochen werden, wenn im Schleifenrumpf das Schlüsselwort <code>break</code> \n",
|
||||
"auftaucht. Die Schleife wird dann sofort verlassen und die Ausführung mit dem nächsten Befehl nach dem Schleifenrumpf\n",
|
||||
"fortgesetzt. Aufgrund der besseren Lesbarkeit sollte <code>break</code> eher sparsam eingesetzt werden."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"a = 1\n",
|
||||
"\n",
|
||||
"while a < 10:\n",
|
||||
" print(a)\n",
|
||||
" if a == 5:\n",
|
||||
" break\n",
|
||||
" a = a + 1\n",
|
||||
"\n",
|
||||
"print(\"Fertig\", a)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"In Python gibt es zunächst einmal nur kopfgesteuerte Schleifen, jedoch können fußgesteuerte Schleifen\n",
|
||||
"recht einfach nachgebaut werden. Auch hier gilt wieder der Verweis auf eine bessere Lesbarkeit durch einen sparsamen Einsatz von <code>break</code>. Endlosschleifen sollten generell vermieden werden."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"a = 1\n",
|
||||
"\n",
|
||||
"while True:\n",
|
||||
" print(a)\n",
|
||||
" a = a + 1\n",
|
||||
" if a >= 6:\n",
|
||||
" break\n",
|
||||
"\n",
|
||||
"print(\"Fertig\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Neben dem vollständigen Schleifenabbruch mit <code>break</code> kann mittels <code>continue</code> auch nur der \n",
|
||||
"aktuelle Schleifendurchlauf abgebrochen werden. Aufgrund besserer Lesbarkeit sollte man sich aber immer die Frage stellen, ob sich ein <code>continue</code> nicht auch vermeiden lässt, z.B. durch entsprechende bedingte Ausführungen."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"a = 0\n",
|
||||
"\n",
|
||||
"while a < 10:\n",
|
||||
" a = a + 1\n",
|
||||
" if a % 2 != 0:\n",
|
||||
" continue\n",
|
||||
" print(a)\n",
|
||||
"\n",
|
||||
"print(\"Fertig\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Eine eher selten anzutreffende Variante ist die Verwendung eines optionalen <code>else</code> nach einer \n",
|
||||
"<code>while</code>-Schleife. Der <code>else</code>-Zweig wird dann ausgeführt, wenn die Laufbedingung \n",
|
||||
"nicht erfüllt ist *und* die Schleife nicht mit <code>break</code> verlassen wird. "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"a = 5\n",
|
||||
"\n",
|
||||
"while a > 0:\n",
|
||||
" print(a)\n",
|
||||
" if a < -1:\n",
|
||||
" break\n",
|
||||
" a = a - 1\n",
|
||||
"else:\n",
|
||||
" print(\"Else!\")\n",
|
||||
"\n",
|
||||
"print(\"Fertig\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Python bietet zudem eine <code>for</code>-Schleife an, mit der speziell Listen bzw. iterierbare Konstrukte durchlaufen werden können. Wir werden diese im Zusammenhang mit Listen in einem späteren Kapitel genauer betrachten."
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"celltoolbar": "Slideshow",
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3 (ipykernel)",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.9.9"
|
||||
},
|
||||
"pycharm": {
|
||||
"stem_cell": {
|
||||
"cell_type": "raw",
|
||||
"metadata": {
|
||||
"collapsed": false
|
||||
},
|
||||
"source": []
|
||||
}
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
}
|
||||
@@ -0,0 +1,146 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"_Aufgabe 1_\n",
|
||||
"\n",
|
||||
"Schreiben Sie ein Python-Programm, das zunächst eine Zahl von der Tastatur einliest,\n",
|
||||
"anschließend mittels einer <code>while</code>-Schleife die Binärdarstellung\n",
|
||||
"der Zahl ermittelt und diese ausgibt."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "-"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"num = int(input(\"Zahl:\"))\n",
|
||||
"\n",
|
||||
"ergebnis = \"\"\n",
|
||||
"while num > 0:\n",
|
||||
" ergebnis = str(num % 2) + ergebnis\n",
|
||||
" num = num // 2\n",
|
||||
"\n",
|
||||
"print(ergebnis)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"_Aufgabe 2_\n",
|
||||
"\n",
|
||||
"Schreiben Sie ein Python-Programm, das einen String bestehend aus <code>0</code> und <code>1</code> \n",
|
||||
"von der Tastatur einliest, diesen als Binärzahl betrachtet und den dezimalen Wert ausgibt."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "-"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"name": "#%%\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"binaer = input(\"Binärzahl:\")\n",
|
||||
"\n",
|
||||
"# Lösung 1\n",
|
||||
"ergebnis = 0\n",
|
||||
"index = 0\n",
|
||||
"while index < len(binaer):\n",
|
||||
" ergebnis = ergebnis * 2\n",
|
||||
" if binaer[index] == \"1\":\n",
|
||||
" ergebnis = ergebnis + 1\n",
|
||||
" index = index + 1\n",
|
||||
"\n",
|
||||
"# Lösung 2 \n",
|
||||
"index = len(binaer)-1\n",
|
||||
"ergebnis2 = 0\n",
|
||||
"while index >=0:\n",
|
||||
" stellenwert = len(binaer) - 1 - index\n",
|
||||
" ergebnis2 = ergebnis2 + int(binaer[index])* (2 ** stellenwert ) \n",
|
||||
" index = index - 1\n",
|
||||
" \n",
|
||||
"print(ergebnis)\n",
|
||||
"print(ergebnis2)"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"celltoolbar": "Slideshow",
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3 (ipykernel)",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.9.9"
|
||||
},
|
||||
"pycharm": {
|
||||
"stem_cell": {
|
||||
"cell_type": "raw",
|
||||
"metadata": {
|
||||
"collapsed": false
|
||||
},
|
||||
"source": []
|
||||
}
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
}
|
||||
@@ -0,0 +1,195 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"name": "#%% md\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"# Software Entwicklung \n",
|
||||
"\n",
|
||||
"## Kapitel 2: Kontrollfluss\n",
|
||||
"\n",
|
||||
"### 2.7 Algorithmus\n",
|
||||
"\n",
|
||||
"Ein Algorithmus ist\n",
|
||||
"\n",
|
||||
"- eine *endliche Folge* von Regeln (*Finitheit*),\n",
|
||||
"- nach denen sich nach *endlich vielen* (*Terminiertheit*),\n",
|
||||
"- *eindeutig festgelegten* Schritten (*Determiniertheit*)\n",
|
||||
"- die Lösung einer *Klasse von Problemen* ergibt (*Allgemeingültigkeit*)."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"name": "#%% md\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Für die Darstellung eines Algorithmus kann können Visualisierungen verwendet werden. Nachfolgend \n",
|
||||
"ist der Euklid'sche Algorithmus zur Berechnung des größten gemeinsamen Teilers (ggT) zweier Zahlen\n",
|
||||
"als UML Aktivitätsdiagramm dargestellt: \n",
|
||||
"\n",
|
||||
"![Aktivitätsdiagramm GGT](../img/ggtuml.png \"GGT-Berechnung als Aktivitätsdiagramm\") "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"name": "#%% md\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Der gleiche Algorithmus kann aber auch in Form eines Struktogramms visualisiert werden:\n",
|
||||
"\n",
|
||||
"![Aktivitätsdiagramm GGT](../img/ggtstruct.png \"GGT-Berechnung als Aktivitätsdiagramm\") "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Sehr gebräuchlich ist mittlerweile die Verwendung von Pseudocode. Es gibt viele Varianten für Pseudocode. Meist einigt man sich innerhalb einer Organisation auf eine einheitliche Syntax. Zudem gibt es in der Literatur viele Syntax-Vorschläge.\n",
|
||||
"\n",
|
||||
" Eingabe a, b\n",
|
||||
" Falls a=0\n",
|
||||
" Ausgabe a\n",
|
||||
" Sonst\n",
|
||||
" Solange b != 0\n",
|
||||
" Falls a > b\n",
|
||||
" a := a - b\n",
|
||||
" Sonst\n",
|
||||
" b := b - a\n",
|
||||
" Ausgabe a"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"name": "#%% md\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Die Lösungsidee für ein Problem wird also unabhängig von einer Programmiersprache in\n",
|
||||
"Form eines Algorithmus entwickelt. Die anschließende Formulierung eines Algorithmus in einer \n",
|
||||
"Programmiersprache ist dann eine relativ einfache Übertragungsaufgabe."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"name": "#%%\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "-"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"a = int(input(\"a eingeben:\"))\n",
|
||||
"b = int(input(\"b eingeben:\"))\n",
|
||||
"\n",
|
||||
"if a==0:\n",
|
||||
" print(b)\n",
|
||||
"else:\n",
|
||||
" while b>0:\n",
|
||||
" if a>b:\n",
|
||||
" a=a-b\n",
|
||||
" else:\n",
|
||||
" b=b-a\n",
|
||||
" print(a)\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"name": "#%% md\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"### 2.8 Berechenbarkeit\n",
|
||||
"\n",
|
||||
"In der *theoretischen Informatik* wurden verschiedene \n",
|
||||
"Modelle für die Beschreibung von Rechenmaschinen entwickelt. Es wurde bewiesen,\n",
|
||||
"dass viele Modelle gleichwertig zur \n",
|
||||
"sog. __[Turing-Maschine](https://de.wikipedia.org/wiki/Turingmaschine)__ sind, \n",
|
||||
"d.h. mit diesen Modellen die gleichen Berechnungen ausgeführt werden können bzw. es keine \n",
|
||||
"Berechnungsvorschrift gibt, die nur mit einem Modell, nicht aber mit dem anderen ausführbar ist.\n",
|
||||
"\n",
|
||||
"Zudem geht man davon aus, dass alle relevanten Algorithmen zur Klasse der von Turing-Maschinen berechenbaren \n",
|
||||
"Algorithmen gehören (__[Churchsche These](https://de.wikipedia.org/wiki/Church-Turing-These)__).\n",
|
||||
"\n",
|
||||
"Mit den Bausteinen *Sequenz*, *Bedingte Anweisung* und *Schleife* sowie *Variablenzuweisung* liefert Python ein Modell, \n",
|
||||
"von dem bewiesen wurde, dass es äquivalent zur Turing-Maschine ist. Oder anders ausgedrückt: alle weiteren \n",
|
||||
"Sprachelemente dienen lediglich der besseren Verständlichkeit und leichteren Wartbarkeit von Python-Code,\n",
|
||||
"erweitern aber nicht die Möglichkeiten der Berechenbarkeit.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"celltoolbar": "Slideshow",
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3 (ipykernel)",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.9.9"
|
||||
},
|
||||
"pycharm": {
|
||||
"stem_cell": {
|
||||
"cell_type": "raw",
|
||||
"metadata": {
|
||||
"collapsed": false
|
||||
},
|
||||
"source": []
|
||||
}
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
body.rise-enabled div.inner_cell>div.input_area {
|
||||
font-size: 150%;
|
||||
}
|
||||
|
||||
body.rise-enabled div.output_subarea.output_text.output_result {
|
||||
font-size: 150%;
|
||||
}
|
||||
body.rise-enabled div.output_subarea.output_text.output_stream.output_stdout {
|
||||
font-size: 150%;
|
||||
}
|
||||
|
||||
body.rise-enabled div.output_subarea.output_html.rendered_html.output_result {
|
||||
font-size: 150%;
|
||||
}
|
||||
|
||||
body.rise-enabled td {
|
||||
font-size: 120%;
|
||||
}
|
||||
|
||||
body.rise-enabled th {
|
||||
font-size: 120%;
|
||||
}
|
||||
Reference in New Issue
Block a user