Schlüsselqualifikation Einführunng in Python
Christoph Giess
commit
2770563f1f
|
|
@ -0,0 +1,50 @@
|
|||
# --> Temporary files
|
||||
privat
|
||||
temp
|
||||
*.swp
|
||||
*~
|
||||
|
||||
# ---> Latex
|
||||
*.aux
|
||||
*.log
|
||||
*.nav
|
||||
*.out
|
||||
*.snm
|
||||
*.toc
|
||||
*.vrb
|
||||
*.synctex.gz
|
||||
|
||||
# ---> Mercurial
|
||||
.hg/
|
||||
.hgignore
|
||||
.hgsigs
|
||||
.hgsub
|
||||
.hgsubstate
|
||||
.hgtags
|
||||
|
||||
# ---> Dart
|
||||
# Don’t commit the following directories created by pub.
|
||||
.buildlog
|
||||
.pub/
|
||||
.dart_tool/
|
||||
build/
|
||||
packages
|
||||
.packages
|
||||
|
||||
# Or the files created by dart2js.
|
||||
*.dart.js
|
||||
*.js_
|
||||
*.js.deps
|
||||
*.js.map
|
||||
|
||||
# Include when developing application packages.
|
||||
pubspec.lock
|
||||
|
||||
# Mac file
|
||||
.DS_Store
|
||||
|
||||
# IntelliJ related
|
||||
*.iml
|
||||
*.ipr
|
||||
*.iws
|
||||
.idea/
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
= Notizen
|
||||
|
||||
== TODOs für Vorlesung
|
||||
* Visualisierung von
|
||||
** Funktionsaufrufen
|
||||
** Arrays
|
||||
* Besser erklären
|
||||
** Dokumentation lesen
|
||||
** Funktionsaufruf
|
||||
** Googeln
|
||||
|
||||
Das war wirklich Neuland für die, dass alles irgendwo mit einem Beispiel erklärt ist. Funktionen aufzurufen war für sie totale Verwirrung und Magie. Die Logik dahinter zu erklären und wie der Computer das Programm "liest" war echt 20x nötig.
|
||||
|
||||
|
||||
== Infos von Oliver
|
||||
|
||||
- link:https://www.youtube.com/watch?v=_DUuzZd0iVA[Jupiter Installation]
|
||||
- link:https://www.youtube.com/watch?v=1S4Cgtkxqhs[Grundlagen zu Notebooks]
|
||||
|
||||
|
||||
== Bücher zu Jupyter
|
||||
|
||||
* für Kurs nur bedingt hilfreich
|
||||
|
||||
|
||||
=== Jupyter Cookbook - Over 75 Recipes ... (Packt)
|
||||
|
||||
NOTE: von 2018, default Python 2
|
||||
|
||||
* Installation verschiedener Kernel
|
||||
* Beispiele verwenden Python, R, JS, Julia -> nicht alles brauchbar
|
||||
* Notebooks mit Widgets interaktiv machen
|
||||
* Security - jeder Jupyter-Kernel kann beliebigen Code ausführen
|
||||
* JupyterLab = Next Generation Jupyter - neue Features ausprobieren
|
||||
|
||||
|
||||
=== Thoughtful Data Science (Packt)
|
||||
|
||||
NOTE: von 2018
|
||||
|
||||
* eigentlich Werbung/Beschreibung für link:https://github.com/pixiedust/pixiedust[PixieDust]
|
||||
* evtl einfacher als Pandas/MathPlotLib/... aber wieder etwas ungewartetes.
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
= Digital Basics: Einführung in die Programmierung mit Python
|
||||
|
||||
== Ziele
|
||||
|
||||
Wir werden gemeinsam
|
||||
|
||||
* eurer erstes Computerprogramm schreiben
|
||||
* die Grundlagen der Programmiersprache Python erlernen
|
||||
* erarbeiten, wie man dem Computer sagt, was er tun soll
|
||||
* die Basis zur Lösung komplexere Programmieraufgaben schaffen
|
||||
* einige Denkweisen von Informatikern kennen lerenen
|
||||
|
||||
== Zielgruppe
|
||||
|
||||
Das Seminar richtet sich an
|
||||
|
||||
* komplette Anfänger ohne irgendwelche Erfahrungen im Programmieren
|
||||
* Studierende aller Fachrichtungen und aus allen Semestern,
|
||||
* Absolventen und Doktoranden aller Fachrichtungen,
|
||||
die ohne jegliche Voraussetzungen ihre ersten Computerprogramme schreiben möchten.
|
||||
|
||||
== Inhalte
|
||||
|
||||
* Wie rede ich mit dem Rechner
|
||||
* Erste Schritte mit Python
|
||||
* Datentypen und ihre Operationen
|
||||
* Funktionen und Module
|
||||
* Programme aus Funktionen zusammenbauen
|
||||
|
||||
== Methoden
|
||||
|
||||
* Vortrag
|
||||
* Übungen
|
||||
* individuelles Feedback / Support
|
||||
* Vorstellung der Ergebnisse in der Gruppe
|
||||
* Diskussion
|
||||
|
||||
|
||||
*Seminardauer:* 5 UE
|
||||
|
||||
*Teilnehmerzahl:* 6-20
|
||||
|
||||
*Referent:* Christoph Giess, MARS
|
||||
|
|
@ -0,0 +1,275 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "1a44722c-9586-4418-ad7f-8a3c964a9db8",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Taschenrechner\n",
|
||||
"Wir fangen ganz einfach an und schauen, wie sich Python als Taschenrechner macht:"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 1,
|
||||
"id": "1e6aecc1-1fbc-4cd9-9330-1a66fa612ec6",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"3"
|
||||
]
|
||||
},
|
||||
"execution_count": 1,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"1 + 2"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 2,
|
||||
"id": "f19f790e-bac5-4e31-a205-d2008bfc6e22",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"24"
|
||||
]
|
||||
},
|
||||
"execution_count": 2,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"2 * 3 * 4"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"id": "82d3380b-1d01-4475-8222-2198d8d4856a",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"43"
|
||||
]
|
||||
},
|
||||
"execution_count": 3,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"1 + 3 * 14"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 4,
|
||||
"id": "62b5e2b5-2bb5-42c3-b80e-8f43347faf5f",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"56"
|
||||
]
|
||||
},
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"(1+3) * 14"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "98a86261-0a33-4570-9064-ad57765e8aa0",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Aufgabe\n",
|
||||
"❓ Jetzt seid ihr dran! Denkt an den Mathe-Unterricht zurück und versucht\n",
|
||||
"* Minus\n",
|
||||
"* Division\n",
|
||||
"* Potenzieren\n",
|
||||
"* Quadratwurzel"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "e2b5f4f4-a5da-4b70-9e11-1a13c8b1c111",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Lösung"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 5,
|
||||
"id": "6d6e56ec-fded-4a99-8941-e88c323eb561",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"3"
|
||||
]
|
||||
},
|
||||
"execution_count": 5,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"5 - 2"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 6,
|
||||
"id": "a151e074-017d-4be4-be9e-0181dca4cd9e",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"2.5"
|
||||
]
|
||||
},
|
||||
"execution_count": 6,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"5 / 2"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "e2ba9ae6-a19e-449a-a1d3-06be54dff4b3",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Kommazahlen gibt's auch. Diese müssen, wie im Englischen üblich, mit Punkt statt mit Komma angegeben werden."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 7,
|
||||
"id": "b26ab8eb-cbf6-486e-a0a2-dfa086125742",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"64"
|
||||
]
|
||||
},
|
||||
"execution_count": 7,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"2 ** 6"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "5e7be5dd-bbcf-4f68-9cfb-662ac00f86c9",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Potenzieren war schon tricky. Die ** kann man sich aber einfach merken wenn man daran denkt das Potenzieren mehrfaches Multiplizieren ist.\n",
|
||||
"\n",
|
||||
"Für die Quadratwurzel müssen wir aber noch ein bisschen über Python lernen."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "cec7a8a1-ce22-41a0-b0e2-b6107e9b9bc3",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Packages\n",
|
||||
"\n",
|
||||
"Der Kern der Programmiersprache Python kann relativ wenig. Die meiste Funktionalität liegt in Packages.\n",
|
||||
"\n",
|
||||
"So ein Package muss mittels `import` verfügbar gemacht werden bevor man dessen Funktionen nutzen kann."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 8,
|
||||
"id": "c04b1fca-a1f5-4ba2-90a8-216c3cc41556",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"2.0"
|
||||
]
|
||||
},
|
||||
"execution_count": 8,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"import math\n",
|
||||
"math.sqrt(4)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "dd7f5220-4b6d-4e76-8cdf-ed04b9d8e8d6",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Aufgabe\n",
|
||||
"❓ Das Package `math` enhält noch eine Reihe weiterer\n",
|
||||
"Funktionen, die aus dem Mathe-Unterricht bekannt sind. Welche sind das?"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "9b1cbddd-4599-4dbd-b439-5276c78e0ccd",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Lösung\n",
|
||||
"Durch ausprobieren kann man `sin`, `cos` und `tan` finden.\n",
|
||||
"\n",
|
||||
"Das ist aber aufwändig. Einfacher geht's mit der Hilfe-Funktion."
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"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.7"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 5
|
||||
}
|
||||
|
|
@ -0,0 +1,186 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 5,
|
||||
"id": "2a1f4fb4-1e20-4441-90f2-98ce7606e088",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "skip"
|
||||
},
|
||||
"tags": [
|
||||
"hide-input"
|
||||
]
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import math"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "c4e44c9e-0eea-48d3-b478-8723995efe97",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Hilfe\n",
|
||||
"\n",
|
||||
"Hilfe kann man sich für Packages oder Funktionen anzeigen lassen:\n",
|
||||
"\n",
|
||||
"`help(math)`\n",
|
||||
"\n",
|
||||
"`help(math.sin)`"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 6,
|
||||
"id": "18821bb6-e5a7-4367-ac55-60c468d78a02",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Help on built-in function sin in module math:\n",
|
||||
"\n",
|
||||
"sin(x, /)\n",
|
||||
" Return the sine of x (measured in radians).\n",
|
||||
"\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"help(math.sin)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "bf381088-a36b-400d-8a8e-9491c85ee637",
|
||||
"metadata": {
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"Das **/** ist kein Parameter sondern eine Info für fortgeschrittene Programmierer ([Details](https://www.python.org/dev/peps/pep-0570/positional-only%20parameters)). Wir ignorieren dies.\n",
|
||||
"\n",
|
||||
"ℹ️ `<TAB>` zeigt verfügbare Funktionen an. Probiert:\n",
|
||||
"\n",
|
||||
"`math.<TAB>`\n",
|
||||
"\n",
|
||||
"`math.c<TAB>`"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "2d4ee0f4-7d02-4935-bfd9-9c04efb7de4d",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Aufgabe\n",
|
||||
"\n",
|
||||
"❓ Berechne sin und cos von 0°, 90° und 180°!"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "d89f4342-623b-4b6e-be90-e6774c62a65f",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Lösung\n",
|
||||
"\n",
|
||||
"War das Ergebnis richtig?\n",
|
||||
"\n",
|
||||
"Die Hilfe sagt, dass man den Parameter von `sin`/`cos` in Radians (Bogenmaß) angeben muss. Gegeben waren aber Grad. D.h. wir müssen dies erst umrechnen. Dazu gibt es auch eine Funktion `math.radians()`. Somit wäre die Lösung:"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 9,
|
||||
"id": "0e612c09-f8b5-4dc2-80c7-49f03e510937",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"1.0"
|
||||
]
|
||||
},
|
||||
"execution_count": 9,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"math.sin(math.radians(90))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "89d942ed-7aac-48d7-ba5e-2d1c0e09a2d3",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"ℹ️ Funktionen sind schachtelbar\n",
|
||||
"\n",
|
||||
"ℹ️ Ein Programm besteht aus ineinander geschachtelten Funktionsaufrufen."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 10,
|
||||
"id": "3197696b-bf76-46b7-99db-67ad482516ca",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"1.2246467991473532e-16"
|
||||
]
|
||||
},
|
||||
"execution_count": 10,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"math.sin(math.radians(180))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "c5b2d7d1-d7e4-4372-933c-19063452d1dd",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Mmh, das sollte 0 sein.\n",
|
||||
"\n",
|
||||
"ℹ️ Beim Rechnen mit Kommazahlen ist die Genauigkeit begrenzt."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "0923f3a5-8e2e-4044-a316-598da598f3db",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"❓ Was wäre, wenn es `math.radians()` nicht geben würde?"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"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.7"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 5
|
||||
}
|
||||
|
|
@ -0,0 +1,250 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "5e2e3e9d-9d88-43b8-a7b6-351a8dd8eb9d",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Funktionen\n",
|
||||
"Wenn es `math.radians()` nicht gäbe, dann könnten wir die uns selbst schreiben:"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"id": "5e0982b9-eb6d-4db7-ba96-cceac29821ae",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import math\n",
|
||||
"def rad(x):\n",
|
||||
" return x * 2 * math.pi / 360"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "38cc7e3f-8186-4ed8-81ae-d199c3cb9d5e",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Zur Unterscheidung heißt sie einfach nur `rad()`.\n",
|
||||
"Das Package `math` muss importiert sein um `pi` zu verwenden."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 5,
|
||||
"id": "333d5172-b326-460e-9851-6e5271bcab79",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"3.141592653589793"
|
||||
]
|
||||
},
|
||||
"execution_count": 5,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"rad(180)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "1b67ecf5-cf68-4c29-ae90-39d2a0f6ce00",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Aufgabe\n",
|
||||
"❓ Das sieht schon toll aus. Geht das aber auch besser?"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "b792d4e1-41ce-4622-8298-077355437419",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Lösung\n",
|
||||
"Beim Programmieren ist es oft nicht leicht zu entscheiden was **besser** ist.\n",
|
||||
"\n",
|
||||
"Man könnnte `x * math.pi / 180` schreiben. Das spart evtl. die Berechnung von `2 / 360`.\n",
|
||||
"Warum `evtl`? Weil manche Programmiersprachen dies selbständig optimieren.\n",
|
||||
"Warum ist das kürzere nicht besser? Die Formel, die man in der Schule gelernt hat ist so nicht direkt wiederzuerkennen und somit das Programm schwerer zu verstehen.\n",
|
||||
"\n",
|
||||
"Wichtig ist aber immer eine gute Dokumentation von Funktionen."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 7,
|
||||
"id": "2ec6f0f0-4109-4aef-92dd-d247c43cc4b3",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Help on function rad in module __main__:\n",
|
||||
"\n",
|
||||
"rad(x)\n",
|
||||
"\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"help(rad)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "537bad50-0e57-463c-9d70-b6c0b60de395",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Mmh, das sieht nicht so toll aus.\n",
|
||||
"\n",
|
||||
"Es braucht einen [Docstring](https://www.python.org/dev/peps/pep-0257/),\n",
|
||||
"um hier etwas vernünftiges angezeigt zu bekommen."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "b5f77780-5a55-4471-9bed-7295e95f34a3",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Aufgabe\n",
|
||||
"Schreibt die Funktion `rad()` so um, dass `help(rad)` einen hilfreichen Text anzeigt."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "4c1d9d64-00bf-4418-8416-5fd7c3eba36c",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Lösung\n",
|
||||
"Wir verwenden einfach den Hilfetext von `math.rad`."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 12,
|
||||
"id": "ab898f30-4161-49c8-b8be-e9631349bb2a",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def rad(x):\n",
|
||||
" \"\"\"Convert angle x from degrees to radians.\"\"\"\n",
|
||||
" return x * 2 * math.pi / 360"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "de201d97-2f1d-4798-9732-77c40ba99b78",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Aufgabe\n",
|
||||
"Schreibt eine Funktion, die die Seitenlänge eines rechtwinkligen Dreiecks anhand des Satzes von Pythagoras berechnet. Zur Erinnerung, der lautet a² + b² = c².\n",
|
||||
"\n",
|
||||
"Überlegt:\n",
|
||||
"* Was sind die Parameter?\n",
|
||||
"* Was soll das Ergebnis sein?\n",
|
||||
"* Wie kann man das Berechnen?\n",
|
||||
"* Wie soll die Funktion heißen?\n",
|
||||
"* Was soll die Hilfe zeigen"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 14,
|
||||
"id": "1f69e422-69dc-4563-8ca3-2e8a15a8ee74",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def pyth(a, b):\n",
|
||||
" \"\"\"Berechnet Hypothenuse eines rechtwinkligen Dreiecks mit Seitenlängen a und b\"\"\"\n",
|
||||
" return math.sqrt(a*a + b*b)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 15,
|
||||
"id": "8cb40698-547a-4abd-a076-a14e05584a2c",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"5.0"
|
||||
]
|
||||
},
|
||||
"execution_count": 15,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"pyth(3, 4)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "26f52ec4-a4aa-4b96-a247-2c0816e10a39",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Aufgabe\n",
|
||||
"❓ Schreibt eine Funktion, die die kleinere von zwei Zahlen zurück gibt."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "c724390e-e029-4bd3-be92-3e0a1ffac267",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Lösungen\n",
|
||||
"**Lösung 1**\n",
|
||||
"\n",
|
||||
"Das ist unnötig. Die Funktion gibt es schon. Sie heißt `min()`\n",
|
||||
"\n",
|
||||
"**Lösug 2**\n",
|
||||
"\n",
|
||||
"Das ist zwar unnötig, aber wenn es denn sein muss:\n",
|
||||
"\n",
|
||||
" def my_min(a, b):\n",
|
||||
" return min(a, b)\n",
|
||||
"\n",
|
||||
"**Lösung 3**\n",
|
||||
"\n",
|
||||
"Wie man das selbst implementiert lernen wir erst im nächsten Kapitel."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "892db341-2524-4f29-918c-9dd035b07982",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"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.7"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 5
|
||||
}
|
||||
|
|
@ -0,0 +1,242 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "5e2e3e9d-9d88-43b8-a7b6-351a8dd8eb9d",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Funktionen\n",
|
||||
"Wenn es `math.radians()` nicht gäbe, dann könnten wir die uns selbst schreiben:"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"id": "5e0982b9-eb6d-4db7-ba96-cceac29821ae",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import math\n",
|
||||
"def rad(x):\n",
|
||||
" return x * 2 * math.pi / 360"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "38cc7e3f-8186-4ed8-81ae-d199c3cb9d5e",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Zur Unterscheidung heißt sie einfach nur `rad()`.\n",
|
||||
"Das Package `math` muss importiert sein um `pi` zu verwenden."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 5,
|
||||
"id": "333d5172-b326-460e-9851-6e5271bcab79",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"3.141592653589793"
|
||||
]
|
||||
},
|
||||
"execution_count": 5,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"rad(180)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "1b67ecf5-cf68-4c29-ae90-39d2a0f6ce00",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Aufgabe\n",
|
||||
"❓ Das sieht schon toll aus. Geht das aber auch besser?"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "b792d4e1-41ce-4622-8298-077355437419",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Lösung\n",
|
||||
"Beim Programmieren ist es oft nicht leicht zu entscheiden was **besser** ist.\n",
|
||||
"\n",
|
||||
"Man könnnte `x * math.pi / 180` schreiben. Das spart evtl. die Berechnung von `2 / 360`.\n",
|
||||
"Warum `evtl`? Weil manche Programmiersprachen dies selbständig optimieren.\n",
|
||||
"Warum ist das kürzere nicht besser? Die Formel, die man in der Schule gelernt hat ist so nicht direkt wiederzuerkennen und somit das Programm schwerer zu verstehen.\n",
|
||||
"\n",
|
||||
"Wichtig ist aber immer eine gute Dokumentation von Funktionen."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 7,
|
||||
"id": "2ec6f0f0-4109-4aef-92dd-d247c43cc4b3",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Help on function rad in module __main__:\n",
|
||||
"\n",
|
||||
"rad(x)\n",
|
||||
"\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"help(rad)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "537bad50-0e57-463c-9d70-b6c0b60de395",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Mmh, das sieht nicht so toll aus.\n",
|
||||
"\n",
|
||||
"Es braucht einen [Docstring](https://www.python.org/dev/peps/pep-0257/),\n",
|
||||
"um hier etwas vernünftiges angezeigt zu bekommen."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "b5f77780-5a55-4471-9bed-7295e95f34a3",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Aufgabe\n",
|
||||
"Schreibt die Funktion `rad()` so um, dass `help(rad)` einen hilfreichen Text anzeigt."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "4c1d9d64-00bf-4418-8416-5fd7c3eba36c",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Lösung\n",
|
||||
"Wir verwenden einfach den Hilfetext von `math.rad`."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 12,
|
||||
"id": "ab898f30-4161-49c8-b8be-e9631349bb2a",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def rad(x):\n",
|
||||
" \"\"\"Convert angle x from degrees to radians.\"\"\"\n",
|
||||
" return x * 2 * math.pi / 360"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "de201d97-2f1d-4798-9732-77c40ba99b78",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Aufgabe\n",
|
||||
"Schreibt eine Funktion, die die Seitenlänge eines rechtwinkligen Dreiecks anhand des Satzes von Pythagoras berechnet. Zur Erinnerung, der lautet a² + b² = c².\n",
|
||||
"\n",
|
||||
"Überlegt:\n",
|
||||
"* Was sind die Parameter?\n",
|
||||
"* Was soll das Ergebnis sein?\n",
|
||||
"* Wie kann man das Berechnen?\n",
|
||||
"* Wie soll die Funktion heißen?\n",
|
||||
"* Was soll die Hilfe zeigen"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 14,
|
||||
"id": "1f69e422-69dc-4563-8ca3-2e8a15a8ee74",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def pyth(a, b):\n",
|
||||
" \"\"\"Berechnet Hypothenuse eines rechtwinkligen Dreiecks mit Seitenlängen a und b\"\"\"\n",
|
||||
" return math.sqrt(a*a + b*b)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 15,
|
||||
"id": "8cb40698-547a-4abd-a076-a14e05584a2c",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"5.0"
|
||||
]
|
||||
},
|
||||
"execution_count": 15,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"pyth(3, 4)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "26f52ec4-a4aa-4b96-a247-2c0816e10a39",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Aufgabe\n",
|
||||
"❓ Schreibt eine Funktion, die die kleinere von zwei Zahlen zurück gibt."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "c724390e-e029-4bd3-be92-3e0a1ffac267",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Lösungen\n",
|
||||
"**Lösung 1**\n",
|
||||
"\n",
|
||||
"Das ist unnötig. Die Funktion gibt es schon. Sie heißt `min()`\n",
|
||||
"\n",
|
||||
"**Lösug 2**\n",
|
||||
"\n",
|
||||
"Das ist zwar unnötig, aber wenn es denn sein muss:\n",
|
||||
"\n",
|
||||
" def my_min(a, b):\n",
|
||||
" return min(a, b)\n",
|
||||
"\n",
|
||||
"**Lösung 3**\n",
|
||||
"\n",
|
||||
"Wie man das selbst implementiert lernen wir erst im nächsten Kapitel."
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"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.7"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 5
|
||||
}
|
||||
|
|
@ -0,0 +1,195 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "c17b2056-f461-4edd-bcbc-c53a1e8aafe4",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Bedinungen & Variablen\n",
|
||||
"## Bedingungen\n",
|
||||
"\n",
|
||||
"Achtet auf Doppelpunkte und Einrückung!"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 1,
|
||||
"id": "ac3cb812-7fb5-40ed-9328-864d9dd7a1b8",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def my_min(a, b):\n",
|
||||
" if a < b:\n",
|
||||
" return a\n",
|
||||
" else:\n",
|
||||
" return b"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 2,
|
||||
"id": "be0a975d-2fb9-4be2-ad94-46de2819c72f",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"-5"
|
||||
]
|
||||
},
|
||||
"execution_count": 2,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"my_min(-2, -5)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "e1f7fc12-e2e3-4c7e-a949-61d3ca9360dc",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Kommentare\n",
|
||||
"\n",
|
||||
"Programme können durch Kommentare leichter verstanden werden.\n",
|
||||
"\n",
|
||||
" \"\"\" Das ist ein\n",
|
||||
" mehrzeiliger\n",
|
||||
" Kommentar \"\"\"\n",
|
||||
" \n",
|
||||
" sin(0) # Kommentar bis Ende der Zeile\n",
|
||||
" \n",
|
||||
"ℹ️ Vernünftige Funktionsnamen sind aber noch wichtiger!"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "d77d67a3-6161-46bf-bb3f-754391b729c8",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Variablen\n",
|
||||
"\n",
|
||||
"In Funktionen habt ihr schon Variablen verwendet.\n",
|
||||
"Diese lassen sich aber auch direkt zuweisen:"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"id": "4055653c-cbec-464b-aeac-a8d140fdb815",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"35"
|
||||
]
|
||||
},
|
||||
"execution_count": 3,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"a = 7\n",
|
||||
"b = 5\n",
|
||||
"c = a * b\n",
|
||||
"# welchen Wert hat c?\n",
|
||||
"c"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 4,
|
||||
"id": "f07ba1f6-9a39-43e4-813e-c3901b1ae350",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"35"
|
||||
]
|
||||
},
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"b = 8\n",
|
||||
"# welchen Wert hat c jetzt?\n",
|
||||
"c"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 5,
|
||||
"id": "ce519d1a-05d9-4307-a2c0-b6dad33d6053",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"56"
|
||||
]
|
||||
},
|
||||
"execution_count": 5,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# c ist immer noch 35 weil es noch nicht neu berechnet wurde\n",
|
||||
"c = a * b\n",
|
||||
"# jetzt sollte es 56 sein\n",
|
||||
"c"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "e9505ef6-2904-475b-837b-bba119c16b7a",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"ℹ️ Warum muss `c` eingegeben werden um das Ergebnis zu sehen?\n",
|
||||
"\n",
|
||||
"Ein Ergebnis wird nur angezeigt, wenn der Aufruf irgendetwas zurück gibt:\n",
|
||||
" \n",
|
||||
"* Berechnung wie 1 + 2 -> Ergebnis\n",
|
||||
"* Funktionaufruf -> das return-te\n",
|
||||
"* Zuweisung a = b -> nix\n",
|
||||
"* Variablenname -> Wert der Variable"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "65aea755-4369-4985-8dfd-c239a015dd03",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"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.7"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 5
|
||||
}
|
||||
|
|
@ -0,0 +1,279 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "df41324e-da47-4d61-a80d-a7bd29198c8d",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Texte\n",
|
||||
"\n",
|
||||
"Bisher haben wir nur mit Zahlen gearbeitet, d.h. Python als besseren Taschenrechner verwendet.\n",
|
||||
"Jetzt wollen wir auch Texte verwenden.\n",
|
||||
"\n",
|
||||
"Text wird auch Zeichenkette oder String genannt.\n",
|
||||
"\n",
|
||||
"Texte haben wir auch schon gesehen, z.B.:\n",
|
||||
"\n",
|
||||
"* Variablennamen `a`, `b`, `c`\n",
|
||||
"* Funktionsnamen wie `my_min` und `cos`\n",
|
||||
"\n",
|
||||
"Um Texte, mit denen wir rechnen wollen, von Variablen und Funktionen zu unterscheiden, müssen wir diese in \" oder ' einschließen."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 6,
|
||||
"id": "7ae417ae-c8d5-4f0e-a280-16265f3fa2d3",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"a = 'Wort'\n",
|
||||
"b = \"Zwei Worte\"\n",
|
||||
"c = \"\"\"Ein mehrzeiliger Text\n",
|
||||
"muss in\n",
|
||||
"drei Hochkommatas\n",
|
||||
"eingeschlossen werden.\"\"\""
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 2,
|
||||
"id": "8af71ec8-1c40-4106-bbd4-3b0bdd2968f7",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"'Wort'"
|
||||
]
|
||||
},
|
||||
"execution_count": 2,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"a"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"id": "14c7d057-124d-4e3b-b6be-a966687930e1",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"'Ein mehrzeiliger Text\\nmuss in\\ndrei Hochkommatas\\neingeschlossen werden.'"
|
||||
]
|
||||
},
|
||||
"execution_count": 3,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"c"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "2e280d2d-eda2-473d-8997-94de82444f48",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"ℹ️ mit \\ lassen sich Sonderzeichen darstellen\n",
|
||||
"\n",
|
||||
"* \\\\ = \\\n",
|
||||
"* \\n = Zeilenumbruch\n",
|
||||
"* \\t = Tabulator"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "41dc4823-c5f0-4ffb-a6c6-c091789cf309",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Aufgabe\n",
|
||||
"❓ Was kann man alles mit Texten machen?\n",
|
||||
"\n",
|
||||
"Tipp:\n",
|
||||
"* `c.<TAB>`\n",
|
||||
"* `help(str)`"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "a376173a-66db-485f-acfe-818c44ad7320",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Lösung\n",
|
||||
"Die Aufgabe war so einfach, die braucht keine Lösung."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "d6a2bb1b-120c-48bf-aed5-ec11fe83f50a",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Aufgabe\n",
|
||||
"❓ Schreibt eine Funktion, die als Parameter ein englisches Wort akzeptiert und dessen Pluralform zurückliefert."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "59669fc1-2dc6-43a6-a297-3304f190d8ea",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Lösung\n",
|
||||
"Wir ignorieren die Sonderfälle und beschränken uns darauf, dBuchstaben **s** anzufügen wenn das Wort nicht damit endet."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 4,
|
||||
"id": "45aa62f3-1257-4499-b2fb-b818cc1dbd21",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def plural(s):\n",
|
||||
" if s.endswith('s'):\n",
|
||||
" return s\n",
|
||||
" else:\n",
|
||||
" return s + 's'"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 5,
|
||||
"id": "ddfbc878-4c16-48a8-852c-97379f447ab9",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"'horses'"
|
||||
]
|
||||
},
|
||||
"execution_count": 5,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"plural(\"horse\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "0e1833b4-aa3b-41b4-9602-0e36103e0070",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Rechnen mit Texten\n",
|
||||
"Texte kann man addieren und multiplizieren:"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 7,
|
||||
"id": "17a904df-8ffc-467a-8744-e2a4fd8b2134",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"'Hallo Python'"
|
||||
]
|
||||
},
|
||||
"execution_count": 7,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"a = \"Hallo\"\n",
|
||||
"b = \"Python\"\n",
|
||||
"a + ' ' + b"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 8,
|
||||
"id": "8c7599a2-c199-433b-bc74-5da51688bdd1",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"'HalloHalloHallo'"
|
||||
]
|
||||
},
|
||||
"execution_count": 8,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"a * 3"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "854d1c91-d4ea-478f-822e-3a3736fb5ff3",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Das kann man z.B. nutzen, um einen langen Strich zu erzeugen:"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 11,
|
||||
"id": "ef7ad859-36f3-46a4-9f5c-972eb45ad0e7",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"'________________________________________________________________________________'"
|
||||
]
|
||||
},
|
||||
"execution_count": 11,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"'_' * 80"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "cf941b04-99bd-41ce-ac04-4fd3b7a9564b",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"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.7"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 5
|
||||
}
|
||||
|
|
@ -0,0 +1,271 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "df41324e-da47-4d61-a80d-a7bd29198c8d",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Texte\n",
|
||||
"\n",
|
||||
"Bisher haben wir nur mit Zahlen gearbeitet, d.h. Python als besseren Taschenrechner verwendet.\n",
|
||||
"Jetzt wollen wir auch Texte verwenden.\n",
|
||||
"\n",
|
||||
"Text wird auch Zeichenkette oder String genannt.\n",
|
||||
"\n",
|
||||
"Texte haben wir auch schon gesehen, z.B.:\n",
|
||||
"\n",
|
||||
"* Variablennamen `a`, `b`, `c`\n",
|
||||
"* Funktionsnamen wie `my_min` und `cos`\n",
|
||||
"\n",
|
||||
"Um Texte, mit denen wir rechnen wollen, von Variablen und Funktionen zu unterscheiden, müssen wir diese in \" oder ' einschließen."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 6,
|
||||
"id": "7ae417ae-c8d5-4f0e-a280-16265f3fa2d3",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"a = 'Wort'\n",
|
||||
"b = \"Zwei Worte\"\n",
|
||||
"c = \"\"\"Ein mehrzeiliger Text\n",
|
||||
"muss in\n",
|
||||
"drei Hochkommatas\n",
|
||||
"eingeschlossen werden.\"\"\""
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 2,
|
||||
"id": "8af71ec8-1c40-4106-bbd4-3b0bdd2968f7",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"'Wort'"
|
||||
]
|
||||
},
|
||||
"execution_count": 2,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"a"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"id": "14c7d057-124d-4e3b-b6be-a966687930e1",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"'Ein mehrzeiliger Text\\nmuss in\\ndrei Hochkommatas\\neingeschlossen werden.'"
|
||||
]
|
||||
},
|
||||
"execution_count": 3,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"c"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "2e280d2d-eda2-473d-8997-94de82444f48",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"ℹ️ mit \\ lassen sich Sonderzeichen darstellen\n",
|
||||
"\n",
|
||||
"* \\\\ = \\\n",
|
||||
"* \\n = Zeilenumbruch\n",
|
||||
"* \\t = Tabulator"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "41dc4823-c5f0-4ffb-a6c6-c091789cf309",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Aufgabe\n",
|
||||
"❓ Was kann man alles mit Texten machen?\n",
|
||||
"\n",
|
||||
"Tipp:\n",
|
||||
"* `c.<TAB>`\n",
|
||||
"* `help(str)`"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "a376173a-66db-485f-acfe-818c44ad7320",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Lösung\n",
|
||||
"Die Aufgabe war so einfach, die braucht keine Lösung."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "d6a2bb1b-120c-48bf-aed5-ec11fe83f50a",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Aufgabe\n",
|
||||
"❓ Schreibt eine Funktion, die als Parameter ein englisches Wort akzeptiert und dessen Pluralform zurückliefert."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "59669fc1-2dc6-43a6-a297-3304f190d8ea",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Lösung\n",
|
||||
"Wir ignorieren die Sonderfälle und beschränken uns darauf, dBuchstaben **s** anzufügen wenn das Wort nicht damit endet."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 4,
|
||||
"id": "45aa62f3-1257-4499-b2fb-b818cc1dbd21",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def plural(s):\n",
|
||||
" if s.endswith('s'):\n",
|
||||
" return s\n",
|
||||
" else:\n",
|
||||
" return s + 's'"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 5,
|
||||
"id": "ddfbc878-4c16-48a8-852c-97379f447ab9",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"'horses'"
|
||||
]
|
||||
},
|
||||
"execution_count": 5,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"plural(\"horse\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "0e1833b4-aa3b-41b4-9602-0e36103e0070",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Rechnen mit Texten\n",
|
||||
"Texte kann man addieren und multiplizieren:"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 7,
|
||||
"id": "17a904df-8ffc-467a-8744-e2a4fd8b2134",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"'Hallo Python'"
|
||||
]
|
||||
},
|
||||
"execution_count": 7,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"a = \"Hallo\"\n",
|
||||
"b = \"Python\"\n",
|
||||
"a + ' ' + b"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 8,
|
||||
"id": "8c7599a2-c199-433b-bc74-5da51688bdd1",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"'HalloHalloHallo'"
|
||||
]
|
||||
},
|
||||
"execution_count": 8,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"a * 3"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "854d1c91-d4ea-478f-822e-3a3736fb5ff3",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Das kann man z.B. nutzen, um einen langen Strich zu erzeugen:"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 11,
|
||||
"id": "ef7ad859-36f3-46a4-9f5c-972eb45ad0e7",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"'________________________________________________________________________________'"
|
||||
]
|
||||
},
|
||||
"execution_count": 11,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"'_' * 80"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"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.7"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 5
|
||||
}
|
||||
|
|
@ -0,0 +1,362 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "a6eda542-00bd-401a-a2cd-735f182ffee4",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Schleifen und Arrays\n",
|
||||
"## For-Schleifen\n",
|
||||
"\n",
|
||||
"Addiere die Zahlen 1 bis 100 ist eine Aufgabe, die man effizient mit der [Gaußschen Summenformel](https://de.wikipedia.org/wiki/Gau%C3%9Fsche_Summenformel) lösen kann.\n",
|
||||
"Wir wollen aber den Computer die einzelnen Berechnungen durchführen lassen.\n",
|
||||
"Hierfür muss dieser\n",
|
||||
"* von 1 bis 100 Zählen\n",
|
||||
"* und diese Zahl jeweils auf die bisherige Summe addieren\n",
|
||||
"\n",
|
||||
"Als Funktion sieht das so aus:"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 25,
|
||||
"id": "92c0754d-0ad9-4920-97f1-fba219b24fcd",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def sum(start, end):\n",
|
||||
" sum = 0\n",
|
||||
" for i in range(start, end):\n",
|
||||
" sum = sum + i\n",
|
||||
" return sum"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 26,
|
||||
"id": "0abe90ed-f16c-4f85-91a2-72e3a16144ec",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"5050"
|
||||
]
|
||||
},
|
||||
"execution_count": 26,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"sum(1,101)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "9088fa07-2889-4470-9903-df1a5c1e1b3f",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"ℹ️ Bei der Programmierung hält man sich i.d.R. daran, dass bei einem Bereich\n",
|
||||
"* der erste Wert dazu gehört\n",
|
||||
"* der zweite Wert aber nicht mehr.\n",
|
||||
"\n",
|
||||
"Damit ist ein Jahr z.B. definiert als 1.1.2022 - 1.1.2023.\n",
|
||||
"Das gilt auch für die Funktion `range()`, die einen Zahlenbereich liefert."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "9a878b57-d866-43e5-a5af-863eea90b1b5",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Arrays\n",
|
||||
"Bisher hatten Variablen genau einen Wert, eine Zahl oder einen Text.\n",
|
||||
"Manchmal ist es aber praktisch, mehrere Werte darin zu speichern, z.B. den zu erwartenden Kontostand in den nächsten Jahren wenn man Geld mit einem bestimmten Zinssatz angelegt hat.\n",
|
||||
"\n",
|
||||
"Für so etwas gibt es Arrays."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 27,
|
||||
"id": "ea885cba-1b89-4ce2-b1e6-bcb737e0158b",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"[1, 2, 3, 1, 1, 1, 1, 1, 1, 1, 1]"
|
||||
]
|
||||
},
|
||||
"execution_count": 27,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# Array mit den Werten 1, 2 und 3\n",
|
||||
"a = [1,2,3]\n",
|
||||
"# 8 mal der Arry [1], d.h. [1, 1, 1, 1,1, 1, 1, 1]\n",
|
||||
"b = [1] * 8\n",
|
||||
"# Arrays kann man aneinanderfügen\n",
|
||||
"c = a + b\n",
|
||||
"c"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 28,
|
||||
"id": "aaf07a48-d337-4418-8d98-1e1abe35a1f4",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"[1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 1]"
|
||||
]
|
||||
},
|
||||
"execution_count": 28,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# die Reihenfole umdrehen - Achtung: es wird nichts zurückgeliefert, c wird intern geändert\n",
|
||||
"c.reverse()\n",
|
||||
"c"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 29,
|
||||
"id": "bdc988c6-a831-4303-a7c1-38aaeed2772f",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"3"
|
||||
]
|
||||
},
|
||||
"execution_count": 29,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# Auf einzelne Elemente des Arrays kann man zugreifen\n",
|
||||
"a[0] + a[1]"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 30,
|
||||
"id": "6fa6c3ef-b765-49b5-aebe-8ef53009b202",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"[1, 2, 3, 4]"
|
||||
]
|
||||
},
|
||||
"execution_count": 30,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# Ein neues Element hinten an den Array anhängen\n",
|
||||
"a.append(4)\n",
|
||||
"a"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 31,
|
||||
"id": "16ac89fe-daf4-4472-9d7d-613530f37a76",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"24"
|
||||
]
|
||||
},
|
||||
"execution_count": 31,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# Einen Array kann man statt range() auch in einer for-Schleife verwenden\n",
|
||||
"# Hier erhält die Variable i in jeden Durchlauf der Schleife einen Wert des Arrays a\n",
|
||||
"# Abhängig von der Berechung in der Schleife muss das Ergebnis (hier prod)\n",
|
||||
"# vorher initialisiert werden\n",
|
||||
"prod = 1\n",
|
||||
"for i in a:\n",
|
||||
" prod = prod * i\n",
|
||||
" \n",
|
||||
"prod"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "d60f9fd7-9b3f-4a1f-a572-c7e4407dd561",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Aufgabe\n",
|
||||
"❓ Schreibe eine Funktion, die als Parameter einen **Anlagebetrag**, einen **Zins** und die **Laufzeit** in Jahren entgegennimmt, \n",
|
||||
"die Zinsrechnung durchführt (Zinsen werden wieder angelegt) und einen Array zurückliefert, bei dem das 0te Element den aktuellen Geldbetrag enthält und die darauffolgenden Elemente den Kontostand nach jeweils n Jahren."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "67f9d6d7-9d51-4217-8555-b4e409848775",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Lösung"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 32,
|
||||
"id": "f0eca3d7-6b3e-4f06-869b-cbc563cce9c8",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def zinsrechnung(anlagebetrag, zins, jahre):\n",
|
||||
" \"\"\"Berechnet den Kontonstand der nächsten Jahre\n",
|
||||
" \n",
|
||||
" anlagebetrag\n",
|
||||
" Der inital angelegte Betrag\n",
|
||||
" zins\n",
|
||||
" Der vereinbarte Zins. Dieser bleibt über die gesamte Laufzeit gleich. Ein Zins von 1.5% muss als 1.5 angegeben werden.\n",
|
||||
" jahre\n",
|
||||
" Die Anlagedauer in Jahren.\n",
|
||||
" \n",
|
||||
" Das Ergebis ist ein Array mit jahre + 1 Elementen.\n",
|
||||
" Das 0. Element enthält den Anlagebetrag, das 1. Element den Gesamtbetrag nach Verzinsung nach dem ersten Jahr, ...\n",
|
||||
" \"\"\"\n",
|
||||
" \n",
|
||||
" result = [anlagebetrag] # Initialisieren mit anlagebetrag\n",
|
||||
" factor = (1 + zins / 100) # ist für jeden Schleifendurchlauf gleich, muss man nur einmal berechnen\n",
|
||||
" \n",
|
||||
" for i in range(0, jahre):\n",
|
||||
" result.append(result[i] * factor)\n",
|
||||
" \n",
|
||||
" return result"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 33,
|
||||
"id": "738f1035-38a9-45ad-ad94-e0ec4831c00d",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"[1000, 1010.0, 1020.1, 1030.301]"
|
||||
]
|
||||
},
|
||||
"execution_count": 33,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"zinsrechnung(1000, 1, 3)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "33c234e2-bb8d-4164-bf83-ab2929d228e6",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Aufgabe\n",
|
||||
"\n",
|
||||
"❓ Jetzt erweitern wir die vorherige Aufgabe.\n",
|
||||
"Der Zinssatz kann variabel sein. Er wird als Array neben dem anlagebetrag der Funktion übergeben."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "75d53e88-adf8-481f-a385-852a27315a1b",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Lösung"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 34,
|
||||
"id": "055c6f9f-5623-454a-b6ae-5579b05c6ca4",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def variabler_zins(anlagebetrag, zinsen):\n",
|
||||
" \"\"\"Berechnet den Kontonstand der nächsten Jahre\n",
|
||||
" \n",
|
||||
" anlagebetrag\n",
|
||||
" Der inital angelegte Betrag\n",
|
||||
" zinsen\n",
|
||||
" Array mit den Zinssätzen der nächsten Jahre. [1.0, 1.5] bedeutet, \n",
|
||||
" dass der Kontostand für 2 Jahre berechnet werden soll und im 1. Jahr 1.0%\n",
|
||||
" und im 2. Jahr 1.5% Zinsen gezahlt werden und die Zinsen wiederangelegt werden.\n",
|
||||
" \n",
|
||||
" Das Ergebis ist ein Array mit jahre + 1 Elementen.\n",
|
||||
" Das 0. Element enthält den Anlagebetrag, das 1. Element den Gesamtbetrag nach Verzinsung nach dem ersten Jahr, ...\n",
|
||||
" \"\"\"\n",
|
||||
" jahre = len(zinsen)\n",
|
||||
" result = [anlagebetrag]\n",
|
||||
" for i in range(0, jahre):\n",
|
||||
" result.append(result[i] * (1+ zinsen[i]/100))\n",
|
||||
" return result"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 35,
|
||||
"id": "26510caa-6a87-4b8e-98fc-bc1d9dfc5f85",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"[1000, 1010.0, 1025.1499999999999, 1045.6529999999998]"
|
||||
]
|
||||
},
|
||||
"execution_count": 35,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"variabler_zins(1000, [1.0, 1.5, 2.0])"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"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.7"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 5
|
||||
}
|
||||
|
|
@ -0,0 +1,313 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "471b22f4-5b9d-423d-bf7d-6cef078b175e",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Simulationen\n",
|
||||
"\n",
|
||||
"Aufbauend auf der letzten Aufgabe möchten wir jetzt simulieren, welches Ertrag wir erwarten können, wenn der Zinnsatz zufällig schwankt. Dafür benötigen wir eine Möglichkeit, diesen Zufall zu berechnen."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "b298aa38-556e-43d4-aee1-0047477a53fa",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Zufallszahlen\n",
|
||||
"\n",
|
||||
"Das Package `random` enthält Funktionen zu Erzeugung von Zufallszahlen.\n",
|
||||
"Probieren wir es aus:"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 5,
|
||||
"id": "2f9a1ee9-0a3f-4ee0-a6e1-d6bc61291889",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import random"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "327159f5-1e19-4334-9738-e9cc8a0c9d47",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"`help(random)` liefert eine lange Dokumentation. Wir brauchen nur einen kleinen Teil davon."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 6,
|
||||
"id": "7ba2a1a0-745d-4c9b-bbdf-8e562a445204",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"3.27\n",
|
||||
"0.57\n",
|
||||
"0.12\n",
|
||||
"3.79\n",
|
||||
"1.4\n",
|
||||
"1.25\n",
|
||||
"1.14\n",
|
||||
"0.71\n",
|
||||
"3.77\n",
|
||||
"0.52\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# Initialisierung - gleicher seed liefert gleiche Zufallszahlen!\n",
|
||||
"random.seed(42)\n",
|
||||
"samples = 10\n",
|
||||
"for i in range(samples):\n",
|
||||
" tmp = random.randint(0, 400)\n",
|
||||
" print(tmp / 100)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "b8a2a8fe-fbb4-4ab7-b927-841d949f3cf6",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Aufgabe\n",
|
||||
"Was tut das kleine Beispiel?\n",
|
||||
"Baue eine Funktion, die einen Array der Länge **n** zurückliefert.\n",
|
||||
"Der Inhalt sollen Zufallszahlen mit 2 Nachkommastellen sein die zwischen **from** und **to* liegen."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "7ed88639-c037-415a-b93f-bcdc8cb49a7c",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Lösung"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 7,
|
||||
"id": "3ffef006-eac3-41f6-9334-f22db10dc0d0",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def rand_numbers(n, start, end):\n",
|
||||
" digits = 2; # falls es mal nur 1 oder 3 Nachkommastellen werden sollen\n",
|
||||
" factor = 10 ** digits;\n",
|
||||
" result = []\n",
|
||||
" for i in range(n):\n",
|
||||
" result.append(random.randint(start * factor, end * factor) / factor)\n",
|
||||
" \n",
|
||||
" return result"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 8,
|
||||
"id": "34cda81b-7611-439e-8ba2-3f01c210fa76",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"[9.12, 36.56, 4.6, 4.44, 9.67]"
|
||||
]
|
||||
},
|
||||
"execution_count": 8,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"rand_numbers(5, 2, 44)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "976b757c-09fa-4492-8996-8129049dc0bf",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Aufgabe\n",
|
||||
"\n",
|
||||
"Schreibe eine neue Funktion, die diese Funktion als Zinsen in der Funktion zur variablen Zinsberechnung verwendet."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 13,
|
||||
"id": "cf269399-9603-4fc6-ae16-c40562d4d8dc",
|
||||
"metadata": {
|
||||
"tags": [
|
||||
"hide-input"
|
||||
]
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def variabler_zins(anlagebetrag, zinsen):\n",
|
||||
" jahre = len(zinsen)\n",
|
||||
" result = [anlagebetrag]\n",
|
||||
" for i in range(0, jahre):\n",
|
||||
" result.append(result[i] * (1+ zinsen[i]/100))\n",
|
||||
" return result"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 14,
|
||||
"id": "16d443c6-6b7c-4362-9048-92f23f44da3a",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"[100, 101.49999999999999, 104.03749999999998, 107.67881249999998]"
|
||||
]
|
||||
},
|
||||
"execution_count": 14,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"variabler_zins(100, [1.5, 2.5, 3.5])"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "ebbfb7e2-f7e1-4c1d-9f2e-6b5ad896be11",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Lösung"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 11,
|
||||
"id": "ac0de40d-c851-40e8-9f18-2c68c25cd7f0",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def variabler_zufallszins(anlagebetrag, jahre, min_zins, max_zins):\n",
|
||||
" return variabler_zins(anlagebetrag, rand_numbers(jahre, min_zins, max_zins))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 12,
|
||||
"id": "5d41f256-22ff-4604-9680-011cfbe77511",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"[1000,\n",
|
||||
" 1005.5000000000001,\n",
|
||||
" 1011.4324500000001,\n",
|
||||
" 1024.479928605,\n",
|
||||
" 1040.256919505517,\n",
|
||||
" 1040.8810736572204]"
|
||||
]
|
||||
},
|
||||
"execution_count": 12,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"variabler_zufallszins(1000, 5, 0, 2)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "5af14f52-76be-448b-b15f-2fe0d7d50a13",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Aufgabe\n",
|
||||
"Eine einzelne Simulation hat nicht viel Aussagekraft. Schreibe eine Funktion, die die Simulation **n** mal ausführt und von jeder Ausführung das Endergebnis zurückgibt."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "b4192e1f-8e0d-4de8-b6fb-215849aeb02f",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Lösung"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 22,
|
||||
"id": "e5ef01b5-bdce-4a3e-8d29-a3081126bdab",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def simulate(anlagebetrag, jahre, min_zins, max_zins, n):\n",
|
||||
" result = []\n",
|
||||
" for i in range(n):\n",
|
||||
" tmp = variabler_zufallszins(anlagebetrag, jahre, min_zins, max_zins)\n",
|
||||
" result.append(tmp[-1]) # letztes Element in Array hat Index -1, vorletztes -2, usw.\n",
|
||||
" \n",
|
||||
" return result"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 23,
|
||||
"id": "441e6fc3-66e5-41bf-9bb2-c01c475ad0b8",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"[1052.6442959071103,\n",
|
||||
" 1064.427091942078,\n",
|
||||
" 1083.9725955171834,\n",
|
||||
" 1089.3384949096728,\n",
|
||||
" 1093.7917438123886,\n",
|
||||
" 1099.7624262587865,\n",
|
||||
" 1112.5348861022283,\n",
|
||||
" 1123.567897245912,\n",
|
||||
" 1128.9355107957267,\n",
|
||||
" 1167.8728995649053]"
|
||||
]
|
||||
},
|
||||
"execution_count": 23,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"results = simulate(1000, 5, 0, 4, 10)\n",
|
||||
"results.sort()\n",
|
||||
"results"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"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.7"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 5
|
||||
}
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
all: html pdf
|
||||
|
||||
html:
|
||||
jupyter-book build .
|
||||
pdf:
|
||||
jupyter-book build --builder pdflatex .
|
||||
clean:
|
||||
rm -rf _build
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
# See https://jupyterbook.org/customize/config.html
|
||||
|
||||
title: Einführung in die Programmierung mit Python
|
||||
author: MARS – Center for Entrepreneurship
|
||||
email: c.giess@hs-mannheim.de
|
||||
copyright: "2022"
|
||||
logo: logo_mars.png
|
||||
|
||||
only_build_toc_files: true
|
||||
|
||||
execute:
|
||||
execute_notebooks: force
|
||||
|
||||
latex:
|
||||
latex_documents:
|
||||
targetname: python_intro.tex
|
||||
|
||||
sphinx:
|
||||
extra_extensions:
|
||||
- sphinx_jupyterbook_latex
|
||||
config:
|
||||
language: German
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
format: jb-book
|
||||
root: intro
|
||||
chapters:
|
||||
- file: 01_taschenrechner
|
||||
- file: 02_hilfe
|
||||
- file: 03_funktionen
|
||||
- file: 04_bedingungen_variablen
|
||||
- file: 05_texte
|
||||
- file: 06_schleifen_arrays
|
||||
- file: 07_zufallszahlen
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
# Dieser Kurs
|
||||
|
||||
Der Kurs richtet sich an Personen, die über keinerlei Erfahrung im Programmieren verfügen, dies aber lernen möchten.
|
||||
|
||||
Wir werden gemeinsam in entspannter Atmosphäre die ersten kleinen Programme erstellen und dabei die Grundlagen der Programmiersprache Python kennen lernen.
|
||||
|
||||
# Kurzvorstellung
|
||||
* Wer bin ich?
|
||||
* Wer seid ihr und was wollt ihr am Ende des Kurses machen?
|
||||
|
||||
# Los gehts
|
||||
|
||||
* Jupyter
|
||||
* https://jupyter.org/try-jupyter/lab/
|
||||
* Notebook Pyolite
|
||||
* Python im Webbrowser
|
||||
* Input-Zeile bedienen
|
||||
* Python Programm (Code) und Dokumentation ([Markdown](https://de.wikipedia.org/wiki/Markdown))
|
||||
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 3.5 KiB |
|
|
@ -0,0 +1 @@
|
|||
jupyter-book
|
||||
Binary file not shown.
Loading…
Reference in New Issue