From 68ab58d4a5a4ef12892d5e89bc3adb55410b23bd Mon Sep 17 00:00:00 2001 From: Max Date: Mon, 20 Jul 2026 12:51:12 +0200 Subject: [PATCH] First Commit --- .idea/.gitignore | 10 + .idea/misc.xml | 10 + .idea/modules.xml | 8 + .idea/vcs.xml | 6 + grundlagen/aufgaben.ipynb | 358 ++++++++ grundlagen/grundlagen.ipynb | 1591 +++++++++++++++++++++++++++++++++++ grundlagen/grundlagen.py | 1 + wbs-python.iml | 11 + 8 files changed, 1995 insertions(+) create mode 100644 .idea/.gitignore create mode 100644 .idea/misc.xml create mode 100644 .idea/modules.xml create mode 100644 .idea/vcs.xml create mode 100644 grundlagen/aufgaben.ipynb create mode 100644 grundlagen/grundlagen.ipynb create mode 100644 grundlagen/grundlagen.py create mode 100644 wbs-python.iml diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..30cf57e --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,10 @@ +# Default ignored files +/shelf/ +/workspace.xml +# Editor-based HTTP Client requests +/httpRequests/ +# Ignored default folder with query files +/queries/ +# Datasource local storage ignored files +/dataSources/ +/dataSources.local.xml diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..9dcea8a --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,10 @@ + + + + + + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 0000000..25794e2 --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..94a25f7 --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/grundlagen/aufgaben.ipynb b/grundlagen/aufgaben.ipynb new file mode 100644 index 0000000..74e131f --- /dev/null +++ b/grundlagen/aufgaben.ipynb @@ -0,0 +1,358 @@ +{ + "cells": [ + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "# Aufgabe 1\n", + "## Aufgabenstellung\n", + "Schreiben Sie eine Funktion, die die Quersumme einer Zahl berechnet\n", + "- Übergabewert (Parameter): int zahl\n", + "- Rückgabewert: Die berechnete Quersumme\n", + "\n", + "Hinweis: Zur Berechung bietet sch der Modulo Operator (%) an" + ], + "id": "87831b5e03132f2e" + }, + { + "metadata": { + "collapsed": true + }, + "cell_type": "code", + "source": [ + "def quersumme(zahl: int) -> int:\n", + " quersumme = 0\n", + " while zahl > 0:\n", + " quersumme = quersumme + (zahl % 10)\n", + " zahl = zahl // 10\n", + " return quersumme" + ], + "id": "22ff5a3be651c92c", + "outputs": [], + "execution_count": null + }, + { + "metadata": {}, + "cell_type": "code", + "source": "quersumme(123456)", + "id": "7199cdd91e59145e", + "outputs": [], + "execution_count": null + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "# Aufgabe 2\n", + "## Aufgabenstellung\n", + "Schreiben Sie ein Programm, das Ihnen ausgibt, ob das über die Integer-Variable \"jahr\" eingeführte Jahr ein\n", + "Schaltjahr ist.\n", + "- Durch 4 ohne Rest teilbare Jahre sind normalerweise Schaltjahre\n", + "- Durch 100 ohne Rest teilbare Jahre sind keine Schaltjahre\n", + "- Durch 400 ohne Rest teilbare Jahre sind jedoch Schaltjahre\n", + "Nutzen Sie zu Umsetzung die Boolesche Variable schaltjahr und lassen Sie sich das Jahr, sowie ob es ein Schaltjahr st\n", + " oder nicht, auf der Konsole ausgeben" + ], + "id": "cbff1da5def57156" + }, + { + "metadata": {}, + "cell_type": "code", + "source": [ + "def schaltjahr(jahr:int):\n", + " schaltjahr = False\n", + " if jahr % 4 == 0 and (not jahr % 100 == 0 or jahr % 400 == 0):\n", + " schaltjahr = True\n", + " if schaltjahr:\n", + " print(str(jahr) + \" ist ein Schaltjahr.\")\n", + " else:\n", + " print(str(jahr) + \" ist kein Schaltjahr.\")" + ], + "id": "b306c7fb66b3dd10", + "outputs": [], + "execution_count": null + }, + { + "metadata": {}, + "cell_type": "code", + "source": "schaltjahr(2000)", + "id": "5664a9baea24f5c6", + "outputs": [], + "execution_count": null + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "# Aufgabe 3\n", + "## Aufgabenstellung\n", + "Schreiben Sie ein Programm, das eine Zufallszahl von 1 bis inklusive 99 auswürfelt und den Benutzer in einer Schleife\n", + " über eine Eingabe die Zahl erraten lässt.\n", + "\n", + "Dabei wird die eingegebene Zahl in einen Integer geparst. Bei falscher Eingabe soll wiederholt werden.\n", + "\n", + "Dat Programm teilt nun dem Benutzer mit, ob die Schätzung kleiner oder größer als die gewürfelte Zahl war.\n", + "\n", + "Die Schleife endet, wenn die gewürfte Zahl getroffen wurde. Dem Benutzer wird die Anzahl der Versuche ausgegeben." + ], + "id": "6c4934d6e12ce2a6" + }, + { + "metadata": {}, + "cell_type": "code", + "source": [ + "import random\n", + "\n", + "anzahl_versuche = 0\n", + "zufallszahl = 1 + random.randrange(99)\n", + "geratene_zahl = 0\n", + "while not geratene_zahl == zufallszahl:\n", + " geratene_zahl = int(input(\"Geben Sie eine Zahl zwischen 1 und 99 ein.\"))\n", + " print(\"Geraten: \" + str(geratene_zahl))\n", + " if geratene_zahl > zufallszahl:\n", + " print(\"Die gesuchte Zahl ist kleiner als die geratene.\")\n", + " if geratene_zahl < zufallszahl:\n", + " print(\"Die gesuchte Zahl ist größer als die geratene.\")\n", + " anzahl_versuche += 1\n", + "else:\n", + " print(\"Richtig geraten!\")\n", + " print(\"Anzahl Versuche: \" + str(anzahl_versuche))\n" + ], + "id": "766664c110d382a8", + "outputs": [], + "execution_count": null + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "# Aufgabe 4\n", + "## Aufgabenstellung\n", + "In Ihrem Unternehmen werden neue Artikelnummern vergeben. Sie bestehen aus fünf Ziffern und zusätzlich einer Prüfziffer.\n", + "\n", + "Sie sollen ein Programm entwefen, dass eine fünfstellige Zahl einliest, daraus die Prüfziffer errechnet und diese auf\n", + "der Konsole ausgibt.\n", + "\n", + "Wie Sie mit Fehleingaben umgehen, bleibt Ihnen überlassen.\n", + "\n", + "Folgende Informationen erhalten Sie für die Berechnung der Prüfziffer:\n", + "- die geraden Zahlen werden addiert, die ungeraden Zahlen werden mit 3 multipliziert und anschließend addiert\n", + "- die Prüfzimmer ergibt sich aus der letzten Stelle der resultierenden Summe\n", + "\n", + "Beispiel: 27493 -> 2 + 3 * 7 + 4 + 3 * 9 + 3 * 3 = 63 -> Prüfzimmer 3 -> Artikelnummer 27493-3" + ], + "id": "68ba83034f1504ad" + }, + { + "metadata": {}, + "cell_type": "code", + "source": [ + "def artikelnummer_bestimmen(zahl:int) -> str:\n", + " if type(zahl) is not int or len(str(zahl)) != 5:\n", + " return \"Die Eingabe muss eine fünfstellige Zahl sein\"\n", + " artikelnummer = str(zahl) + \"-\"\n", + " pruefziffer = 0\n", + " while zahl > 0:\n", + " next = zahl % 10\n", + " if (next % 2 == 1):\n", + " next *= 3\n", + " pruefziffer += next\n", + " zahl = zahl // 10\n", + " return artikelnummer + str(pruefziffer%10)" + ], + "id": "c9202f56044a9e52", + "outputs": [], + "execution_count": null + }, + { + "metadata": {}, + "cell_type": "code", + "source": [ + "print(artikelnummer_bestimmen(27493))\n", + "print(artikelnummer_bestimmen(123456))\n", + "print(artikelnummer_bestimmen(\"hallo\"))" + ], + "id": "9b251562c7cd189b", + "outputs": [], + "execution_count": null + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "# Aufgabe 5\n", + "## Aufgabenstellung\n", + "Schreiben Sie bitte folgende Funktion:\n", + "```\n", + "Funktionsname: fill_dice_array\n", + "Übergabewerte: 1 Liste 'arr'\n", + " 2 Integer 'min' und 'max'\n", + " 1 Integer 'n'\n", + "Funktion: Die Funktion füllt die Liste arr mit 'n' Zufallszahlen zwischen (beiderseits einschließlich) min und max\n", + "Rückgabewert: keiner\n", + "```\n", + "\n", + "Verwenden Sie bitte die obige Funktion in folgendem Python-Programm - für dieses Programm soll gelten:\n", + "- Das Programm startet eine Schleife, pro Durchlauf\n", + " - wird eine Lsite mit 5 Zufalls-Würfelzahlen gefüllt\n", + " - wird die gefüllte Liste (numerisch) sortiert\n", + " - wird geprüft, ob es sich um eine \"große Straße\" handelt (1,2,3,4,5) oder (2,3,4,5,6)\n", + "- Die Schleife endet, falls eine \"große Straße\" gewürfelt wurde\n", + "- Das Programm endet mit der Anzahl der Schleifen-Durchläufe, die nötig waren, um die \"große Straße\" zu erreichen" + ], + "id": "c86f19ff812e866c" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-07-20T10:46:31.733352413Z", + "start_time": "2026-07-20T10:46:31.623436116Z" + } + }, + "cell_type": "code", + "source": [ + "import random\n", + "\n", + "def fill_dice_array(min:int, max:int, n:int):\n", + " arr = []\n", + " for i in range(n):\n", + " arr = arr + [random.randrange(1+max-min) + min]\n", + " return arr\n", + "\n", + "def ist_grosse_Strasse(arr:list[int]):\n", + " for i in range (len(arr)-1):\n", + " if arr[i]+1 != arr[i+1]:\n", + " return False\n", + " else:\n", + " return True\n", + "\n", + "anzahl = 1\n", + "while True:\n", + " arr = fill_dice_array(1, 6, 5)\n", + " arr.sort()\n", + " if ist_grosse_Strasse(arr):\n", + " break\n", + " anzahl += 1\n", + "\n", + "print(\"Große Straße: \", arr)\n", + "print(\"Benötigte Versuche: \", anzahl)" + ], + "id": "bae8089b2089e3c6", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Große Straße: [1, 2, 3, 4, 5]\n", + "Benötigte Versuche: 13\n" + ] + } + ], + "execution_count": 78 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "## Musterlösung", + "id": "79d5c499b765c033" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-07-20T10:46:22.707482868Z", + "start_time": "2026-07-20T10:46:22.563191355Z" + } + }, + "cell_type": "code", + "source": [ + "from random import randrange\n", + "\n", + "\n", + "def fill_dice_array(arr:list[int], min:int, max:int, n:int)->None:\n", + "\n", + " for i in range(n):\n", + " arr.append(randrange(min, max+1))\n", + "\n", + "\n", + "def is_large_straight(arr):\n", + " for i in range(len(arr)-1):\n", + " if arr[i+1]-arr[i] != 1:\n", + " return False\n", + " return True\n", + "\n", + "\n", + "def main():\n", + " count = 0\n", + " run = True\n", + " while run:\n", + " count = count + 1\n", + " arr = []\n", + " fill_dice_array(arr, 1, 6, 5)\n", + " arr.sort()\n", + " print(arr)\n", + " run = not is_large_straight(arr)\n", + "\n", + " print(\"Benötigte Durchläufe: \", count)\n", + "\n", + "\n", + "if __name__ == \"__main__\":\n", + " main()" + ], + "id": "6a4aa9c742c3cc74", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2, 3, 3, 4, 5]\n", + "[1, 1, 3, 3, 6]\n", + "[2, 4, 4, 4, 6]\n", + "[2, 3, 4, 5, 5]\n", + "[1, 2, 2, 4, 4]\n", + "[1, 1, 3, 3, 6]\n", + "[2, 2, 3, 3, 4]\n", + "[1, 2, 2, 4, 6]\n", + "[1, 3, 4, 5, 6]\n", + "[1, 2, 4, 5, 5]\n", + "[2, 3, 3, 3, 5]\n", + "[1, 2, 4, 5, 6]\n", + "[2, 2, 4, 4, 6]\n", + "[1, 3, 3, 5, 5]\n", + "[1, 1, 1, 4, 6]\n", + "[1, 3, 4, 4, 5]\n", + "[1, 2, 2, 4, 4]\n", + "[2, 4, 4, 4, 6]\n", + "[1, 1, 2, 3, 4]\n", + "[1, 2, 3, 4, 4]\n", + "[2, 2, 3, 4, 5]\n", + "[1, 4, 4, 5, 6]\n", + "[2, 3, 4, 5, 6]\n", + "Benötigte Durchläufe: 23\n" + ] + } + ], + "execution_count": 73 + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/grundlagen/grundlagen.ipynb b/grundlagen/grundlagen.ipynb new file mode 100644 index 0000000..6fea50d --- /dev/null +++ b/grundlagen/grundlagen.ipynb @@ -0,0 +1,1591 @@ +{ + "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-20T09:11:10.948463746Z", + "start_time": "2026-07-20T09:11:10.798957171Z" + } + }, + "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-20T09:11:11.032980920Z", + "start_time": "2026-07-20T09:11:11.003974369Z" + } + }, + "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-20T09:11:11.195935177Z", + "start_time": "2026-07-20T09:11:11.082523115Z" + } + }, + "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-20T09:11:11.310496241Z", + "start_time": "2026-07-20T09:11:11.205075294Z" + } + }, + "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-20T09:11:11.397864886Z", + "start_time": "2026-07-20T09:11:11.319361085Z" + } + }, + "cell_type": "code", + "source": [ + "zahl = 20\n", + "print(type(zahl))" + ], + "id": "3e2af284c19c419e", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\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-20T09:11:11.459974422Z", + "start_time": "2026-07-20T09:11:11.403819607Z" + } + }, + "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": [ + "\n", + "Hallo!\n", + "\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-20T09:11:11.605083552Z", + "start_time": "2026-07-20T09:11:11.484140897Z" + } + }, + "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-20T09:11:11.761983339Z", + "start_time": "2026-07-20T09:11:11.646254720Z" + } + }, + "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", + "\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-20T09:11:11.829494366Z", + "start_time": "2026-07-20T09:11:11.767570462Z" + } + }, + "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-20T09:11:11.916345399Z", + "start_time": "2026-07-20T09:11:11.844536855Z" + } + }, + "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-20T09:11:12.008499356Z", + "start_time": "2026-07-20T09:11:11.934968664Z" + } + }, + "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-20T09:11:12.068358351Z", + "start_time": "2026-07-20T09:11:12.015675726Z" + } + }, + "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-20T09:11:12.245361692Z", + "start_time": "2026-07-20T09:11:12.109162042Z" + } + }, + "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-20T09:11:12.313827542Z", + "start_time": "2026-07-20T09:11:12.255914921Z" + } + }, + "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-20T09:11:12.373300996Z", + "start_time": "2026-07-20T09:11:12.324674759Z" + } + }, + "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-20T09:11:12.449764043Z", + "start_time": "2026-07-20T09:11:12.427649843Z" + } + }, + "cell_type": "code", + "source": "zahl = 12", + "id": "c2265fe429fd7064", + "outputs": [], + "execution_count": 16 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-07-20T09:11:12.506076267Z", + "start_time": "2026-07-20T09:11:12.454526702Z" + } + }, + "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-20T09:11:12.592221220Z", + "start_time": "2026-07-20T09:11:12.520718035Z" + } + }, + "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-20T09:11:12.674764076Z", + "start_time": "2026-07-20T09:11:12.600125491Z" + } + }, + "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-20T09:11:12.746370667Z", + "start_time": "2026-07-20T09:11:12.697105467Z" + } + }, + "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-20T09:11:12.882254618Z", + "start_time": "2026-07-20T09:11:12.762663699Z" + } + }, + "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-20T09:11:13.054408375Z", + "start_time": "2026-07-20T09:11:12.911517866Z" + } + }, + "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-20T09:11:13.111375983Z", + "start_time": "2026-07-20T09:11:13.061237827Z" + } + }, + "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-20T09:11:13.276421329Z", + "start_time": "2026-07-20T09:11:13.163026489Z" + } + }, + "cell_type": "code", + "source": "print(\"Zufallszahl:\", random.randrange(10))", + "id": "53dbf3af15783420", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Zufallszahl: 0\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-20T09:11:18.677171837Z", + "start_time": "2026-07-20T09:11:13.317399300Z" + } + }, + "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", + "\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-20T09:11:24.757618711Z", + "start_time": "2026-07-20T09:11:18.760922485Z" + } + }, + "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.23\n", + "\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-20T09:11:31.574692560Z", + "start_time": "2026-07-20T09:11:24.801573722Z" + } + }, + "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": [ + "63\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-20T09:11:31.651516271Z", + "start_time": "2026-07-20T09:11:31.625196270Z" + } + }, + "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-20T09:11:31.727355043Z", + "start_time": "2026-07-20T09:11:31.662888064Z" + } + }, + "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-20T09:25:42.800135258Z", + "start_time": "2026-07-20T09:25:42.773091026Z" + } + }, + "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": 31 + }, + { + "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-20T09:25:51.695400822Z", + "start_time": "2026-07-20T09:25:51.576870819Z" + } + }, + "cell_type": "code", + "source": "print(MyClass.text)", + "id": "6a9fc37a928f6658", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello World\n" + ] + } + ], + "execution_count": 32 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Hier wird auf das Klassenattribut zugegriffen.", + "id": "9c2a50c7e46bfb88" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-07-20T09:25:54.131456288Z", + "start_time": "2026-07-20T09:25:54.061832506Z" + } + }, + "cell_type": "code", + "source": "my_class_object = MyClass(42)", + "id": "22b2baf371403c31", + "outputs": [], + "execution_count": 33 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Hier wird ein Objekt der Klasse MyClass erzeugt.", + "id": "917932057d2f1033" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-07-20T09:25:57.363875773Z", + "start_time": "2026-07-20T09:25:57.191674396Z" + } + }, + "cell_type": "code", + "source": "print(my_class_object.zahl)", + "id": "251ccbfc000216fa", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "42\n" + ] + } + ], + "execution_count": 34 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Das öffentliche Instanzattribut wird ausgegeben.", + "id": "bff2ef249e581ce5" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-07-20T09:27:25.645524609Z", + "start_time": "2026-07-20T09:27:25.493228622Z" + } + }, + "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": 36 + }, + { + "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 +} diff --git a/grundlagen/grundlagen.py b/grundlagen/grundlagen.py new file mode 100644 index 0000000..d3e46f2 --- /dev/null +++ b/grundlagen/grundlagen.py @@ -0,0 +1 @@ +print('Hello World') \ No newline at end of file diff --git a/wbs-python.iml b/wbs-python.iml new file mode 100644 index 0000000..df7beba --- /dev/null +++ b/wbs-python.iml @@ -0,0 +1,11 @@ + + + + + + + + + + + \ No newline at end of file