Add notebooks for day 1 part 1

Signed-off-by: Christopher Arndt <chris@chrisarndt.de>

Kursgliederung.md

@@ -0,0 +1,147 @@
+# Programmieren mit Python: Kursgliederung
+
+
+## Tag 1 (Montag) Vormittag (9:00 - 12:30 Uhr)
+
+### Vorstellung & Organisatorisches (15-20 min)
+
+* Vorstellung SoftEd, Trainer, Seminarbegleitung
+* Ausblick auf die Seminarinhalte
+* Vorstellungsrunde Teilnehmer, Präsens und Online
+* Ablauf, Pausen, Mittagessen etc.
+
+### Einführung in die Programmiersprache Python (45-60 min)
+
+* Einführung in die Arbeitsumgebung für den Kurs
+* Verwendung des Interpreters (Interactive Modus)
+	* Aufruf
+	* Interaktives Testen von Code
+	* Python als Taschenrechner
+	* Erweiterte interaktive Umgebungen (IPython, Jupyter)
+* Genereller Aufbau eines Programms
+	* Hallo, Welt!
+	* Ein kurzes, aber komplettes Kommandozeilenprogramm
+	* Syntaxelemente von Python (Ausdrücke, Anweisungen, Operatoren, Trennzeichen, Einrückung usw.)
+* Grundlegende Datentypen und Operationen
+	* Integer und mathematische Operatoren
+	* Fließkommazahlen (Floats)
+	* Strings
+* Kontrollstrukturen und Vergleichsoperatoren
+	* Branching (Verzweigung): `if` / `elif` / `else` und `match`
+	* Loops (Schleifen): `for` und `while`
+	* Funktionen: `def` und `return`
+
+### Warum Python? (15 min)
+
+#### Was macht Python besonders und unterscheidet es von anderen Programmiersprachen?
+
+#### Anwendungsbereiche von Python
+
+* als "Skriptsprache"
+* für Desktop- und Webanwendungen
+* für Scientific Computing und Data Science
+* für Machine Learning
+* als Bindeglied zwischen Komponenten und Bibliotheken in anderen Sprachen
+* Für Embedded Programming (MicroPython)
+
+## Kaffee/Teepause (20 min)
+
+### Erweiterte Grundlagen in Python
+
+#### Erweiterte Datentypen: Container (45 min)
+
+* Listen
+* Tupel
+* Dictionary
+* Sets
+
+**Übungsaufgaben**
+
+
+#### String-Operation und String-Formatierung und Ausgabe (45 min)
+
+* Escape-Sequenzen, Single-, Double- und Triple-Quotes und Klammerung
+* Stringvergleiche und Testen auf Substrings
+* Strings zusammenfügen, auftrennen und slicen
+* Uppercase, Lowercase, Capitalization, Stripping, usw.
+* String-Formatierung und Formatstrings
+
+**Übungsaufgaben**
+
+
+## Mittagspause (12:30 - 13:30 Uhr)
+
+
+## Tag 1 (Montag) Nachmittag (13:30 Uhr - 17:00 Uhr)
+
+### Objektorientierung in Python (45-60 min)
+
+* Allgemeiner Einblick in die Objektstruktur in Python
+* Definieren von Klassen
+* Erzeugen von Objekten
+* Vererbung
+* Spezialmethoden von Objekten ("Dunder methods")
+
+**Übungsaufgaben**
+
+### Kaffee-/Teepause (20 min)
+
+### Fehlerbehandlung in Python (45-60 min)
+
+* Was sind Exceptions?
+* Abfangen von Fehlern
+* Eigene Fehler erzeugen
+* Eigene Exceptions definieren und benutzen
+
+**Übungsaufgaben**
+
+### Tipps und Tricks im täglichen Umgng mit Python (10-20 min)
+
+### Zusammenfassung, Fragen, Lösungen usw. (30 min)
+
+
+## Tag 2 (Dienstag) Vormittag (9:00 - 12:30 Uhr)
+
+### Rekapitulierung der Inhalte vom Vortag und Fragen (20-30 min)
+
+### Module in Python (45-60 min)
+
+* Importieren, verwenden von Modulen
+* Allgemeiner Umgang mit dem Packet Manager PIP
+* Eigene Module definieren
+* Module und Pakete (`Packages')
+* Der Standardmodulsuchpfad (`sys.path`)
+* Relative Importe
+
+## Kaffee-/Teepause (20 min)
+
+### Zugriff auf das Dateisystem
+
+* Öffnen, Lesen und Schreiben von Dateien
+* Text- und Binärdaten
+* Text-Encodings
+* Lesen und Schreiben von Daten im JSON Format
+* Fehlerbehandlung und Context Manager (`with`-Statement)
+
+**Übungsaufgaben**
+
+### Datenbankzugriff mit Sqlite3
+
+**Übungsaufgaben**
+
+
+## Mittagspause (12:30 - 13:30 Uhr)
+
+
+## Tag 2 (Dienstag) Nachmittag (13:30 Uhr - 17:00 Uhr)
+
+### Entwicklung eines HTML-Crawlers (60-90 min)
+
+## Kaffee-/Teepause (20 min)
+
+### Zusammenfassung, Fragen, Lösungen usw. (30 min)
+
+### Best Practices (30 min)
+
+* Code Style
+* Verwendung von Dekoratoren (falls Zeit)

Seminarinhalt.md

@@ -0,0 +1,53 @@
+# Programmieren mit Python: Seminarinhalt
+
+## Einführung in die Programmiersprache Python
+
+* Verwendung des Interpreters (Interactive Modus)
+* Genereller Aufbau eines Programms
+* Grundlegende Datentypen und Operationen
+* Kontrollstrukturen
+
+## Erweiterte Grundlagen in Python
+
+* Erweiterte Datentypen: Listen, Tupel, Dictionary, Set
+* String Formatierung
+
+## Funktionen in Python
+
+* Definition und Aufruf von Funktionen
+* Generatoren
+* Rekursion
+
+## Objektorientierung in Python
+
+* Allgemeiner Einblick in die Objektstruktur in Python
+* Definieren von Klassen
+* Erzeugen von Objekten
+* Vererbung
+
+## Fehlerbehandlung in Python
+
+* Abfangen von Fehlern
+* Eigene Fehler erzeugen
+
+## Module in Python
+
+* Importieren, Verwenden von Modulen
+* Allgemeiner Umgang mit dem Packet Manager PIP
+
+## Zugriff auf das Dateisystem
+
+* Lesen und Schreiben von Daten im JSON Format
+
+## Datenbankzugriff mit Sqlite3
+
+## Entwicklung eines HTML-Crawlers
+
+## Best Practices
+
+* Code Style
+* Verwendung von Dekoratoren
+
+
+
+

makepdf.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+for md in *.md; do
+    if [[ "$md" = "README.md" ]]; then
+        continue
+    fi
+    pandoc --from=gfm --to=pdf -o "${md%.*}.pdf" "$md"
+done

notebooks/basictypes.ipynb

@@ -0,0 +1,420 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Grundlegende Datentypen und Operationen"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Numerische Typen"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "42\n",
+      "23\n",
+      "65\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Ganzzahlen (Integers)\n",
+    "\n",
+    "a = 42\n",
+    "b = 23\n",
+    "print(a)\n",
+    "print(b)\n",
+    "print(a + b)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3.14159\n",
+      "2.71828\n",
+      "8.539721265199999\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Fließkommazahlen (Floats)\n",
+    "\n",
+    "pi = 3.14159\n",
+    "e = 2.71828\n",
+    "print(pi)\n",
+    "print(type(pi))\n",
+    "print(e)\n",
+    "print(pi * e)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3 1.5 4.5\n",
+      "<class 'float'>\n",
+      "0.16666666666666666\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Implizite Umwandlung von numerischen Typen\n",
+    "\n",
+    "i = 3\n",
+    "f = 1.5\n",
+    "summe = a + f\n",
+    "print(i, f, summe)\n",
+    "print(type(e))\n",
+    "z = 1\n",
+    "n = 6\n",
+    "print(z / n)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2\n",
+      "999\n",
+      "144\n",
+      "8.0\n",
+      "3.8\n",
+      "1.0\n",
+      "23.799999999999997\n",
+      "0.3333333333333333\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Grundrechenarten\n",
+    "\n",
+    "# Integer\n",
+    "print(1 + 1)\n",
+    "print(1_000 - 1)\n",
+    "print(12 * 12)  # Vorsicht: Asterisk (\"Sternchen\"), nicht x)\n",
+    "print(64 / 8)\n",
+    "\n",
+    "# Floats\n",
+    "print(0.5 + 3.3)\n",
+    "print(1.99 - 0.99)\n",
+    "print(20.0 * 1.19)\n",
+    "print(1.0 / 3.0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "64\n",
+      "512\n",
+      "512\n",
+      "11585.237502960395\n"
+     ]
+    }
+   ],
+   "source": [
+    "# X hoch Y\n",
+    "\n",
+    "x = 8\n",
+    "x2 = x ** 2\n",
+    "print(x2)\n",
+    "print(x ** 3)\n",
+    "print(pow(x, 3))\n",
+    "\n",
+    "print(x ** e)\n",
+    "print(pow(x, e))   # pow akzeptiert integer und floats"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1\n",
+      "<class 'int'>\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Modulo\n",
+    "\n",
+    "x = 10\n",
+    "y = 3\n",
+    "rest = x % 3\n",
+    "print(rest)\n",
+    "print(type(rest))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Strings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dies ist ein String!\n",
+      "Man kann einfache oder doppelte Anführungszeichen verwenden.\n",
+      "Innerhalb der Anführungszeichen kann man den jeweils \"anderen Typ\" verwenden\n",
+      "Oder 'andersherum'.\n",
+      "Alternativ kann man eine Backslash als \"Escape\"-Zeichen verwenden\n",
+      "String-Literale, die direkt hintereinander, durch Leerzeichen getrennt, stehenwerden zusammengefügt.\n",
+      "Mit Klammerung klapt das auch über mehrere Zeilen hinweg\n"
+     ]
+    }
+   ],
+   "source": [
+    "s = \"Dies ist ein String!\"\n",
+    "print(s)\n",
+    "s2 = 'Man kann einfache oder doppelte Anführungszeichen verwenden.'\n",
+    "print(s2)\n",
+    "s3a = 'Innerhalb der Anführungszeichen kann man den jeweils \"anderen Typ\" verwenden'\n",
+    "print(s3a)\n",
+    "s3b = \"Oder 'andersherum'.\"\n",
+    "print(s3b)\n",
+    "s4 = \"Alternativ kann man eine Backslash als \\\"Escape\\\"-Zeichen verwenden\"\n",
+    "print(s4)\n",
+    "s5 = \"String-Literale\" \", die direkt hintereinander\" \", durch Leerzeichen getrennt, stehen\" \"werden zusammengefügt.\"\n",
+    "print(s5)\n",
+    "s6 = (\"Mit Klammerung klappt das auch \"\n",
+    "      \"über mehrere Zeilen \"\n",
+    "      \"hinweg\")\n",
+    "print(s6)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dies ist ein langer String (\"triple quoted string\").\n",
+      "Er kann Zeilenumbrüche enthalten.\n",
+      "\n",
+      "Und Leerzeilen.\n",
+      "\n",
+      "Und auch 'einfache' oder \"doppelte\" Anführungszeichen.\n",
+      "\n",
+      "Er endet mit drei weiteren Anführungszeichen des gleichen Typs.\n",
+      "\n",
+      "'Dies ist ein langer String (\"triple quoted string\").\\nEr kann Zeilenumbrüche enthalten.\\n\\nUnd Leerzeilen.\\n\\nUnd auch \\'einfache\\' oder \"doppelte\" Anführungszeichen.\\n\\nEr endet mit drei weiteren Anführungszeichen des gleichen Typs.\\n'\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Längere Strings\n",
+    "\n",
+    "long_string = \"\"\"Dies ist ein langer String (\"triple quoted string\").\n",
+    "Er kann Zeilenumbrüche enthalten.\n",
+    "\n",
+    "Und Leerzeilen.\n",
+    "\n",
+    "Und auch 'einfache' oder \"doppelte\" Anführungszeichen.\n",
+    "\n",
+    "Er endet mit drei weiteren Anführungszeichen des gleichen Typs.\n",
+    "\"\"\"\n",
+    "print(long_string)\n",
+    "print(repr(long_string))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Erste Zeile\n",
+      "Zweite Zeile\n",
+      "Eine Zeile\n",
+      "Noch eine Zeile\n",
+      "Eins\tZwei\tDrei\n",
+      "1\t2\t3\n",
+      "'Dieser String enthält ein\\x00Null-Zeichen'\n",
+      "Hexadezimal-Codes können wir druckbare (e.g. '@') und nicht druckbare Zeichen (e.g. ) verwendet werden.\n",
+      "❤\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Escape Sequenzen\n",
+    "\n",
+    "# Zeilenumbrüche und Tabs\n",
+    "print(\"Erste Zeile\\r\\nZweite Zeile\")  # Zeilenumbruch nach Windows-Art  \n",
+    "print(\"Eine Zeile\\nNoch eine Zeile\")  # Rest der Welt ;-)\n",
+    "print(\"Eins\\tZwei\\tDrei\")\n",
+    "print(\"1\\t2\\t3\")\n",
+    "\n",
+    "# Null und Hexadezimal- und Unicode-Sequenzen\n",
+    "print(repr(\"Dieser String enthält ein\\0Null-Zeichen\"))\n",
+    "print(\"Hexadezimal-Codes können wir druckbare (e.g. '\\x40') und nicht druckbare Zeichen (e.g. \\x7F) verwendet werden.\")\n",
+    "print('\\u2764')  # Unicode"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dies ist der erste String.Und dies der zweite.\n",
+      "Ich habe es dir schon dreimal gesagt!Ich habe es dir schon dreimal gesagt!Ich habe es dir schon dreimal gesagt!\n"
+     ]
+    }
+   ],
+   "source": [
+    "# String-Operationen\n",
+    "\n",
+    "s1 = \"Dies ist der erste String.\"\n",
+    "s2 = \"Und dies der zweite.\"\n",
+    "s3 = s1 + s2\n",
+    "print(s3)\n",
+    "s4 = \"Ich habe es dir schon dreimal gesagt! \"\n",
+    "print(s4 * 3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "SCHREI NICHT SO LAUT!\n",
+      "True\n",
+      "True\n",
+      "True\n"
+     ]
+    }
+   ],
+   "source": [
+    "klein = \"schrei nicht so laut!\"\n",
+    "print(klein.upper())\n",
+    "print(\"hallo\" == \"HALLO\".lower())\n",
+    "print(\"hallo\" == \"Hallo\".lower())\n",
+    "print(\"straße\".upper() == \"STRASSE\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hallo\n",
+      "a\n",
+      "Hello\n"
+     ]
+    }
+   ],
+   "source": [
+    "hallo = \"Hallo\"\n",
+    "print(hallo)\n",
+    "print(hallo[1])\n",
+    "print(hallo[0] + 'e' + hallo[2:])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "TypeError",
+     "evalue": "'str' object does not support item assignment",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[1;32m/home/chris/work/python-kurs-softed/notebooks/basictypes.ipynb Cell 16\u001b[0m line \u001b[0;36m3\n\u001b[1;32m      <a href='vscode-notebook-cell:/home/chris/work/python-kurs-softed/notebooks/basictypes.ipynb#X23sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m \u001b[39m# Aber das geht nicht:\u001b[39;00m\n\u001b[0;32m----> <a href='vscode-notebook-cell:/home/chris/work/python-kurs-softed/notebooks/basictypes.ipynb#X23sZmlsZQ%3D%3D?line=2'>3</a>\u001b[0m hallo[\u001b[39m1\u001b[39;49m] \u001b[39m=\u001b[39m \u001b[39m'\u001b[39m\u001b[39me\u001b[39m\u001b[39m'\u001b[39m\n",
+      "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
+     ]
+    }
+   ],
+   "source": [
+    "# Aber das geht nicht!:\n",
+    "\n",
+    "hallo[1] = 'e'"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "softed",
+   "language": "python",
+   "name": "softed"
+  },
+  "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.11.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

notebooks/controlflow.ipynb

@@ -0,0 +1,585 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Kontrollstrukturen und Vergleichsoperatoren"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Verzweigung (Branching)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hmm, ob das so stimmt?\n"
+     ]
+    }
+   ],
+   "source": [
+    "# if / else / elif\n",
+    "\n",
+    "alter = -1\n",
+    "\n",
+    "if alter >= 16:\n",
+    "    print(\"Nicht vergessen: am 9.6.2024 ist Europa-Wahl!\")\n",
+    "elif alter > 0:\n",
+    "    print(\"Schön, dass du geboren bist!\")\n",
+    "else:\n",
+    "    print(\"Hmm, ob das so stimmt?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Nach Süden, nach Süden!\n"
+     ]
+    }
+   ],
+   "source": [
+    "richtung = \"s\"\n",
+    "\n",
+    "if richtung == \"n\":\n",
+    "    print(\"Auf in den hohen Norden!\")\n",
+    "elif richtung == \"s\":\n",
+    "    print(\"Nach Süden, nach Süden!\")\n",
+    "elif richtung == \"w\":\n",
+    "    print(\"Go west!\")\n",
+    "elif richtung == \"o\":\n",
+    "    print(\"Bin schon da.\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Auf in den hohen Norden!\n"
+     ]
+    }
+   ],
+   "source": [
+    "# match\n",
+    "\n",
+    "# richtung = input(\"Wo soll's denn lang gehen? \")\n",
+    "richtung = \"n\"\n",
+    "\n",
+    "match richtung:\n",
+    "    case \"n\" | \"norden\":\n",
+    "        print(\"Auf in den hohen Norden!\")\n",
+    "    case \"s\" | \"süden\":\n",
+    "        print(\"Nach Süden, nach Süden!\")\n",
+    "    case \"w\" | \"westen\":\n",
+    "        print(\"Go west!\")\n",
+    "    case \"o\" | \"osten\":\n",
+    "        print(\"Bin schon da.\")\n",
+    "    case _:\n",
+    "        print(\"Das Glück liegt manchmal abseits des direkten Wegs!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Schleifen"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Schleifendurchlauf Nr.  0\n",
+      "Schleifendurchlauf Nr.  1\n",
+      "Schleifendurchlauf Nr.  2\n",
+      "Schleifendurchlauf Nr.  3\n",
+      "Schleifendurchlauf Nr.  4\n"
+     ]
+    }
+   ],
+   "source": [
+    "# for\n",
+    "\n",
+    "for i in range(5):\n",
+    "    print(\"Schleifendurchlauf Nr. \", i)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Summer der Zahlen 1-10:  55\n"
+     ]
+    }
+   ],
+   "source": [
+    "result = 0\n",
+    "for i in range(1, 11):\n",
+    "    result += i\n",
+    "print(\"Summe der Zahlen 1-10:\", result)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "9 passt in die Reihe\n"
+     ]
+    }
+   ],
+   "source": [
+    "for i in (2, 4, 6, 8, 9, 10):\n",
+    "    if i % 2:\n",
+    "        print(i, \"passt nicht in die Reihe\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "10 ... 9 ... 8 ... 7 ... 6 ... 5 ... 4 ... 3 ... 2 ... 1 ... Lift off!\n"
+     ]
+    }
+   ],
+   "source": [
+    "# while\n",
+    "\n",
+    "i = 10\n",
+    "while i > 0:  # or: while True:\n",
+    "    print(i, \"... \", end=\"\")\n",
+    "    i -= 1\n",
+    "print(\"Lift off!\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "10\n",
+      "11\n",
+      "12\n",
+      "14\n",
+      "15\n",
+      "16\n",
+      "17\n",
+      "18\n",
+      "19\n"
+     ]
+    }
+   ],
+   "source": [
+    "# continue\n",
+    "\n",
+    "for i in range(10, 20):\n",
+    "    if i == 13:\n",
+    "        continue\n",
+    "    print(i)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration:  142\n"
+     ]
+    }
+   ],
+   "source": [
+    "# break\n",
+    "\n",
+    "i = 0\n",
+    "result = 0\n",
+    "maximum = 10_000\n",
+    "\n",
+    "while True:\n",
+    "    result += i\n",
+    "\n",
+    "    if result >= maximum:\n",
+    "        print(\"Iteration: \", i+1)\n",
+    "        break\n",
+    "\n",
+    "    i += 1\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "q ist Buchstabe Nr. 17 des dt. Alphabets.\n"
+     ]
+    }
+   ],
+   "source": [
+    "alphabet = \"abcdefghifklmnopqrstuvwxyz\"\n",
+    "buchstabe = \"q\"\n",
+    "i = 0\n",
+    "for char in alphabet:\n",
+    "    i += 1\n",
+    "    if char == buchstabe:\n",
+    "        print(buchstabe, \"ist Buchstabe Nr.\", i, \"des dt. Alphabets.\")\n",
+    "        break\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "q ist Buchstabe Nr. 17 des dt. Alphabets.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# einfacher:\n",
+    "\n",
+    "for i, char in enumerate(alphabet):\n",
+    "    if char == buchstabe:\n",
+    "        print(buchstabe, \"ist Buchstabe Nr.\", i + 1, \"des dt. Alphabets.\")\n",
+    "        break"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Funktionen"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "256 256 100\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Aufruf eingebauter Funktionen\n",
+    "\n",
+    "x = pow(2, 8)\n",
+    "y = max(x, 100)\n",
+    "z = min(max(0, x), 100)\n",
+    "print(x, y, z)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# optionale Parameter\n",
+    "\n",
+    "print()\n",
+    "print(\"\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "5\n"
+     ]
+    }
+   ],
+   "source": [
+    "# eigene Funktionen\n",
+    "\n",
+    "def add(a, b):\n",
+    "    return a + b\n",
+    "\n",
+    "print(add(2, 3))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "15\n",
+      "24\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Keyword arguments\n",
+    "\n",
+    "print(add(a=5, b=10))\n",
+    "print(add(4, b=20))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "SyntaxError",
+     "evalue": "positional argument follows keyword argument (1525390589.py, line 2)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;36m  Cell \u001b[0;32mIn[21], line 2\u001b[0;36m\u001b[0m\n\u001b[0;31m    print(add(a=6, 10))\u001b[0m\n\u001b[0m                     ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m positional argument follows keyword argument\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Das geht nicht:\n",
+    "print(add(a=6, 10))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Vergleichsausdrücke"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "False\n",
+      "True\n",
+      "False\n",
+      "True\n",
+      "True\n",
+      "False\n",
+      "True\n",
+      "True\n"
+     ]
+    }
+   ],
+   "source": [
+    "a = 10\n",
+    "b = 50\n",
+    "c = 2\n",
+    "d = 5 * a\n",
+    "\n",
+    "print(a == b)\n",
+    "print(a != d)\n",
+    "print(a > b)\n",
+    "print(a > c)\n",
+    "print(a >= c)\n",
+    "print(c > a)\n",
+    "print(c < b)\n",
+    "print(c >= 2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True\n",
+      "True\n",
+      "True\n",
+      "False\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Negation\n",
+    "\n",
+    "print(not c > a)\n",
+    "print(not a == b)   # klarer: a != b\n",
+    "print(not b != d)   # klarer: b == d\n",
+    "print(not a > c)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True\n",
+      "True\n",
+      "True\n"
+     ]
+    }
+   ],
+   "source": [
+    "# logische Kombination\n",
+    "\n",
+    "print(b > a and a > c)\n",
+    "print(a > b or a > c)\n",
+    "print(not a < c and b >= d)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True\n",
+      "True\n",
+      "True\n",
+      "False\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Bool'scher (True/False) Wert von Integers, Floats und Strings  \n",
+    "print(a > c)\n",
+    "print(bool(a > c))  ## redundant, da Vergleichsausdrücke immer einen bool'schen Wert haben\n",
+    "# Aber:\n",
+    "print(bool(a))\n",
+    "print(not a)  # auch ein bool'scher Ausdruck\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "False\n",
+      "True\n",
+      "True\n",
+      "False\n",
+      "True\n",
+      "True\n",
+      "True\n",
+      "True\n",
+      "False\n",
+      "True\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(bool(0))\n",
+    "print(bool(1))\n",
+    "print(bool(-1))\n",
+    "print(bool(0.0))\n",
+    "print(bool(0.1))\n",
+    "print(bool(-0.1))\n",
+    "print(bool(\"True\"))\n",
+    "print(bool(\"False\"))  # !!!\n",
+    "print(bool(\"\"))\n",
+    "print(bool(\"\\0\"))\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "softed",
+   "language": "python",
+   "name": "softed"
+  },
+  "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.11.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}