wbs-python/python/grundlagen.ipynb

{
 "cells": [
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "## 1. Grundlegendes zu Python\n",
    "\n",
    "Python ist, im Gegensatz zu Java und C#, eine interpretierte Sprache.\n",
    "\n",
    "Compiler analysieren normalerweise den gesamten Code und wandeln diesen insgesamt in Bytecode oder Maschinencode um.\n",
    "\n",
    "Ein Interpreter schaut sich den Code dagegen Zeile für Zeile an und führt diesen direkt aus oder kompiliert ihn, ohne den restlichen Code vorher vollständig zu kennen.\n",
    "\n",
    "Weitere Informationen:\n",
    "https://en.wikipedia.org/wiki/Interpreter_(computing)\n",
    "\n",
    "Wichtig:\n",
    "\n",
    "Wie bei C müssen wir in Python auf die Reihenfolge achten, in der Funktionen und Variablen deklariert werden.\n",
    "\n",
    "Das bedeutet:\n",
    "\n",
    "- Code wird von oben nach unten verarbeitet\n",
    "- Funktionen oder Variablen müssen bekannt sein, bevor sie verwendet werden\n",
    "- Fehler können dadurch zur Laufzeit auftreten"
   ],
   "id": "ac0c33dc0c1297e4"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "## 2. Programmierparadigmen und Typisierung\n",
    "\n",
    "Python bietet mehrere Programmierparadigmen:\n",
    "\n",
    "- objektorientierte Programmierung\n",
    "- aspektorientierte Programmierung\n",
    "- funktionale Programmierung\n",
    "\n",
    "Außerdem ist Python dynamisch typisiert.\n",
    "\n",
    "Das bedeutet:\n",
    "\n",
    "- Variablen haben keinen fest eingetragenen Datentyp\n",
    "- der Datentyp wird zur Laufzeit ermittelt\n",
    "- eine Variable kann später einen anderen Datentyp aufnehmen\n",
    "\n",
    "Wie viele dynamische Sprachen wird Python häufig als Skriptsprache verwendet.\n",
    "\n",
    "Weitere Informationen:\n",
    "https://de.wikipedia.org/wiki/Aspektorientierte_Programmierung\n"
   ],
   "id": "d284d731a2a42b8c"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "## 3. Syntax in Python\n",
    "\n",
    "Python verwendet keine Semikolons und keine geschweiften Klammern.\n",
    "\n",
    "Stattdessen ist besonders wichtig:\n",
    "\n",
    "- Einrückungen\n",
    "- Zeilenabstände\n",
    "- gut lesbare Namen\n",
    "\n",
    "Einrückungen bestimmen in Python, welche Anweisungen zu einem Block gehören.\n",
    "\n",
    "Weitere Informationen zu Namenskonventionen:\n",
    "https://peps.python.org/pep-0008/#naming-conventions\n"
   ],
   "id": "2baf47f4d725f805"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "## 4. Kommentare\n",
    "\n"
   ],
   "id": "2525f9ee74b8ad94"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:14.443182400Z",
     "start_time": "2026-07-21T06:13:14.353016900Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Ein einzeiliger Kommentar\n",
    "\n",
    "\"\"\"\n",
    "Ein\n",
    "mehrzeiliger\n",
    "Kommentar\n",
    "\"\"\""
   ],
   "id": "9cb1aee100734ca0",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nEin\\nmehrzeiliger\\nKommentar\\n'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 1
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Einzeilige Kommentare beginnen mit einem Rautezeichen.\n",
    "\n",
    "Mehrzeilige Kommentare können mit dreifachen Anführungszeichen geschrieben werden.\n",
    "\n",
    "Hinweis:\n",
    "\n",
    "Dreifache Anführungszeichen erzeugen technisch gesehen einen mehrzeiligen String. Wenn dieser String keiner Variable zugewiesen wird, kann er ähnlich wie ein Kommentar verwendet werden."
   ],
   "id": "d22972b4204121ef"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 5. Module importieren",
   "id": "aca9990202898832"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:14.487833800Z",
     "start_time": "2026-07-21T06:13:14.449716300Z"
    }
   },
   "cell_type": "code",
   "source": "import random  # Zufallsgenerator importieren",
   "id": "fd4e242bb6a19765",
   "outputs": [],
   "execution_count": 2
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Mit import können zusätzliche Module eingebunden werden.\n",
    "\n",
    "In diesem Beispiel wird random verwendet, um später Zufallszahlen zu erzeugen."
   ],
   "id": "6dad3cc1dc131214"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 6. Textausgabe",
   "id": "a0197eb00bd1bf0d"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:14.644513100Z",
     "start_time": "2026-07-21T06:13:14.498362Z"
    }
   },
   "cell_type": "code",
   "source": "print('Hello World')",
   "id": "be5776e2873bf60b",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Mit print() wird Text in der Konsole ausgegeben.\n",
    "\n",
    "Der Text \"Hallo, Welt!\" ist ein String."
   ],
   "id": "297b49ca008ced24"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 7. Variablen und dynamische Typisierung",
   "id": "d7956f498c4ad59f"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:14.766124400Z",
     "start_time": "2026-07-21T06:13:14.668107500Z"
    }
   },
   "cell_type": "code",
   "source": [
    "zahl = 20\n",
    "print(zahl)\n",
    "print(zahl + 10)"
   ],
   "id": "6c4e1daa92e19fad",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "30\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "In Python muss bei einer Variable kein Datentyp angegeben werden.\n",
    "\n",
    "Der Datentyp wird dynamisch ermittelt.\n",
    "\n",
    "Hier enthält die Variable zahl zunächst eine ganze Zahl.\n",
    "\n",
    "Mit dieser Zahl kann gerechnet werden."
   ],
   "id": "5ad29acf306eed66"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 8. Datentyp anzeigen",
   "id": "c598acffd19d9a04"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:14.830121500Z",
     "start_time": "2026-07-21T06:13:14.781675100Z"
    }
   },
   "cell_type": "code",
   "source": [
    "zahl = 20\n",
    "print(type(zahl))"
   ],
   "id": "3e2af284c19c419e",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    }
   ],
   "execution_count": 5
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Mit type() kann der aktuelle Datentyp einer Variable ausgegeben werden.\n",
    "\n",
    "Das ist besonders hilfreich, weil Variablen in Python ihren Datentyp ändern können."
   ],
   "id": "5fc6c977158682e"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 9. Datentyp ändern",
   "id": "fa8068b01478cb8a"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:14.885497100Z",
     "start_time": "2026-07-21T06:13:14.840648700Z"
    }
   },
   "cell_type": "code",
   "source": [
    "zahl = 20\n",
    "print(type(zahl))\n",
    "zahl = \"Hallo!\"\n",
    "print(zahl)\n",
    "print(type(zahl))"
   ],
   "id": "2a37d25ed63988b2",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "Hallo!\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "execution_count": 6
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Hier wird der Variable zahl ein String zugewiesen.\n",
    "\n",
    "Vorher enthielt zahl eine ganze Zahl. Danach enthält dieselbe Variable Text.\n",
    "\n",
    "Daran sieht man die dynamische Typisierung:\n",
    "\n",
    "- zuerst int\n",
    "- danach str"
   ],
   "id": "790093290c60db24"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 10. String-Konkatenation und Typumwandlung",
   "id": "c55721a07a7b9733"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:14.978829800Z",
     "start_time": "2026-07-21T06:13:14.895515Z"
    }
   },
   "cell_type": "code",
   "source": [
    "zahl = zahl + str(10)\n",
    "(print(zahl))"
   ],
   "id": "e50ae419489806d1",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hallo!10\n"
     ]
    }
   ],
   "execution_count": 7
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Hier wird die Zahl 10 mit str() in einen String umgewandelt.\n",
    "\n",
    "Nur dadurch kann sie an den vorhandenen String angehängt werden.\n",
    "\n",
    "Ohne diese Umwandlung würde Python versuchen, Text und Zahl direkt zu verknüpfen. Das ist nicht erlaubt."
   ],
   "id": "c99969da5bc2632f"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 11. Listen",
   "id": "1f5f478a2bcb8d9a"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:15.113436500Z",
     "start_time": "2026-07-21T06:13:14.988359400Z"
    }
   },
   "cell_type": "code",
   "source": [
    "zahlen_liste = [1,2,3,4,5]\n",
    "print(zahlen_liste)\n",
    "print(type(zahlen_liste))"
   ],
   "id": "cd63682b0d2fb55e",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "execution_count": 8
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Eine Liste kann mehrere Werte speichern.\n",
    "\n",
    "Mit type() kann auch hier überprüft werden, dass es sich um eine Liste handelt.\n",
    "\n",
    "Neben Listen gibt es in Python auch:\n",
    "\n",
    "- Tupel\n",
    "- Sets\n",
    "- Dictionaries\n",
    "\n",
    "Diese Datenstrukturen werden später genauer betrachtet."
   ],
   "id": "58679f512bbf1723"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 12. Länge und Indexzugriff",
   "id": "6a1059fd9735a597"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:15.188873900Z",
     "start_time": "2026-07-21T06:13:15.121959800Z"
    }
   },
   "cell_type": "code",
   "source": [
    "print(\"Länge der Liste: \", len(zahlen_liste))\n",
    "print(\"Element an Stelle 2: \", zahlen_liste[2])"
   ],
   "id": "60135a23cd9a6a3a",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Länge der Liste:  5\n",
      "Element an Stelle 2:  3\n"
     ]
    }
   ],
   "execution_count": 9
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Mit len() wird die Länge der Liste ermittelt.\n",
    "\n",
    "Listen beginnen mit Index 0.\n",
    "\n",
    "Das bedeutet:\n",
    "\n",
    "- zahlen_liste[0] ist das erste Element\n",
    "- zahlen_liste[1] ist das zweite Element\n",
    "- zahlen_liste[2] ist das dritte Element"
   ],
   "id": "e76be58c3730032a"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 13. Listen kopieren und verändern",
   "id": "dd32946372b8b201"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:15.278654200Z",
     "start_time": "2026-07-21T06:13:15.190874100Z"
    }
   },
   "cell_type": "code",
   "source": [
    "neue_liste = zahlen_liste.copy()\n",
    "neue_liste.append(10)\n",
    "zahl = zahlen_liste.pop(0)\n",
    "print(zahlen_liste[0])\n",
    "print(zahlen_liste)\n",
    "print(neue_liste)\n",
    "print(zahl)"
   ],
   "id": "8c85e4440a3c8c33",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "[2, 3, 4, 5]\n",
      "[1, 2, 3, 4, 5, 10]\n",
      "1\n"
     ]
    }
   ],
   "execution_count": 10
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Mit copy() wird eine Kopie der Liste erstellt.\n",
    "\n",
    "Mit append() wird ein neues Element an das Ende der Liste angefügt.\n",
    "\n",
    "Mit pop(0) wird das Element an Index 0 entfernt.\n",
    "\n",
    "Wie bei Java und C# rücken die folgenden Elemente danach nach vorne.\n",
    "\n",
    "Wichtig:\n",
    "\n",
    "Die Kopie neue_liste und die ursprüngliche Liste zahlen_liste können sich danach unterschiedlich entwickeln."
   ],
   "id": "f8c38f83bbb50148"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "## 14. Slicing\n",
    "Mit Slicing kann ein Teilbereich einer Liste ausgewählt werden."
   ],
   "id": "8e296e0a7da8e0bc"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:15.332018800Z",
     "start_time": "2026-07-21T06:13:15.286157300Z"
    }
   },
   "cell_type": "code",
   "source": "print(neue_liste[1:4])",
   "id": "a80e99c9b71b0398",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 4]\n"
     ]
    }
   ],
   "execution_count": 11
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Hier werden die Elemente von Index 1 bis exklusiv Index 4 ausgegeben.\n",
    "\n",
    "Das bedeutet:\n",
    "\n",
    "- Startindex ist enthalten\n",
    "- Endindex ist nicht enthalten"
   ],
   "id": "2498c71328e12edb"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 15. Gemischte Listen",
   "id": "86f9b53bb8174380"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:15.383606500Z",
     "start_time": "2026-07-21T06:13:15.341545600Z"
    }
   },
   "cell_type": "code",
   "source": [
    "gemischte_liste = [1, 2, \"Hallo\"]\n",
    "gemischte_liste = gemischte_liste + [42,11] + [\"Welt\"]\n",
    "print(gemischte_liste)"
   ],
   "id": "1ff96f79b951be2e",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 'Hallo', 42, 11, 'Welt']\n"
     ]
    }
   ],
   "execution_count": 12
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Python-Listen können Werte unterschiedlicher Datentypen enthalten.\n",
    "\n",
    "Listen können mit dem Plus-Operator verkettet werden."
   ],
   "id": "fd77e135cd1304f3"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 16. Mehrdimensionale Listen",
   "id": "7cb07d5cb6ac9ef1"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:15.460875100Z",
     "start_time": "2026-07-21T06:13:15.392132200Z"
    }
   },
   "cell_type": "code",
   "source": [
    "mehrdimensional = [[1, 2, 3, 4], [11, 12, 13]]\n",
    "print(mehrdimensional[1][2])"
   ],
   "id": "984517dcc87e291a",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n"
     ]
    }
   ],
   "execution_count": 13
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Eine Liste kann wiederum Listen enthalten.\n",
    "\n",
    "Dadurch entstehen mehrdimensionale Strukturen.\n",
    "\n",
    "    mehrdimensional[1][2]\n",
    "\n",
    "Dieser Zugriff bedeutet:\n",
    "\n",
    "- zuerst die Liste an Index 1 auswählen\n",
    "- darin das Element an Index 2 auswählen"
   ],
   "id": "d3d679aef2648f21"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 17. Strings und Indexzugriff",
   "id": "e84c3a348e3b7f7c"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:15.633856400Z",
     "start_time": "2026-07-21T06:13:15.462875200Z"
    }
   },
   "cell_type": "code",
   "source": [
    "name = \"Nina\"\n",
    "print(name[0]) # Gibt erstes Zeichen des Strings zurück"
   ],
   "id": "5a68a838ea1320b7",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N\n"
     ]
    }
   ],
   "execution_count": 14
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Strings verhalten sich ähnlich wie Listen.\n",
    "\n",
    "Auf einzelne Zeichen kann mit einem Index zugegriffen werden."
   ],
   "id": "161f0501e11ee16a"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 18. Strings mit join verbinden",
   "id": "c22801da27ee039b"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:15.711819700Z",
     "start_time": "2026-07-21T06:13:15.637368700Z"
    }
   },
   "cell_type": "code",
   "source": [
    "strings = [\"Hallo\", \"Welt\", \"!\"]\n",
    "\n",
    "print(strings)\n",
    "print(\"-\".join(strings))"
   ],
   "id": "be7fab7b41f1f7c6",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hallo', 'Welt', '!']\n",
      "Hallo-Welt-!\n"
     ]
    }
   ],
   "execution_count": 15
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Mit join() können Werte einer String-Liste zu einem einzigen String verbunden werden.\n",
    "\n",
    "Das \"-\" gibt den Trenner an."
   ],
   "id": "d2f1169ff3c482fb"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "## 19. Das __name__-Konzept\n",
    "\n",
    "    print(__name__)\n",
    "\n",
    "Top-Level-Code befindet sich in der __main__-Umgebung.\n",
    "\n",
    "Auch wenn Python keine Main-Methode wie Java oder C# benötigt, befindet sich direkt ausgeführter Code trotzdem in einer Art Hauptumgebung.\n",
    "\n",
    "Weitere Informationen:\n",
    "https://docs.python.org/3/library/__main__.html"
   ],
   "id": "9badbc23f4ab667a"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 20. If-Else",
   "id": "2f5aabe6e3fefc6d"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:15.837611800Z",
     "start_time": "2026-07-21T06:13:15.715324Z"
    }
   },
   "cell_type": "code",
   "source": "zahl = 12",
   "id": "c2265fe429fd7064",
   "outputs": [],
   "execution_count": 16
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:15.926123100Z",
     "start_time": "2026-07-21T06:13:15.841611200Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Falls in 'zahl' aktuell kein int gespeichert ist, wird ein neuer Wert vergeben\n",
    "if type(zahl) is not int:\n",
    "    zahl = 6\n",
    "\n",
    "if zahl < 10:\n",
    "    print(\"zahl ist kleiner 10\")\n",
    "    if zahl == 5:\n",
    "        print(\"zahl ist genau 5\")\n",
    "    else:\n",
    "        print(\"zahl ist nicht genau 5\")\n",
    "else:\n",
    "    print(\"zahl ist nicht kleiner 10\")\n",
    "\n",
    "print(\"Hier ist die if-Abfrage zu Ende\")"
   ],
   "id": "15cae027a5b4063f",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "zahl ist nicht kleiner 10\n",
      "Hier ist die if-Abfrage zu Ende\n"
     ]
    }
   ],
   "execution_count": 17
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Wichtige Punkte:\n",
    "\n",
    "- nach der Bedingung steht ein Doppelpunkt\n",
    "- der eingerückte Block gehört zur Bedingung\n",
    "- verschachtelte Bedingungen benötigen weitere Einrückung\n",
    "\n",
    "Python verwendet keine geschweiften Klammern. Deshalb ist die Einrückung besonders wichtig."
   ],
   "id": "54037d467d958b7a"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 21. Logische Verknüpfungen",
   "id": "2b2e2bc33786192c"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:16.099805700Z",
     "start_time": "2026-07-21T06:13:15.933146700Z"
    }
   },
   "cell_type": "code",
   "source": [
    "if zahl < 20 and not zahl % 2 == 0:\n",
    "    print(\"kleiner 20 und ungerade\")\n",
    "else:\n",
    "    print(\"nicht kleiner 20 oder gerade\")"
   ],
   "id": "568308b791d85d6c",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nicht kleiner 20 oder gerade\n"
     ]
    }
   ],
   "execution_count": 18
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Logische Verknüpfungen werden in Python mit Wörtern geschrieben:\n",
    "\n",
    "- and für logisches UND\n",
    "- or für logisches ODER\n",
    "- not für Negation\n",
    "\n",
    "Der Ausdruck zahl % 2 == 0 prüft, ob eine Zahl gerade ist.\n",
    "\n",
    "Der Modulo-Operator % liefert den Rest einer Division."
   ],
   "id": "7d4d31d565bfdeee"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 22. For-Schleife",
   "id": "30ddd6bce3a717e7"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:16.223568300Z",
     "start_time": "2026-07-21T06:13:16.105314100Z"
    }
   },
   "cell_type": "code",
   "source": [
    "for z in zahlen_liste:\n",
    "    print(z)"
   ],
   "id": "2e879c9fe7ed942c",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "execution_count": 19
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Die For-Schleife in Python entspricht eher einer ForEach-Schleife.\n",
    "\n",
    "Sie durchläuft direkt die Elemente einer Liste.\n",
    "\n",
    "Jedes print() erzeugt standardmäßig einen Zeilenumbruch."
   ],
   "id": "56e26da3e5f7f2df"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 23. range()",
   "id": "b5134def134a18c"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:16.302482300Z",
     "start_time": "2026-07-21T06:13:16.231592900Z"
    }
   },
   "cell_type": "code",
   "source": [
    "for i in range(10): # Range ist immer exklusiv\n",
    "    print(i, end=' ')"
   ],
   "id": "a311bbabd55ec61",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 6 7 8 9 "
     ]
    }
   ],
   "execution_count": 20
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "range(10) erzeugt Werte von 0 bis exklusiv 10.\n",
    "\n",
    "Mit end=' ' wird verhindert, dass print() einen Zeilenumbruch erzeugt. Stattdessen wird ein Leerzeichen ausgegeben."
   ],
   "id": "6767953e03344f3e"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 24. range() mit Start, Ende und Schrittweite",
   "id": "b0f175cc32cd623a"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:16.365728400Z",
     "start_time": "2026-07-21T06:13:16.304480600Z"
    }
   },
   "cell_type": "code",
   "source": [
    "for i in range(5, 15, 2):\n",
    "    print(i, end=' ')"
   ],
   "id": "a863103671cecea5",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 7 9 11 13 "
     ]
    }
   ],
   "execution_count": 21
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "range(5, 15, 2) bedeutet:\n",
    "\n",
    "- Start bei 5\n",
    "- Ende vor 15\n",
    "- Schrittweite 2"
   ],
   "id": "1e7c3f28a690163a"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 25. If-Elif-Else in einer Schleife",
   "id": "4ad498445e2206f7"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:16.412962300Z",
     "start_time": "2026-07-21T06:13:16.367742300Z"
    }
   },
   "cell_type": "code",
   "source": [
    "for z in zahlen_liste:\n",
    "    if z > 3:\n",
    "        print(str(z) + \" ist größer 3\")\n",
    "    elif z == 3:\n",
    "        print(str(z) + \" ist genau 3\")\n",
    "    else:\n",
    "        print(str(z) + \" ist kleiner 3\")"
   ],
   "id": "9b7751c65aaf3da0",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 ist kleiner 3\n",
      "3 ist genau 3\n",
      "4 ist größer 3\n",
      "5 ist größer 3\n"
     ]
    }
   ],
   "execution_count": 22
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "elif steht für else if.\n",
    "\n",
    "Damit können mehrere Bedingungen nacheinander geprüft werden."
   ],
   "id": "d3db1dfdda25b59b"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "## 26. Schleifen mit else\n",
    "Schleifen in Python können auch ein else besitzen.\n",
    "\n",
    "Das else wird ausgeführt, wenn die Schleife erfolgreich bis zum Schluss gelaufen ist.\n",
    "\n",
    "Anders formuliert:\n",
    "\n",
    "Das else wird ausgeführt, wenn die Schleifenbedingung als False ausgewertet wird und die Schleife nicht vorher durch break beendet wurde."
   ],
   "id": "ddbc6cd920733505"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 27. While-Schleife",
   "id": "c05e73a22dc0f18c"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:16.473940600Z",
     "start_time": "2026-07-21T06:13:16.422494500Z"
    }
   },
   "cell_type": "code",
   "source": [
    "print(\"Solange zahl > 0\")\n",
    "\n",
    "zahl = 10\n",
    "\n",
    "while zahl > 0:\n",
    "    zahl = zahl - 1\n",
    "else:\n",
    "    print(\"Schleife beendet\")"
   ],
   "id": "994490cd6f8649f7",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Solange zahl > 0\n",
      "Schleife beendet\n"
     ]
    }
   ],
   "execution_count": 23
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Die While-Schleife läuft, solange die Bedingung True ergibt.\n",
    "\n",
    "In jedem Durchlauf wird zahl um 1 reduziert.\n",
    "\n",
    "Wenn zahl nicht mehr größer als 0 ist, endet die Schleife.\n",
    "\n",
    "Auch hier kann ein else-Block verwendet werden."
   ],
   "id": "5a8e889e1b9deaac"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 28. Zufallszahlen",
   "id": "23f50b9bc77fbd81"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:16.554611700Z",
     "start_time": "2026-07-21T06:13:16.480480400Z"
    }
   },
   "cell_type": "code",
   "source": "print(\"Zufallszahl:\", random.randrange(10))",
   "id": "53dbf3af15783420",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Zufallszahl: 1\n"
     ]
    }
   ],
   "execution_count": 24
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "random.randrange(10) erzeugt eine Zufallszahl von 0 bis exklusiv 10.\n",
    "\n",
    "Dafür wurde am Anfang das Modul random importiert."
   ],
   "id": "76620b7e70c2fc0e"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 29. Eingabe",
   "id": "6f7380c1c6932707"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:23.884532300Z",
     "start_time": "2026-07-21T06:13:16.559138700Z"
    }
   },
   "cell_type": "code",
   "source": [
    "eingabe = input(\"Zahl eingeben: \")\n",
    "print(eingabe)\n",
    "print(type(eingabe))"
   ],
   "id": "15339228a73e2170",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "execution_count": 25
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Mit input() kann eine Eingabe von der Konsole eingelesen werden.\n",
    "\n",
    "Wichtig:\n",
    "\n",
    "input() liefert immer einen String zurück.\n",
    "\n",
    "Auch wenn eine Zahl eingegeben wird, ist der Datentyp zunächst str."
   ],
   "id": "d8a377ecfd0b0c4b"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 30. Konvertieren",
   "id": "28ede91f40754b67"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:28.564360Z",
     "start_time": "2026-07-21T06:13:24.029666400Z"
    }
   },
   "cell_type": "code",
   "source": [
    "eingabe = input(\"Float eingeben: \")\n",
    "eingabe = float(eingabe)\n",
    "print(eingabe + 5)\n",
    "print(type(eingabe))"
   ],
   "id": "5a60e13be16fdadd",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9.2\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "execution_count": 26
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Mit float() wird die Eingabe in eine Kommazahl umgewandelt.\n",
    "\n",
    "Danach ist der Datentyp float."
   ],
   "id": "535aaf9b29ecfb98"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 31. Exceptions",
   "id": "79b6e3c2f467ed35"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:32.866171900Z",
     "start_time": "2026-07-21T06:13:29.599087800Z"
    }
   },
   "cell_type": "code",
   "source": [
    "try:\n",
    "    eingabe = int(input(\"Binäre Zahl eingeben: \"), 2)\n",
    "    print(eingabe)\n",
    "except Exception as e:\n",
    "    print(\"Fehler!\", e)\n",
    "finally:\n",
    "    print(\"Finally\")"
   ],
   "id": "2d7c52f51f992b76",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "Finally\n"
     ]
    }
   ],
   "execution_count": 27
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Mit try und except können Fehler behandelt werden.\n",
    "\n",
    "In diesem Beispiel wird eine binäre Zahl eingelesen.\n",
    "\n",
    "Die 2 bei int(..., 2) bedeutet:\n",
    "\n",
    "- die Eingabe wird als Zahl im Binärsystem interpretiert\n",
    "\n",
    "Wenn ein Fehler auftritt, wird der except-Block ausgeführt.\n",
    "\n",
    "Der finally-Block wird immer ausgeführt."
   ],
   "id": "6e4f8e4bf787f3f0"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 32. Funktionen",
   "id": "bb239c6b53d9734"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:32.918723Z",
     "start_time": "2026-07-21T06:13:32.883916800Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def addieren(a:int, b:int) -> int:\n",
    "    summe = a + b\n",
    "    return summe"
   ],
   "id": "a14c13b9ea46bce7",
   "outputs": [],
   "execution_count": 28
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Funktionen werden in Python mit def definiert.\n",
    "\n",
    "Die Angaben a:int, b:int und -> int sind Typ-Annotationen.\n",
    "\n",
    "Sie zeigen an, welche Typen erwartet werden, erzwingen diese aber nicht automatisch zur Laufzeit."
   ],
   "id": "5d957808720ffcb5"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:32.955679200Z",
     "start_time": "2026-07-21T06:13:32.924724300Z"
    }
   },
   "cell_type": "code",
   "source": [
    "erg = addieren(40, 2)\n",
    "print(erg)"
   ],
   "id": "36feda6e4105b89b",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n"
     ]
    }
   ],
   "execution_count": 29
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Hier wird die Funktion aufgerufen und das Ergebnis gespeichert.",
   "id": "647848e2e9a695e"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 33. Klassen",
   "id": "d4fd88a944cbf8bf"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:32.993153400Z",
     "start_time": "2026-07-21T06:13:32.970747700Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class MyClass:\n",
    "    text = \"Hello World\"  # Öffentliches Klassen-Attribut\n",
    "\n",
    "    def __init__(self, wert):  # Konstruktor\n",
    "        self.zahl = wert  # Öffentliches Instanz-Attribut deklariert und 'wert' zugewiesen\n",
    "        self.__zahl_private = 42  # Privates Feld (zwei _ davor)\n",
    "        # https://www.geeksforgeeks.org/private-variables-python/\n",
    "\n",
    "    # Instanz-Methoden in Klassen müssen als ersten Parameter 'self' haben, was 'this' in Java und C# entspricht.\n",
    "    # mit 'self' kann auf die Member zugegriffen werden\n",
    "    def get_zahl_private(self):\n",
    "        return self.__zahl_private\n",
    "\n",
    "    def set_zahl_private(self, wert):\n",
    "        self.__zahl_private = wert"
   ],
   "id": "15dee2bd9a671fc0",
   "outputs": [],
   "execution_count": 30
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "text ist ein öffentliches Klassenattribut.\n",
    "\n",
    "Es gehört zur Klasse MyClass."
   ],
   "id": "5ef883f7f9c447f3"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "## 34. Konstruktor in einer Klasse\n",
    "__init__ ist der Initialisierer der Klasse.\n",
    "\n",
    "self.zahl ist ein öffentliches Instanzattribut.\n",
    "\n",
    "self.__zahl_private ist ein privates Feld.\n",
    "\n",
    "Zwei Unterstriche vor dem Namen erschweren den direkten Zugriff von außen.\n",
    "\n",
    "Weitere Informationen:\n",
    "https://www.geeksforgeeks.org/private-variables-python/"
   ],
   "id": "5ae09f40abe0012f"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "## 35. Instanzmethoden und self\n",
    "Instanzmethoden in Klassen müssen als ersten Parameter self haben.\n",
    "\n",
    "self entspricht this in Java und C#.\n",
    "\n",
    "Mit self kann auf die Member des Objekts zugegriffen werden."
   ],
   "id": "78e5c5d2f39d95db"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "## 36. Objekte verwenden\n",
    "\n",
    "    print(MyClass.text)"
   ],
   "id": "bbff1f6eeb4e677f"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:33.054233600Z",
     "start_time": "2026-07-21T06:13:32.998681Z"
    }
   },
   "cell_type": "code",
   "source": "print(MyClass.text)",
   "id": "6a9fc37a928f6658",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "execution_count": 31
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Hier wird auf das Klassenattribut zugegriffen.",
   "id": "9c2a50c7e46bfb88"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:33.087704800Z",
     "start_time": "2026-07-21T06:13:33.062760100Z"
    }
   },
   "cell_type": "code",
   "source": "my_class_object = MyClass(42)",
   "id": "22b2baf371403c31",
   "outputs": [],
   "execution_count": 32
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Hier wird ein Objekt der Klasse MyClass erzeugt.",
   "id": "917932057d2f1033"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:33.143033Z",
     "start_time": "2026-07-21T06:13:33.093703600Z"
    }
   },
   "cell_type": "code",
   "source": "print(my_class_object.zahl)",
   "id": "251ccbfc000216fa",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n"
     ]
    }
   ],
   "execution_count": 33
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Das öffentliche Instanzattribut wird ausgegeben.",
   "id": "bff2ef249e581ce5"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-07-21T06:13:33.225877100Z",
     "start_time": "2026-07-21T06:13:33.150556800Z"
    }
   },
   "cell_type": "code",
   "source": [
    "my_class_object.set_zahl_private(100)\n",
    "print(my_class_object.get_zahl_private())"
   ],
   "id": "fadee0dae3a223c0",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n"
     ]
    }
   ],
   "execution_count": 34
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Das private Attribut wird über Setter und Getter verändert und ausgegeben.",
   "id": "afaf81a7c2430535"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "## Zusammenfassung\n",
    "\n",
    "- Python ist eine interpretierte Sprache\n",
    "- Python ist dynamisch typisiert\n",
    "- Einrückungen bestimmen Codeblöcke\n",
    "- Variablen können ihren Datentyp ändern\n",
    "- Listen können mehrere Werte speichern\n",
    "- Strings können ähnlich wie Listen verwendet werden\n",
    "- input() liefert immer einen String\n",
    "- Funktionen werden mit def definiert\n",
    "- Klassen verwenden self für den Zugriff auf Objektmember\n",
    "- private Attribute können mit zwei Unterstrichen markiert werden"
   ],
   "id": "2256ac3098e2d030"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "## Verständnisfragen\n",
    "\n",
    "- Was ist der Unterschied zwischen Compiler und Interpreter?\n",
    "- Warum ist die Einrückung in Python so wichtig?\n",
    "- Was bedeutet dynamisch typisiert?\n",
    "- Wie funktioniert eine For-Schleife mit range()?\n",
    "- Was ist der Zweck von try und except?"
   ],
   "id": "8260234398eac5c2"
  }
 ],
 "metadata": {},
 "nbformat": 4,
 "nbformat_minor": 5
}