max/wbs-python
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Unterricht Mittwoch

Browse Source
This commit is contained in:
Max
2026-07-22 12:04:02 +02:00
parent 33a5c4df89
commit 6a29bc0f51
13 changed files with 915 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files
python/aufgaben_tag1.ipynb
+358
View File
@@ -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
}
python/aufgaben_tag2.ipynb
+490
View File
@@ -0,0 +1,490 @@
{
"cells": [
{
"metadata": {},
"cell_type": "markdown",
"source": [
"# Aufgabe 1\n",
"## Aufgabenstellung\n",
"Erstellen Sie die Klasse \"Song\" mit den Attributen string \"titel\", int \"dauer_sekunden\", string \"interpret\" und der Methode \"Spielen\", die auf der Konsole alle Informationen über den Song ausgibt (die Dauer dabei in Minuten:Sekunden -> 03:35)\n",
"\n",
"- Die Attribute sollen private sein mit öffentlichen Gettern als Eingeschaft\n",
"- Über einen Konstruktor sollen die Attribute initialisiert werden."
],
"id": "906e4e84eba33aab"
},
{
"cell_type": "code",
"id": "initial_id",
"metadata": {
"collapsed": true
},
"source": [
"class Song:\n",
" def __init__(self, titel:str, dauer_sekunden:int, interpret:str, *args):\n",
" self.__titel = titel\n",
" self.__dauer_sekunden = dauer_sekunden\n",
" self.__interpret = interpret\n",
" super().__init__(*args)\n",
"\n",
" @property\n",
" def titel(self) -> str:\n",
" return self.__titel\n",
"\n",
" @property\n",
" def dauer_sekunden(self) -> int:\n",
" return self.__dauer_sekunden\n",
"\n",
" @property\n",
" def interpret(self) -> str:\n",
" return self.__interpret\n",
"\n",
" def spielen(self) -> None:\n",
" minuten = self.__dauer_sekunden // 60\n",
" restsekunden = self.__dauer_sekunden % 60\n",
"\n",
" print(f\"{self.__titel} von {self.__interpret}, Dauer: {minuten:02d}:{restsekunden:02d} Minuten\")"
],
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Erstellen Sie in der Main einen Song und rufen Sie die Methode auf.",
"id": "91a0f43537a3d9b4"
},
{
"metadata": {},
"cell_type": "code",
"source": [
"song = Song(\"Hallo\", 125, \"Welt\")\n",
"song.spielen()"
],
"id": "648e48c76d987a94",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"# Aufgabe 2\n",
"## Aufgabenstellung\n",
"Sie bauen einen Robot. Erstellen Sie die Klasse Robot mit folgenden Membern:\n",
"\n",
"- Integer \"battery_time\"\n",
"- String \"task\"\n",
"- Methode \"is_battery_time_low\":\n",
" - gibt true zurück, wenn die Laufzeit kleiner 2 ist, sonst false.\n",
"- Methode \"execute_task\":\n",
" - gibt auf dem Bildschirm den Text des Attributs \"aufgabe\" aus, wenn \"is_battery_time_low\" false liefert und reduziert dann die battery_time um 1, sonst soll \"Ich muss aufgeladen werden.\" in der Konsole erscheinen."
],
"id": "236fa9f5181f518d"
},
{
"metadata": {},
"cell_type": "code",
"source": [
"class Robot:\n",
" def __init__(self, battery_time:int, task:str, *args):\n",
" self.__battery_time = battery_time\n",
" self.__task = task\n",
" super().__init__(*args)\n",
"\n",
" def is_battery_time_low(self) -> bool:\n",
" return self.__battery_time < 2\n",
"\n",
" def execute_task(self) -> None:\n",
" if self.is_battery_time_low():\n",
" print(\"Ich muss aufgeladen werden\")\n",
" return\n",
"\n",
" print(self.__task)\n",
" self.__battery_time -= 1"
],
"id": "64c12bd54e52cf60",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"Erstellen Sie in der Main einen Roboter mit der Aufgabe \"Ich reiche Butter.\" und einer Batterielaufzeit von 5.\n",
"\n",
"Lassen Sie ihn fünfmal in einer Schleife Butter reichen."
],
"id": "3f89c8f76710d139"
},
{
"metadata": {},
"cell_type": "code",
"source": [
"robot = Robot(5, \"Ich reiche Butter.\")\n",
"for i in range(5):\n",
" robot.execute_task()"
],
"id": "c2217f3770898f37",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"# Aufgabe 3\n",
"## Aufgabenstellung\n",
"Zwei Klassen:\n",
"- \"Buch\" mit dem Attribut \"titel\" (public get)\n",
"- \"Autor\" mit dem Attribut \"name\" (public get)\n",
"\n",
"jeweils einen Konstruktor, der die Eigenschaften initialisiert.\n",
"\n",
"Implementieren Sie die Assoziation der beiden Klassen und stellen Sie eine bidirektionale Navigierbarkeit her. Dazu\n",
"müssen Sie den Klassen weitere Member hinzufügen. (Gehen Sie davon aus, dass ein Buch mehrere Autoren haben und ein\n",
"Autor mehrere Bücher verfassen kann)"
],
"id": "4c09b6fb40b8d1f9"
},
{
"metadata": {},
"cell_type": "code",
"source": [
"class Author:\n",
" def __init__(self, name, *args):\n",
" self.__name = name\n",
" self.__books = []\n",
" super().__init__(*args)\n",
"\n",
" @property\n",
" def name(self):\n",
" return self.__name\n",
"\n",
" @property\n",
" def books(self):\n",
" return self.__books\n",
"\n",
" @books.setter\n",
" def books(self, books) -> None:\n",
" self.__books = books\n",
"\n",
"\n",
" def __str__(self):\n",
" return \"Name: \" + self.__name"
],
"id": "9dee92e77e3508c9",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "code",
"source": [
"class Book:\n",
" def __init__(self, title: str, authors: list):\n",
" self.__title = title\n",
" self.__authors = authors\n",
"\n",
" a: Author # Typ-Hinweis\n",
" for a in authors:\n",
" a.books.append(self) # Füge allen übergebenen Authors das Book hinzu.\n",
"\n",
" @property\n",
" def title(self):\n",
" return self.__title\n",
"\n",
" @property\n",
" def authors(self):\n",
" return self.__authors\n",
"\n",
" @authors.setter\n",
" def authors(self, authors):\n",
" self.__authors = authors\n",
"\n",
" def __str__(self):\n",
" string = \"Title: \" + self.__title + \"\\n\" + \"Authors: \\n\"\n",
" for a in self.__authors:\n",
" string += str(a) + \"\\n\"\n",
" return string"
],
"id": "4b7aee3b3776c94f",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Testen Sie das Programm im Main.",
"id": "1100bf56fd8decd0"
},
{
"metadata": {},
"cell_type": "code",
"source": [
"a1 = Author(\"Carl Sagan\")\n",
"a2 = Author(\"Jerome Agel\")\n",
"a3 = Author(\"Jonathan Norton Leonard\")\n",
"\n",
"b1 = Book(\"Nachbarn im Kosmos\", [a1, a2])\n",
"b2 = Book(\"Die Planeten\", [a1, a3])\n",
"\n",
"# Ausgabe aller Books der jeweiligen Authors\n",
"for b in a1.books:\n",
" print(b)\n",
"\n",
"for b in a2.books:\n",
" print(b)\n",
"\n",
"for b in a3.books:\n",
" print(b)"
],
"id": "a9a21cf8add5b47a",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"# Aufgabe 4\n",
"## Aufgabenstellung\n",
"Erstellen Sie bitte die Klassen Spellcaster, Sorcerer, Wizard, WildMagicSorcerer und IllusionWizard:\n",
"- Sorcerer und Wizard sind Spellcaster.\n",
"- WildMagicSorcerer ist ein Sorcerer und IllusionWizard ist ein Wizard.\n",
"\n",
"- Alle Spellcaster verfügen über die Methode \"castSpell()\"\n",
"- In Spellcaster gibt die Methode \"Ich kann zaubern.\" aus.\n",
"\n",
"Sorcerer und Wizard überschreiben diese Methode.\n",
"- Sorcerer gibt \"Ich kann zaubern.\" und \"Meine Zauberkraft ist mir angeboren.\" aus.\n",
"- Wizard gibt \"Ich kann zaubern.\" und \"Für meine Zauberkraft musste ich hart arbeiten.\" aus.\n",
"WildMagicSorcerer und IllusionWizard überschreiben und versiegeln(finalize) die Methode.\n",
"- WildMagicSorcerer gibt \"Ich kann zaubern.\", \"Meine Zauberkraft ist mir angeboren.\" und \"Meine Zauber sind unberechenbar.\" aus.\n",
"- IllusionWizard gibt \"Ich kann zaubern.\", \"Für meine Zauberkraft musste ich hart arbeiten.\" und \"Ich habe mich auf\n",
"Illusionszauber spezialisiert.\" aus.\n",
"\n",
"Vermeiden Sie beim Überschreiben der Methode doppelten Code!"
],
"id": "2108e544f058d539"
},
{
"metadata": {},
"cell_type": "code",
"source": [
"class Spellcaster(object):\n",
" def cast_spell(self):\n",
" print(\"Ich kann zaubern.\")\n",
"\n",
"\n",
"class Sorcerer(Spellcaster):\n",
" def cast_spell(self):\n",
" super().cast_spell()\n",
" print(\"Meine Zauberkraft ist mir angeboren.\")\n",
"\n",
"\n",
"class Wizard(Spellcaster):\n",
" def cast_spell(self):\n",
" super().cast_spell()\n",
" print(\"Für meine Zauberkraft musste ich hart arbeiten.\")\n",
"\n",
"\n",
"class WildMagicSorcerer(Sorcerer):\n",
" def cast_spell(self):\n",
" super().cast_spell()\n",
" print(\"Meine Zauber sind unberechenbar.\")\n",
"\n",
"\n",
"class IllusionWizard(Wizard):\n",
" def cast_spell(self):\n",
" super().cast_spell()\n",
" print(\"Ich habe mich auf Illusionszauber spezialisiert.\")"
],
"id": "9f4ca8d209e3898c",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "markdown",
"source": "In der Main erzeugen Sie einen wildMagicSorcerer und einen illusionWizard und rufen für beide die castSpell()-Methode auf.",
"id": "88c78295e6ff733b"
},
{
"metadata": {},
"cell_type": "code",
"source": [
"sorcerer = WildMagicSorcerer()\n",
"wizard = IllusionWizard()\n",
"sorcerer.cast_spell()\n",
"wizard.cast_spell()"
],
"id": "28ce197ac73ed492",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"# Aufgabe 5\n",
"## Aufgabenstellung\n",
"Sie sollen eine Anwendung für einen Shop schreiben. Im Shop gibt es viele Artikel, die mit Id, Bezeichnung, Einkaufspreis, Gewinnsatz und Verkaufspreis gespeichert werden. Der Verkaufspreis wird dabei immer aus Einkaufspreis + Gewinn errechnet.\n",
"\n",
"Artikel, die gekauft werden, werden mit Mengenangabe in einen Warenkorb gelegt. Es sollen Artikel in den Warenkorb gelegt und wieder entfernt werden können. Ebenfalls soll es möglich sein, die Anzahl eines Artikels ändern zu können. Über den Warenkorb wird der Gesamtpreis aller sich dort befindenden Artikel ermittelt.\n",
"\n",
"Artikel im Warenkorb werden dort als Warenkorb-Items eingetragen. Ein Warenkorb-Item besteht aus dem Artikel selbst und der Anzahl. Ebenfalls soll der Gesamtpreis für diesen Artikel abgefragt werden können.\n",
"\n",
"Es ist nicht erforderlich, ein Eingabe-Menü zu basteln. Es reicht, die einzelnen Fälle über Code in der Main zu testen.\n",
"\n",
"Wichtig für diese Übung: Beachten Sie die Prinzipien der OOP. Insbesondere die Klassenbildung und Datenkapselung / Geheimnisprinzip.\n",
"\n",
"Ebenso sollen Sie die strikte Trennung von Funktionalität / Datenhaltung und Darstellung beachten. Heißt: Dort, wo die Daten gespeichert sind und Funktionalitäten liegen, wird KEINE Konsolenausgabe getätigt. Konsolenausgaben nur in dafür vorgesehenen eigenen Klassen oder zum Beispiel in der Main."
],
"id": "dabe541b90e049b1"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## Bearbeitung\n",
"Sie sollen eine Anwendung für einen Shop schreiben. Im Shop gibt es viele Artikel, die mit Id, Bezeichnung, Einkaufspreis, Gewinnsatz und Verkaufspreis gespeichert werden. Der Verkaufspreis wird dabei immer aus Einkaufspreis + Gewinn errechnet."
],
"id": "152f0dfd54408937"
},
{
"metadata": {},
"cell_type": "code",
"source": [
"class Artikel:\n",
" def __init__(self, id, bezeichnung: str, einkaufspreis: float, gewinnsatz: float): # Angabe von konkreten Datentypen\n",
" self.id = id\n",
" self.bezeichnung = bezeichnung\n",
" self.einkaufspreis = einkaufspreis\n",
" self.gewinnsatz = gewinnsatz\n",
"\n",
"\n",
" @property\n",
" def verkaufspreis(self) -> float: # Angabe von Rückgabetyp\n",
" return self.einkaufspreis * (1 + self.gewinnsatz / 100)"
],
"id": "f876b667a5783072",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Artikel im Warenkorb werden dort als Warenkorb-Items eingetragen. Ein Warenkorb-Item besteht aus dem Artikel selbst und der Anzahl. Ebenfalls soll der Gesamtpreis für diesen Artikel abgefragt werden können.",
"id": "9b3dba2c6071ca86"
},
{
"metadata": {},
"cell_type": "code",
"source": [
"class WarenkorbItem:\n",
" def __init__(self, artikel: Artikel, anzahl: int):\n",
" self.artikel = artikel\n",
" self.anzahl = anzahl\n",
"\n",
" @property\n",
" def gesamtpreis(self) -> float:\n",
" return self.artikel.verkaufspreis * self.anzahl"
],
"id": "1590b144e6e119a2",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Artikel, die gekauft werden, werden mit Mengenangabe in einen Warenkorb gelegt. Es sollen Artikel in den Warenkorb gelegt und wieder entfernt werden können. Ebenfalls soll es möglich sein, die Anzahl eines Artikels ändern zu können. Über den Warenkorb wird der Gesamtpreis aller sich dort befindenden Artikel ermittelt.",
"id": "26737f39f9902970"
},
{
"metadata": {},
"cell_type": "code",
"source": [
"class Warenkorb:\n",
" def __init__(self):\n",
" self.liste = []\n",
"\n",
" def add_artikel(self, artikel, anzahl: int):\n",
" item = self.find_item(artikel)\n",
" if item is None:\n",
" self.liste.append(WarenkorbItem(artikel, anzahl))\n",
" else:\n",
" item.anzahl = item.anzahl + anzahl\n",
"\n",
" def remove_artikel(self, artikel: Artikel, anzahl: int) -> bool:\n",
" item = self.find_item(artikel)\n",
" if item is None:\n",
" return False\n",
" if item.anzahl - anzahl > 0:\n",
" item.anzahl = item.anzahl - anzahl\n",
" else:\n",
" self.liste.remove(item)\n",
" return True\n",
"\n",
" def find_item(self, artikel: Artikel) -> WarenkorbItem | None:\n",
" for item in self.liste:\n",
" if item.artikel == artikel:\n",
" return item\n",
" return None\n",
"\n",
" @property\n",
" def gesamtpreis(self) -> float:\n",
" summe = 0\n",
" item: WarenkorbItem\n",
" for item in self.liste:\n",
" summe = summe + item.gesamtpreis\n",
"\n",
" return summe"
],
"id": "edcaca28fe6a6cb0",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "code",
"source": [
"apfel = Artikel(1, \"Apfel\", 1.00, 10)\n",
"birne = Artikel(2, \"Birne\", 1.10, 10)\n",
"warenkorb = Warenkorb()\n",
"warenkorb.add_artikel(apfel, 10)\n",
"print(warenkorb.gesamtpreis)\n",
"print(warenkorb.remove_artikel(apfel, 5))\n",
"warenkorb.add_artikel(apfel, 10)\n",
"print(warenkorb.gesamtpreis)\n",
"print(warenkorb.remove_artikel(birne, 5))\n",
"print(warenkorb.remove_artikel(apfel, 15))\n",
"print(warenkorb.gesamtpreis)"
],
"id": "769c973f4a9ec4a5",
"outputs": [],
"execution_count": null
}
],
"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
}
python/aufgaben_tag3.ipynb
+385
View File
@@ -0,0 +1,385 @@
{
"cells": [
{
"metadata": {
"collapsed": true
},
"cell_type": "markdown",
"source": [
"# Aufgabe 1\n",
"## Aufgabenstellung\n",
"Ein Online-Shop hat eine Liste mit Produktpreisen.\n",
"\n",
"Beispiel: preise = [20, 55, 80, 30, 120]\n",
"\n",
"Produkte über 50 EUR erhalten 10% Rabatt.\n",
"\n",
"Schreiben Sie ein Programm, das mit Hilfe von Lamdba eine neue Liste mit reduzierten Preisen erstellt."
],
"id": "897a5654dca6cca5"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## Bearbeitung\n",
"### Variante A"
],
"id": "ee68cc8aef8a90e1"
},
{
"metadata": {},
"cell_type": "code",
"source": [
"from datetime import date\n",
"\n",
"preise = [20, 55, 80, 30, 120]\n",
"print(\"Originalpreis\")\n",
"print(preise)\n",
"\n",
"berechne_reduzierten_preis = lambda x: x * 0.9 if x > 50 else x\n",
"reduzierte_preise = list(map(berechne_reduzierten_preis, preise))\n",
"\n",
"print(\"Mit Rabatt\")\n",
"print(reduzierte_preise)"
],
"id": "7992fb80d80b9a9d",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "markdown",
"source": "### Variante B",
"id": "79212ee1313a3dab"
},
{
"metadata": {},
"cell_type": "code",
"source": [
"preise = [20, 55, 80, 30, 120]\n",
"\n",
"format_preis = lambda x: f'{x:.2f} EUR'\n",
"\n",
"print(\"Originalpreis\")\n",
"print(list(map(format_preis, preise)))\n",
"\n",
"berechne_reduzierten_preis = lambda x: x * 0.9 if x > 50 else x\n",
"reduzierte_preise = list(map(berechne_reduzierten_preis, preise))\n",
"\n",
"print(\"Mit Rabatt\")\n",
"print(list(map(format_preis, reduzierte_preise)))"
],
"id": "d0783086c8499ec",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"# Aufgabe 2\n",
"## Aufgabenstellung\n",
"Schreibe ein Programm zur Verwaltung von Mitarbeitern.\n",
"\n",
"Jeder Mitarbeiter besitzt:\n",
"- Name\n",
"- Alter\n",
"- Abteilung\n",
"- Gehalt"
],
"id": "35d95a33d0cfa30f"
},
{
"metadata": {},
"cell_type": "code",
"source": [
"from datetime import date\n",
"from dateutil.relativedelta import relativedelta"
],
"id": "272c0dd3d94b644b",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "code",
"source": [
"class Abteilung:\n",
"\n",
" def __init__(self, name:str, *args):\n",
" self.__name = name\n",
" super().__init__(*args)\n",
"\n",
" @property\n",
" def name(self):\n",
" return self.__name\n",
"\n",
" def __str__(self):\n",
" return self.name"
],
"id": "90d84c95ac6ed431",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "code",
"source": [
"class Mitarbeiter:\n",
"\n",
" def __init__(self, name:str, geburtsdatum:date, abteilung:Abteilung, gehalt:float, *args):\n",
" self.__name = name\n",
" self.__geburtsdatum = geburtsdatum\n",
" self.__abteilung = abteilung\n",
" self.__gehalt = gehalt\n",
" super().__init__(*args)\n",
"\n",
" @property\n",
" def name(self):\n",
" return self.__name\n",
"\n",
" @property\n",
" def alter(self):\n",
" return relativedelta(date.today(), self.__geburtsdatum).years\n",
"\n",
" @property\n",
" def gehalt(self):\n",
" return self.__gehalt\n",
"\n",
" @property\n",
" def abteilung(self):\n",
" return self.__abteilung\n",
"\n",
" def __str__(self):\n",
" return f\"{self.name}, geboren {self.__geburtsdatum} ({self.alter} Jahre alt) arbeitet in {self.abteilung} und verdient {self.gehalt:.2f} EUR.\""
],
"id": "e75bd9332850f6fa",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"\n",
"Erstelle mindestens 6 Mitarbeiter und speichere sie in einer Liste."
],
"id": "80f0590dbc1f3eea"
},
{
"metadata": {},
"cell_type": "code",
"source": [
"it = Abteilung(\"IT-Abteilung\")\n",
"personal = Abteilung(\"Personalabteilung\")\n",
"vertrieb = Abteilung(\"Vertrieb\")\n",
"\n",
"mitarbeiter_list = [\n",
" Mitarbeiter(\"Albert\", date(1970, 2, 22), personal, 1234.5),\n",
" Mitarbeiter(\"Bert\", date(1980, 3, 11), it, 2345.6),\n",
" Mitarbeiter(\"Camembert\", date(2008, 1, 15), it, 1234.5),\n",
" Mitarbeiter(\"Dilbert\", date(2001, 2, 22), personal, 1234.5),\n",
" Mitarbeiter(\"Elbert\", date(1999, 3, 11), it, 2345.6),\n",
" Mitarbeiter(\"Filbert\", date(1968, 1, 15), it, 5234.5),\n",
"]"
],
"id": "f54a24a33da9ef37",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"\n",
"Das Programm soll anschließend:\n",
"\n",
"- Alle Mitarbeiter ausgeben."
],
"id": "186cd3483d573698"
},
{
"metadata": {},
"cell_type": "code",
"source": [
"for mitarbeiter in mitarbeiter_list:\n",
" print(mitarbeiter)"
],
"id": "888cea3bcb830aed",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "markdown",
"source": "- Alle Mitarbeiter anzeigen, die älter als 30 Jahre sind.",
"id": "b29b20967f9c3ac7"
},
{
"metadata": {},
"cell_type": "code",
"source": [
"mitarbeiter_ueber_30 = list(filter(lambda x: x.alter > 30, mitarbeiter_list))\n",
"\n",
"for mitarbeiter in mitarbeiter_ueber_30:\n",
" print(mitarbeiter)"
],
"id": "1a992cb2a3092ae5",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "markdown",
"source": "- Das durchschnittliche Gehalt berechnen.",
"id": "aa7c0e7d3d25a806"
},
{
"metadata": {},
"cell_type": "code",
"source": [
"summe_gehalt = sum(list(map(lambda x : x.gehalt, mitarbeiter_list)))\n",
"durchschnitt_gehalt = summe_gehalt / len(mitarbeiter_list)\n",
"\n",
"print(durchschnitt_gehalt)"
],
"id": "3d16715679dd9a23",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "markdown",
"source": "- Alle Mitarbeiter der IT-Abteilung ausgeben.",
"id": "7a99b3570a2444a3"
},
{
"metadata": {},
"cell_type": "code",
"source": [
"mitarbeiter_in_it = list(filter(lambda x: x.abteilung == it, mitarbeiter_list))\n",
"\n",
"for mitarbeiter in mitarbeiter_in_it:\n",
" print(mitarbeiter)"
],
"id": "bce2741c8f96e7eb",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "markdown",
"source": "- Die Namen aller Mitarbeiter in Großbuchstaben ausgeben.",
"id": "51d3d88f26dc87fa"
},
{
"metadata": {},
"cell_type": "code",
"source": [
"MITARBEITER_NAMEN = list(map(lambda x: x.name.upper(), mitarbeiter_list))\n",
"\n",
"print(MITARBEITER_NAMEN)"
],
"id": "ceab8fc00992178",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "markdown",
"source": "- Alle Mitarbeiter ausgeben, deren Gehalt über 4000 € liegt.",
"id": "2909d6f2185cd42c"
},
{
"metadata": {},
"cell_type": "code",
"source": [
"mitarbeiter_gehalt_ueber_4000 = list(filter(lambda x:x.gehalt > 4000, mitarbeiter_list))\n",
"\n",
"for mitarbeiter in mitarbeiter_gehalt_ueber_4000:\n",
" print(mitarbeiter)"
],
"id": "c7653e3dd84adf1",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"\n",
"### Zusatzaufgabe\n",
"Gib aus, welcher Mitarbeiter das höchste Gehalt besitzt."
],
"id": "6c2a5da8a3ffbcea"
},
{
"metadata": {},
"cell_type": "code",
"source": [
"mitarbeiter_max_gehalt = mitarbeiter_list[0]\n",
"\n",
"for mitarbeiter in mitarbeiter_list:\n",
" if mitarbeiter_max_gehalt.gehalt < mitarbeiter.gehalt:\n",
" mitarbeiter_max_gehalt = mitarbeiter\n",
"\n",
"print(mitarbeiter_max_gehalt)\n"
],
"id": "faaf607cc0508e17",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Alternative mit Lambda:",
"id": "13dba464d7ddd6af"
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2026-07-22T09:46:00.972621400Z",
"start_time": "2026-07-22T09:46:00.935546200Z"
}
},
"cell_type": "code",
"source": [
"mitarbeiter_max_gehalt = max(mitarbeiter_list, key= lambda x: x.gehalt)\n",
"print(mitarbeiter_max_gehalt)"
],
"id": "1946de57dee64b91",
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Filbert, geboren 1968-01-15 (58 Jahre alt) arbeitet in IT-Abteilung und verdient 5234.50 EUR.\n"
]
}
],
"execution_count": 9
}
],
"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
}
python/computer.py
+30
View File
@@ -0,0 +1,30 @@
class Computer:
anzahl = 0 # Klassenattribut
def __init__(self, bezeichnung:str, *args):
self.__bezeichnung = bezeichnung
self.__class__.anzahl += 1
super().__init__(*args)
@property
def bezeichnung(self) -> str:
return self.__bezeichnung
@bezeichnung.setter
def bezeichnung(self, bezeichnung:str) -> None:
self.__bezeichnung = bezeichnung
def get_bezeichnung(self, bezeichnung:str):
return self.__bezeichnung
#bezeichnung_property = property(fget=get_bezeichnung, fset=set_bezeichnung)
@classmethod
def ausgabe_anzahl(cls):
print("Anzahl: %s Computer" % cls.anzahl)
if __name__ == "__main__":
print("Environment main")
if __name__ == "computer":
print("Environment computer")
python/fraction.py
+21
View File
@@ -0,0 +1,21 @@
# Operatoren und magische Methoden
# https://docs.python.org/3/reference/datamodel.html#emulating-numeric-types\
class Fraction:
def __init__(self, numerator:int, denominator:int):
self.numerator = numerator
self.denominator = denominator
def ausgabe(self):
print(self.numerator, "/", self.denominator)
def __add__(self, other): # Erlaubt es uns, zwei Objekte miteinander zu addieren
numerator = self.numerator * other.denominator + other.numerator * self.denominator
denominator = self.denominator * other.denominator
return Fraction(numerator, denominator)
def __str__(self): # Entspricht der ToString() Methode
return str(self.numerator) + "/" + str(self.denominator)
def __del__(self): # Destruktor
print(self.__class__)
python/grundlagen.ipynb
+1591
View File
File diff suppressed because it is too large Load Diff
python/grundlagen.py
+1
View File
@@ -0,0 +1 @@
print('Hello World')
python/klassen.ipynb
+931
View File
@@ -0,0 +1,931 @@
{
"cells": [
{
"metadata": {},
"cell_type": "markdown",
"source": [
"# Klassen, Vererbung und Magic Methods in Python\n",
"\n",
"## Ziel dieser Einheit\n",
"\n",
"In dieser Einheit lernst du:\n",
"\n",
"- wie Klassen in Python aufgebaut sind\n",
"- wie Klassenattribute und Instanzattribute funktionieren\n",
"- wie Properties verwendet werden\n",
"- wie Klassenmethoden und statische Methoden unterschieden werden\n",
"- wie Vererbung und Mehrfachvererbung in Python funktionieren\n",
"- wie Konstruktorverkettung mit super() und \\*args umgesetzt wird\n",
"- wie Magic Methods verwendet werden"
],
"id": "1bc0f92c24d3aafd"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 1. Überblick über das Beispiel\n",
"\n",
"Dieses Thema besteht aus zwei Beispielen.\n",
"\n",
"### Beispiel 1: Klassen und Vererbung\n",
"\n",
"Das erste Beispiel besteht aus den Dateien:\n",
"\n",
"- computer.py\n",
"- telefon.py\n",
"- smartphone.py"
],
"id": "25e3da34ffcde469"
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2026-07-21T08:17:20.833561200Z",
"start_time": "2026-07-21T08:17:20.769251100Z"
}
},
"cell_type": "code",
"source": [
"from telefon import Telefon\n",
"from computer import Computer\n",
"from smartphone import Smartphone\n",
"from fraction import Fraction"
],
"id": "57dce3cccdaf835a",
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Environment computer\n"
]
}
],
"execution_count": 1
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"In diesen Dateien wird gezeigt:\n",
"\n",
"- wie Klassen definiert werden\n",
"- wie Attribute gekapselt werden\n",
"- wie Properties funktionieren\n",
"- wie Klassenmethoden und statische Methoden verwendet werden\n",
"- wie Vererbung funktioniert\n",
"- wie Python Mehrfachvererbung ermöglicht\n",
"- wie Konstruktoren über super() verkettet werden"
],
"id": "a8ebda0b94eb34a8"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"### Beispiel 2: Magic Methods\n",
"\n",
"Das zweite Beispiel besteht aus der Datei:\n",
"\n",
"- fraction.py\n",
"\n",
"Hier wird gezeigt:\n",
"\n",
"- wie Operatoren über Magic Methods angepasst werden können\n",
"- wie Objekte mit print() sinnvoll ausgegeben werden können\n",
"- wie Objekte gelöscht werden können"
],
"id": "577ba96741997bd"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"### Main-Datei\n",
"\n",
"Die Datei klassen.py verwendet die Klassen aus beiden Beispielen und zeigt, wie die Konzepte praktisch genutzt werden."
],
"id": "b9023a06c19885c0"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "## 2. Die Klasse Computer",
"id": "1df322274c512733"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"Die Datei computer.py beginnt mit der Definition der Klasse Computer.\n",
"\n",
" class Computer:\n",
"\n",
" anzahl = 0\n",
"\n",
"Das Attribut anzahl ist ein Klassenattribut.\n",
"\n",
"Ein Klassenattribut gehört nicht zu einem einzelnen Objekt, sondern zur Klasse selbst. Dadurch teilen sich alle Objekte der Klasse Computer dieses Attribut.\n",
"\n",
"In diesem Beispiel wird anzahl verwendet, um zu zählen, wie viele Computer-Objekte erzeugt wurden."
],
"id": "b1d89c1b6e8c4c93"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "## 3. Initialisierung eines Computer-Objekts",
"id": "b6b287aaf94bd2a3"
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2026-07-21T08:17:40.156907400Z",
"start_time": "2026-07-21T08:17:40.096922700Z"
}
},
"cell_type": "code",
"source": [
"computer = Computer(\"Dell\")\n",
"print(computer.bezeichnung)\n",
"computer.bezeichnung = \"Asus\"\n",
"print(computer.bezeichnung)\n",
"computer.ausgabe_anzahl()"
],
"id": "230073769e0d285",
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Dell\n",
"Asus\n",
"Anzahl: 2 Computer\n"
]
}
],
"execution_count": 5
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"Wenn Computer() aufgerufen wird, arbeiten in Python \\_\\_new\\_\\_ und \\_\\_init\\_\\_ zusammen.\n",
"\n",
"- \\_\\_new\\_\\_ erzeugt das Objekt\n",
"- \\_\\_init\\_\\_ initialisiert das bereits erzeugte Objekt\n",
"\n",
"Das Attribut \\_\\_bezeichnung wird als privates Attribut angelegt. Die zwei Unterstriche vor dem Namen sorgen dafür, dass Python den Namen intern verändert. Dadurch wird der direkte Zugriff von außen erschwert.\n",
"\n",
"Mit self.\\_\\_class\\_\\_.anzahl wird über das Objekt auf die Klasse zugegriffen. Dadurch kann das Klassenattribut anzahl erhöht werden.\n",
"\n",
"Der Aufruf super().\\_\\_init\\_\\_(\\*args) ist besonders wichtig für die spätere Vererbung. Dadurch kann der nächste Konstruktor in der Vererbungskette aufgerufen werden."
],
"id": "101ad80eb05e2a17"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 4. Property für bezeichnung\n",
"\n",
" @property\n",
" def bezeichnung(self) -> str:\n",
" return self.__bezeichnung\n",
"\n",
"Mit @property wird eine Methode so nutzbar, als wäre sie ein normales Attribut.\n",
"\n",
"Dadurch kann später geschrieben werden:\n",
"\n",
" print(computer.bezeichnung)\n",
"\n",
"Obwohl der Zugriff wie ein einfacher Attributzugriff aussieht, wird intern die Methode bezeichnung() ausgeführt.\n",
"\n",
"So kann ein privates Attribut kontrolliert nach außen verfügbar gemacht werden."
],
"id": "f1f0ea837a0bb5f3"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 5. Setter für bezeichnung\n",
"\n",
" @bezeichnung.setter\n",
" def bezeichnung(self, bezeichnung:str) -> None:\n",
" self.__bezeichnung = bezeichnung\n",
"\n",
"Der Setter wird aufgerufen, wenn der Property ein neuer Wert zugewiesen wird.\n",
"\n",
"Beispiel:\n",
"\n",
" computer.bezeichnung = \"Asus\"\n",
"\n",
"Dadurch wird nicht direkt von außen auf \\_\\_bezeichnung zugegriffen. Stattdessen wird die Setter-Methode ausgeführt und weist den neuen Wert intern zu."
],
"id": "cc788b3ce7d85d75"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 6. Klassische Getter- und Setter-Methoden\n",
"\n",
" def get_bezeichnung(self):\n",
" return self.__bezeichnung\n",
"\n",
" def set_bezeichnung(self, bezeichnung):\n",
" self.__bezeichnung = bezeichnung\n",
"\n",
"Neben Properties können auch klassische Getter- und Setter-Methoden verwendet werden.\n",
"\n",
"Diese Schreibweise erinnert stärker an Java oder C#."
],
"id": "f34bf45c7487532c"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 7. Property mit property()\n",
"\n",
" bezeichnung_property = property(fget=get_bezeichnung, fset=set_bezeichnung)\n",
"\n",
"Mit property() können selbst erstellte Getter- und Setter-Methoden zu einer Property verbunden werden.\n",
"\n",
"Diese Variante gilt als veraltet und wird heute normalerweise nicht mehr verwendet.\n",
"\n",
"Stattdessen sollte @property verwendet werden, weil diese Schreibweise lesbarer und moderner ist.\n",
"\n",
"Weitere Informationen:\n",
"https://realpython.com/python-property/"
],
"id": "e39f2e3c37dcff98"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 8. Klassenmethode\n",
"\n",
" @classmethod\n",
" def ausgabe_anzahl(cls):\n",
" print(\"Anzahl: %s Computer\" % cls.anzahl)\n",
"\n",
"Python unterscheidet zwischen Klassenmethoden und statischen Methoden.\n",
"\n",
"Eine Klassenmethode bekommt als ersten Parameter cls.\n",
"\n",
"cls steht für die Klasse selbst. Dadurch kann eine Klassenmethode auf Klassenattribute zugreifen.\n",
"\n",
"In diesem Beispiel greift die Methode ausgabe_anzahl() auf das Klassenattribut anzahl zu und gibt aus, wie viele Computer-Objekte erzeugt wurden."
],
"id": "5781caf27da1f28b"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 9. Das \\_\\_name\\_\\_-Konzept\n",
"\n",
" if __name__ == \"__main__\":\n",
" print(\"Environment main\")\n",
"\n",
" if __name__ == \"computer\":\n",
" print(\"Environment computer\")\n",
"\n",
"Mit \\_\\_name\\_\\_ kann geprüft werden, in welchem Kontext eine Python-Datei ausgeführt wird.\n",
"\n",
"Wenn eine Datei direkt gestartet wird, befindet sie sich in der \\_\\_main\\_\\_-Umgebung.\n",
"\n",
"Wenn die Datei aus einer anderen Datei importiert wird, entspricht \\_\\_name\\_\\_ dem Namen des Moduls.\n",
"\n",
"In diesem Beispiel bedeutet das:\n",
"\n",
"- direkte Ausführung von computer.py → \\_\\_name\\_\\_ ist \"\\_\\_main\\_\\_\"\n",
"- Import aus klassen.py → \\_\\_name\\_\\_ ist \"computer\""
],
"id": "c097e674bee7704d"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "## 10. Die Klasse Telefon",
"id": "97d671aeb0d77966"
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2026-07-21T08:17:20.916537800Z",
"start_time": "2026-07-21T08:17:20.875642500Z"
}
},
"cell_type": "code",
"source": [
"meintelefon = Telefon(\"Vodafone\")\n",
"print(meintelefon.netz)\n",
"meintelefon.klingeln(5)"
],
"id": "32cce4b29f6cbfe6",
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Vodafone\n",
"*klingel**klingel**klingel**klingel**klingel*\n"
]
}
],
"execution_count": 3
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"Die Datei telefon.py definiert die Klasse Telefon.\n",
"\n",
" class Telefon:\n",
"\n",
" def __init__(self, netz:str, *args):\n",
" self.__netz = netz\n",
" super().__init__(*args)\n",
"\n",
"Auch hier wird im Konstruktor ein privates Attribut gesetzt.\n",
"\n",
"Das Attribut \\_\\_netz speichert das Mobilfunknetz.\n",
"\n",
"Der Aufruf super().\\_\\_init\\_\\_(\\*args) ist wichtig, damit diese Klasse später sauber an der Konstruktorverkettung teilnehmen kann."
],
"id": "1857652c023df901"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 11. Property für netz\n",
"\n",
" @property\n",
" def netz(self) -> str:\n",
" return self.__netz\n",
"\n",
" @netz.setter\n",
" def netz(self, netz:str):\n",
" self.__netz = netz\n",
"\n",
"Die Property netz ermöglicht kontrollierten Zugriff auf das private Attribut \\_\\_netz.\n",
"\n",
"Auch hier sieht der spätere Zugriff wie ein normaler Attributzugriff aus:\n",
"\n",
" print(telefon.netz)\n",
"\n",
"Intern wird aber die Getter-Methode aufgerufen."
],
"id": "ed2fb4ce1225951b"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 12. Statische Methode\n",
"\n",
" @staticmethod\n",
" def klingeln(anzahl:int = 1):\n",
" print(anzahl * \"*klingel*\")\n",
"\n",
"Python unterscheidet zwischen Klassenmethoden und statischen Methoden.\n",
"\n",
"Eine statische Methode bekommt weder self noch cls.\n",
"\n",
"Das bedeutet:\n",
"\n",
"- sie arbeitet nicht mit einem konkreten Objekt\n",
"- sie greift nicht auf Klassenattribute zu\n",
"- sie ist eher eine Hilfsmethode, die logisch zur Klasse gehört\n",
"\n",
"Die Methode klingeln() gibt den Text \"*klingel*\" mehrfach aus.\n",
"\n",
"Der Parameter anzahl hat den Standardwert 1. Wird kein Wert übergeben, klingelt es also einmal."
],
"id": "608e80850e7e02ad"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "## 13. Die Klasse Smartphone",
"id": "19e20783d3533b6b"
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2026-07-21T08:18:01.661401800Z",
"start_time": "2026-07-21T08:18:01.599246Z"
}
},
"cell_type": "code",
"source": [
"galaxy = Smartphone(\"Galaxy\", \"Telekom\")\n",
"\n",
"print(galaxy.bezeichnung)\n",
"print(galaxy.netz)\n",
"galaxy.klingeln(5)\n",
"galaxy.ausgabe_anzahl()\n",
"\n",
"#galaxy.__class__ = Telefon # Datentyp des Objektes ändern\n",
"#galaxy: Telefon = galaxy # Datentyp der Variable ändern\n",
"print(type(galaxy))\n",
"\n",
"# Wie bei Java und C# können wir prüfen, ob das Objekt vom Typ Smartphone auch ein Objekt vom Typ Telefon ist:\n",
"if isinstance(galaxy, Telefon):\n",
" print(galaxy.bezeichnung + \" ist ein Telefon.\")"
],
"id": "23d06b73f3563f9",
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Galaxy\n",
"Telekom\n",
"*klingel**klingel**klingel**klingel**klingel*\n",
"Anzahl: 3 Computer\n",
"<class 'smartphone.Smartphone'>\n",
"Galaxy ist ein Telefon.\n"
]
}
],
"execution_count": 6
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"Die Datei smartphone.py importiert zunächst die Klassen Telefon und Computer.\n",
"\n",
" from telefon import Telefon\n",
" from computer import Computer\n",
"\n",
"Anschließend wird die Klasse Smartphone definiert.\n",
"\n",
" class Smartphone(Computer, Telefon):\n",
" def __init__(self, bezeichnung:str, netz:str, *args):\n",
" super().__init__(bezeichnung, netz, *args)\n",
"\n",
"Python kann Mehrfachvererbung.\n",
"\n",
"Das bedeutet, dass eine Klasse von mehreren Klassen erben kann.\n",
"\n",
"In diesem Beispiel erbt Smartphone von:\n",
"\n",
"- Computer\n",
"- Telefon\n",
"\n",
"Die Reihenfolge ist wichtig:\n",
"\n",
" class Smartphone(Computer, Telefon)\n",
"\n",
"Dadurch wird zuerst Computer und danach Telefon in die Vererbungskette aufgenommen."
],
"id": "a2ae80c347f18d49"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 14. Konstruktorverkettung\n",
"\n",
"In der Main-Datei wird ein Smartphone erzeugt.\n",
"\n",
" galaxy = Smartphone(\"Galaxy\", \"Telekom\")\n",
"\n",
"Die Werte \"Galaxy\" und \"Telekom\" werden an den Konstruktor von Smartphone übergeben.\n",
"\n",
"Dort werden sie über super().\\_\\_init\\_\\_ an die Konstruktoren der Superklassen weitergeleitet.\n",
"\n",
"Da Smartphone von mehreren Klassen erbt, werden auch die Konstruktoren der Superklassen verkettet."
],
"id": "5e9624a25fca2221"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 15. Ablauf der Konstruktorverkettung\n",
"\n",
"Der Ablauf sieht vereinfacht so aus:\n",
"\n",
"1. Smartphone erhält bezeichnung und netz\n",
"2. Smartphone ruft super().\\_\\_init\\_\\_(bezeichnung, netz, \\*args) auf\n",
"3. Computer erhält bezeichnung und nimmt netz über \\*args entgegen\n",
"4. Computer speichert die Bezeichnung\n",
"5. Computer ruft super().\\_\\_init\\_\\_(\\*args) auf\n",
"6. Telefon erhält netz\n",
"7. Telefon speichert das Netz\n",
"\n",
"Damit das funktioniert, benötigen die Konstruktoren zusätzliche Parameter über \\*args.\n",
"\n",
"\\*args steht für eine beliebige Anzahl weiterer Parameter.\n",
"\n",
"Dadurch können Parameter, die eine Klasse nicht selbst verarbeitet, an die nächste Klasse weitergegeben werden."
],
"id": "43df21a4d5bb3d00"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 16. Reihenfolge bei Mehrfachvererbung\n",
"\n",
"Die Reihenfolge der Konstruktorverkettung wird durch die Reihenfolge bei der Vererbung bestimmt.\n",
"\n",
" class Smartphone(Computer, Telefon)\n",
"\n",
"In diesem Beispiel wird zuerst Computer und danach Telefon berücksichtigt.\n",
"\n",
"Theoretisch kann Python von beliebig vielen Klassen erben. Damit auch Smartphone für weitere Vererbungen offen bleibt, enthält auch dessen Konstruktor \\*args."
],
"id": "98bbbe3c61a5aaec"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 17. Die Main-Datei klassen.py\n",
"\n",
"In klassen.py werden die benötigten Klassen importiert.\n",
"\n",
" from telefon import Telefon\n",
" from computer import Computer\n",
" from smartphone import Smartphone\n",
" from fraction import Fraction\n",
"\n",
"Diese Datei dient als Einstiegspunkt, um die Klassen zu erzeugen und zu testen."
],
"id": "627021ed917b1fd4"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 18. Arbeiten mit Computer\n",
"\n",
" computer = Computer(\"Dell\")\n",
" print(computer.bezeichnung)\n",
" computer.bezeichnung = \"Asus\"\n",
" print(computer.bezeichnung_property)\n",
" computer.ausgabe_anzahl()\n",
"\n",
"Computer(\"Dell\") ist der Konstruktor-Ausdruck.\n",
"\n",
"Durch diesen Aufruf werden \\_\\_new\\_\\_ und \\_\\_init\\_\\_ ausgeführt.\n",
"\n",
"Danach wird:\n",
"\n",
"- die Bezeichnung über die Property ausgegeben\n",
"- die Bezeichnung über den Setter verändert\n",
"- die ältere property()-Variante verwendet\n",
"- die Klassenmethode ausgabe_anzahl() aufgerufen"
],
"id": "51f9501545956fda"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 19. Arbeiten mit Telefon\n",
"\n",
" telefon = Telefon(\"1&1\")\n",
" print(telefon.netz)\n",
" telefon.klingeln(10)\n",
"\n",
"Hier wird ein Telefon-Objekt erzeugt.\n",
"\n",
"Danach wird:\n",
"\n",
"- das Netz über die Property ausgegeben\n",
"- die statische Methode klingeln() aufgerufen"
],
"id": "6d7d2d9f239f9775"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 20. Arbeiten mit Smartphone\n",
"\n",
" galaxy = Smartphone(\"Galaxy\", \"Telekom\")\n",
"\n",
"Anschließend können Eigenschaften und Methoden aus beiden Superklassen verwendet werden.\n",
"\n",
" print(galaxy.bezeichnung)\n",
" print(galaxy.netz)\n",
" galaxy.klingeln(5)\n",
" galaxy.ausgabe_anzahl()\n",
"\n",
"Das Smartphone besitzt dadurch:\n",
"\n",
"- bezeichnung aus Computer\n",
"- netz aus Telefon\n",
"- klingeln() aus Telefon\n",
"- ausgabe_anzahl() aus Computer"
],
"id": "4947b906a0f8dc37"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 21. Typprüfung\n",
"\n",
" print(type(galaxy))\n",
"\n",
"Mit type() kann der tatsächliche Typ eines Objekts ausgegeben werden.\n",
"\n",
"---\n",
"\n",
" if isinstance(galaxy, Telefon):\n",
" print(galaxy.bezeichnung + \" ist ein Telefon.\")\n",
"\n",
"Mit isinstance() kann geprüft werden, ob ein Objekt von einem bestimmten Typ ist.\n",
"\n",
"Wie bei Java und C# kann also geprüft werden, ob ein Smartphone auch ein Telefon ist.\n",
"\n",
"Da Smartphone von Telefon erbt, ist diese Prüfung wahr."
],
"id": "b2d9fe72fe34c1aa"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 22. Magic Methods\n",
"\n",
"Die Datei fraction.py behandelt Operatoren und magische Methoden.\n",
"\n",
" class Fraction:\n",
" def __init__(self, numerator:int, denominator:int):\n",
" self.numerator = numerator\n",
" self.denominator = denominator\n",
"\n",
"Magic Methods sind besondere Methoden in Python.\n",
"\n",
"Sie beginnen und enden mit doppelten Unterstrichen.\n",
"\n",
"Beispiele:\n",
"\n",
"- \\_\\_init\\_\\_\n",
"- \\_\\_add\\_\\_\n",
"- \\_\\_str\\_\\_\n",
"- \\_\\_del\\_\\_\n",
"\n",
"Python ruft diese Methoden in bestimmten Situationen automatisch auf.\n",
"\n",
"Weitere Informationen:\n",
"https://docs.python.org/3/reference/datamodel.html#emulating-numeric-types"
],
"id": "92201737e56fe54f"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 23. Ausgabe eines Bruchs\n",
"\n",
" def ausgabe(self):\n",
" print(self.numerator, \"/\", self.denominator)\n",
"\n",
"Diese Methode gibt den Bruch in einer einfachen Schreibweise aus."
],
"id": "1792691e48453934"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 24. Addition mit \\_\\_add\\_\\_\n",
"\n",
" def __add__(self, other):\n",
" numerator = self.numerator * other.denominator + other.numerator * self.denominator\n",
" denominator = self.denominator * other.denominator\n",
" return Fraction(numerator, denominator)\n",
"\n",
"Die Methode \\_\\_add\\_\\_ erlaubt es, zwei Objekte miteinander zu addieren.\n",
"\n",
"Dadurch kann später geschrieben werden:\n",
"\n",
" fraction3 = fraction + fraction2\n",
"\n",
"Python erkennt den Plus-Operator und ruft intern die Methode \\_\\_add\\_\\_ auf."
],
"id": "b2c2c453b68b781b"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 25. String-Darstellung mit \\_\\_str\\_\\_\n",
"\n",
" def __str__(self):\n",
" return str(self.numerator) + \"/\" + str(self.denominator)\n",
"\n",
"Die Methode \\_\\_str\\_\\_ entspricht der ToString()-Methode aus Java oder C#.\n",
"\n",
"Sie bestimmt, wie ein Objekt als String dargestellt wird.\n",
"\n",
"Wenn print(fraction) aufgerufen wird, verwendet Python diese Methode."
],
"id": "22a1c8d454e1b8fe"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 26. Destruktor mit \\_\\_del\\_\\_\n",
"\n",
" def __del__(self):\n",
" print(self.__class__)\n",
"\n",
"Die Methode \\_\\_del\\_\\_ ist der Destruktor.\n",
"\n",
"Sie wird aufgerufen, wenn ein Objekt gelöscht wird."
],
"id": "91b57a5ccbbe0c72"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 27. Arbeiten mit Fraction\n",
"\n",
" fraction = Fraction(5, 10)\n",
" fraction.ausgabe()\n",
" print(fraction)\n",
" print(fraction.__dict__)\n",
"\n",
"Hier wird ein Fraction-Objekt erzeugt.\n",
"\n",
"Danach wird:\n",
"\n",
"- der Bruch mit der eigenen Methode ausgegeben\n",
"- der Bruch mit print() ausgegeben\n",
"- das interne Dictionary des Objekts angezeigt\n",
"\n",
"\\_\\_dict\\_\\_ zeigt die Attribute, die im Objekt gespeichert sind."
],
"id": "6cac29b8e80971d"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 28. Zweiter Bruch und Addition\n",
"\n",
" fraction2 = Fraction(1, 2)\n",
" print(fraction2)\n",
"\n",
" fraction3 = fraction + fraction2\n",
" fraction3.ausgabe()\n",
" print(fraction3)\n",
"\n",
"Hier werden zwei Fraction-Objekte addiert.\n",
"\n",
"Durch die Methode \\_\\_add\\_\\_ kann der Plus-Operator verwendet werden."
],
"id": "e5f8d6898b990069"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 29. Objekte löschen\n",
"\n",
" del fraction\n",
" fraction2 = None\n",
" print(\"Zwei Objekte sind gelöscht\")\n",
"\n",
"Mit del wird ein Objekt manuell gelöscht.\n",
"\n",
"Wenn eine Variable auf None gesetzt wird und keine weiteren Referenzen mehr auf das Objekt zeigen, kann das Objekt ebenfalls gelöscht werden."
],
"id": "23c8e0a5a89f5a40"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 30. Wichtige Konzepte im Überblick\n",
"\n",
"### Klassen\n",
"\n",
"Klassen bündeln Daten und Verhalten.\n",
"\n",
"---\n",
"\n",
"### Instanzattribute\n",
"\n",
"Instanzattribute gehören zu einem konkreten Objekt.\n",
"\n",
"---\n",
"\n",
"### Klassenattribute\n",
"\n",
"Klassenattribute gehören zur Klasse und werden von allen Objekten geteilt.\n",
"\n",
"---\n",
"\n",
"### Properties\n",
"\n",
"Properties ermöglichen kontrollierten Zugriff auf Attribute, sehen aber aus wie normale Variablen.\n",
"\n",
"---\n",
"\n",
"### Klassenmethoden\n",
"\n",
"Klassenmethoden erhalten cls und können auf Klassenattribute zugreifen.\n",
"\n",
"---\n",
"\n",
"### Statische Methoden\n",
"\n",
"Statische Methoden erhalten weder self noch cls.\n",
"\n",
"---\n",
"\n",
"### Vererbung\n",
"\n",
"Vererbung ermöglicht Wiederverwendung von Code.\n",
"\n",
"---\n",
"\n",
"### Mehrfachvererbung\n",
"\n",
"Python erlaubt Vererbung von mehreren Klassen.\n",
"\n",
"---\n",
"\n",
"### Konstruktorverkettung\n",
"\n",
"Konstruktorverkettung bedeutet, dass Konstruktoren mehrerer Klassen nacheinander aufgerufen werden.\n",
"\n",
"---\n",
"\n",
"### Magic Methods\n",
"\n",
"Magic Methods definieren besonderes Verhalten, zum Beispiel für Operatoren oder print()."
],
"id": "91e7a78416a01a31"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## Zusammenfassung\n",
"\n",
"- Python-Klassen können Attribute und Methoden enthalten\n",
"- Klassenattribute gelten für alle Objekte einer Klasse\n",
"- Instanzattribute gehören zu einem bestimmten Objekt\n",
"- Properties verbinden Getter und Setter mit Variablenzugriff\n",
"- Python unterstützt Mehrfachvererbung\n",
"- super() und \\*args ermöglichen Konstruktorverkettung\n",
"- Magic Methods erlauben besondere Spracheigenschaften wie Operatoren"
],
"id": "55b53e324eca3645"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## Verständnisfragen\n",
"\n",
"- Was ist der Unterschied zwischen Klassenattribut und Instanzattribut?\n",
"- Warum wird super() bei Vererbung verwendet?\n",
"- Wofür wird \\*args in den Konstruktoren benötigt?\n",
"- Was passiert bei der Konstruktorverkettung?\n",
"- Wozu dient die Methode \\_\\_add\\_\\_?"
],
"id": "872a30edea3b0c7c"
}
],
"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
}
python/klassen.py
+12
View File
@@ -0,0 +1,12 @@
from computer import Computer
from telefon import Telefon
meinpc = Computer("Dell")
print(meinpc.bezeichnung)
meinpc.bezeichnung = "Asus"
print(meinpc.bezeichnung)
meinpc.ausgabe_anzahl()
meintelefon = Telefon("Vodafone")
print(meintelefon.netz)
meintelefon.klingeln(5)
python/lambda.ipynb
+451
View File
@@ -0,0 +1,451 @@
{
"cells": [
{
"metadata": {
"collapsed": true
},
"cell_type": "markdown",
"source": [
"# Funktionale Programmierung in Python\n",
"\n",
"## Ziel dieser Einheit\n",
"\n",
"In dieser Einheit lernst du:\n",
"\n",
"- was funktionale Programmierung bedeutet\n",
"- wie Lambda-Ausdrücke in Python funktionieren\n",
"- wie filter() verwendet wird\n",
"- wie map() verwendet wird\n",
"- wie mehrere funktionale Operationen kombiniert werden\n",
"- wie List Comprehensions als pythonische Alternative funktionieren"
],
"id": "aba2c4fa1f75f62d"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 1. Grundidee der funktionalen Programmierung\n",
"\n",
"Funktionale Programmierung bedeutet:\n",
"\n",
"- Wir verändern Daten nicht direkt\n",
"- Wir benutzen Funktionen, um neue Daten zu erzeugen\n",
"- Häufig genutzte Funktionen sind:\n",
" - filter() → filtern\n",
" - map() → umwandeln\n",
" - sum() → berechnen\n",
"\n",
"In diesem Beispiel arbeiten wir mit einer Liste von Zahlen."
],
"id": "5fe9a211e4e1f290"
},
{
"metadata": {},
"cell_type": "code",
"source": "zahlen = [1, 2, 3, 4, 5, 6]",
"id": "eb8147e500b5876e",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"\n",
"Die ursprüngliche Liste bleibt dabei unverändert.\n",
"Stattdessen erzeugen wir neue Listen mit den gewünschten Ergebnissen."
],
"id": "ce47b4e7ceac7b2b"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 2. Lambda-Ausdrücke\n",
"\n",
"Ein Lambda-Ausdruck ist eine kurze, anonyme Funktion.\n",
"\n",
"Anonym bedeutet:\n",
"\n",
"- die Funktion hat keinen eigenen Namen\n",
"- sie wird direkt dort definiert, wo sie gebraucht wird\n",
"\n",
"Beispiel:"
],
"id": "308f2ba46c30f8bd"
},
{
"metadata": {},
"cell_type": "code",
"source": "lambda x: x % 2 == 0",
"id": "36ecb9f8790e3ef3",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"\n",
"Bedeutung:\n",
"\n",
"- x ist die Variable für die Funktion\n",
"- x % 2 == 0 prüft, ob eine Zahl gerade ist\n",
"- das Ergebnis ist True oder False\n",
"\n",
"Vergleich mit Java:\n",
"\n",
" (x) -> x % 2 == 0\n",
"\n",
"In Java würde ein ähnlicher Lambda-Ausdruck also mit Pfeil geschrieben werden."
],
"id": "ab7b62549d06d131"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 3. Filtern mit filter()\n",
"\n",
"Zuerst sollen nur die geraden Zahlen aus der Liste ausgewählt werden."
],
"id": "4f313a6ccf2b179e"
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2026-07-22T08:15:25.729179Z",
"start_time": "2026-07-22T08:15:25.652826100Z"
}
},
"cell_type": "code",
"source": [
"gerade_zahlen = list(filter(lambda x: x % 2 == 0, zahlen))\n",
"\n",
"print(\"Gerade Zahlen:\", gerade_zahlen)"
],
"id": "405e64898d7dd020",
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Gerade Zahlen: [2, 4, 6]\n"
]
}
],
"execution_count": 10
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"\n",
"\n",
"Erklärung:\n",
"\n",
"- filter() bekommt eine Funktion und eine Liste\n",
"- die Funktion prüft jedes Element\n",
"- nur Elemente, bei denen die Funktion True zurückgibt, bleiben erhalten\n",
"- list() wandelt das Ergebnis wieder in eine Liste um\n",
"\n",
"In diesem Beispiel prüft:\n",
"\n",
" lambda x: x % 2 == 0\n",
"\n",
"ob eine Zahl gerade ist.\n",
"\n",
"Aus der Liste:\n",
"\n",
" [1, 2, 3, 4, 5, 6]\n",
"\n",
"wird dadurch:\n",
"\n",
" [2, 4, 6]"
],
"id": "a7786217eb1ebd0f"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"### Aufgabe zur Übung\n",
"Eine Liste mit den Zahlen von 1 bis 100 so filtern, dass alle Zahlen ausgegeben werden, die durch 12 oder 17 teilbar sind"
],
"id": "10bddadd2af9878"
},
{
"metadata": {},
"cell_type": "code",
"source": [
"zahlen_liste = []\n",
"for i in range (1, 101):\n",
" zahlen_liste.append(i)\n",
"\n",
"durch_12_oder_17_teilbar = list(filter(lambda x: x % 12 == 0 or x % 17 == 0, zahlen_liste))\n",
"print(durch_12_oder_17_teilbar)"
],
"id": "a06029e472a8f213",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 4. Umwandeln mit map()\n",
"\n",
"Als nächstes sollen alle Zahlen quadriert werden."
],
"id": "84ceeb61fc5b523a"
},
{
"metadata": {},
"cell_type": "code",
"source": [
"quadriere = lambda x: x * x\n",
"\n",
"quadrate = list(\n",
" map(quadriere, zahlen)\n",
")\n",
"\n",
"print(\"Quadrate:\", quadrate)"
],
"id": "5789adc3dd4af6f8",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"\n",
"\n",
"Erklärung:\n",
"\n",
"- map() wendet eine Funktion auf jedes Element an\n",
"- hier wird jede Zahl mit sich selbst multipliziert\n",
"- dadurch entsteht eine neue Liste mit den Quadraten\n",
"\n",
"Die Funktion:\n",
"\n",
" lambda x: x * x\n",
"\n",
"berechnet für jede Zahl ihr Quadrat.\n",
"\n",
"Aus:\n",
"\n",
" [1, 2, 3, 4, 5, 6]\n",
"\n",
"wird:\n",
"\n",
" [1, 4, 9, 16, 25, 36]"
],
"id": "7210ac5691299df5"
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"### Aufgabe zur Übung\n",
"Eine Map erstellen, die jede Zahl in einer Liste mit drei multipliziert:"
],
"id": "2885e847dce66b9b"
},
{
"metadata": {},
"cell_type": "code",
"source": [
"multipliziere_mit_drei = lambda x: 3 * x\n",
"\n",
"zahlen_mal_drei = list(map(multipliziere_mit_drei, zahlen))\n",
"print(zahlen_mal_drei)"
],
"id": "a327676c343bd9b1",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"## 5. Kombinieren von filter() und map()\n",
"\n",
"Funktionale Operationen können kombiniert werden.\n",
"\n",
"In diesem Beispiel sollen zuerst nur die geraden Zahlen gefiltert und danach quadriert werden."
],
"id": "ac187b86ff0d3bc5"
},
{
"metadata": {},
"cell_type": "code",
"source": [
"ergebnis = list(\n",
" map(\n",
" lambda x: x * x,\n",
" filter(lambda x: x % 2 == 0, zahlen)\n",
" )\n",
")\n",
"\n",
"print(\"Quadrate der geraden Zahlen:\", ergebnis)"
],
"id": "5c41c5c137fa4b65",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"\n",
"\n",
"Ablauf:\n",
"\n",
"1. filter() wählt nur gerade Zahlen aus\n",
"2. map() quadriert diese Zahlen\n",
"3. list() erzeugt daraus eine Liste\n",
"\n",
"Zwischenschritt:\n",
"\n",
" filter(lambda x: x % 2 == 0, zahlen)\n",
"\n",
"ergibt:\n",
"\n",
" [2, 4, 6]\n",
"\n",
"Danach wird mit map() quadriert:\n",
"\n",
" [4, 16, 36]\n",
"\n",
"## 6. Python-typische Schreibweise: List Comprehension\n",
"\n",
"Die gleiche Aufgabe kann in Python auch mit einer List Comprehension geschrieben werden."
],
"id": "1c43c327479ca804"
},
{
"metadata": {},
"cell_type": "code",
"source": [
"ergebnis_comp = [x * x for x in zahlen if x % 2 == 0]\n",
"\n",
"print(\"Mit List Comprehension:\", ergebnis_comp)"
],
"id": "a80de265be2ebfa5",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "markdown",
"source": [
"\n",
"\n",
"Erklärung:\n",
"\n",
"- Das ist die pythonischere Variante\n",
"- sie ist oft besser lesbar als map() und filter()\n",
"- sie kombiniert Filtern und Umwandeln in einer Zeile\n",
"\n",
"Die Struktur lautet:\n",
"\n",
" neuer_wert for element in liste if bedingung\n",
"\n",
"In unserem Beispiel:\n",
"\n",
" x * x for x in zahlen if x % 2 == 0\n",
"\n",
"Bedeutung:\n",
"\n",
"- gehe durch alle Zahlen in zahlen\n",
"- verwende nur Zahlen, die gerade sind\n",
"- berechne für jede dieser Zahlen x * x\n",
"\n",
"Das Ergebnis ist wieder:\n",
"\n",
" [4, 16, 36]\n",
"\n",
"\n",
"## 7. Wichtige Konzepte im Überblick\n",
"\n",
"### Funktionale Programmierung\n",
"\n",
"Funktionale Programmierung beschreibt Berechnungen mit Funktionen.\n",
"\n",
"Die ursprünglichen Daten werden dabei möglichst nicht verändert.\n",
"Stattdessen werden neue Daten erzeugt.\n",
"\n",
"\n",
"### Lambda-Ausdruck\n",
"\n",
"Ein Lambda-Ausdruck ist eine kurze Funktion ohne Namen.\n",
"\n",
"Er eignet sich besonders für kleine Funktionen, die nur einmal gebraucht werden.\n",
"\n",
"\n",
"### filter()\n",
"\n",
"filter() wählt Elemente aus einer Sammlung aus.\n",
"\n",
"Die übergebene Funktion muss True oder False zurückgeben.\n",
"\n",
"\n",
"### map()\n",
"\n",
"map() wandelt jedes Element einer Sammlung um.\n",
"\n",
"Die übergebene Funktion bestimmt, wie jedes Element verändert wird.\n",
"\n",
"\n",
"### List Comprehension\n",
"\n",
"List Comprehensions sind eine typische Python-Schreibweise.\n",
"\n",
"Sie sind oft lesbarer als verschachtelte map()- und filter()-Aufrufe.\n",
"\n",
"\n",
"## Zusammenfassung\n",
"\n",
"- Funktionale Programmierung arbeitet mit Funktionen statt direkter Veränderung von Daten\n",
"- Lambda-Ausdrücke sind kurze anonyme Funktionen\n",
"- filter() filtert Elemente anhand einer Bedingung\n",
"- map() wandelt Elemente um\n",
"- map() und filter() können kombiniert werden\n",
"- List Comprehensions sind in Python oft die bevorzugte Schreibweise\n",
"\n",
"\n",
"## Verständnisfragen\n",
"\n",
"- Was ist ein Lambda-Ausdruck?\n",
"- Wofür wird filter() verwendet?\n",
"- Wofür wird map() verwendet?\n",
"- Warum wird list() um filter() oder map() geschrieben?\n",
"- Was ist der Vorteil einer List Comprehension?"
],
"id": "239738006efd56b5"
}
],
"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
}
python/smartphone.py
+7
View File
@@ -0,0 +1,7 @@
from telefon import Telefon
from computer import Computer
# Vererbung (Python kann Mehrfachvererbung):
class Smartphone(Computer, Telefon):
def __init__(self, bezeichnung:str, netz:str, *args):
super().__init__(bezeichnung, netz, *args)
python/telefon.py
+20
View File
@@ -0,0 +1,20 @@
class Telefon:
def __init__(self, netz:str, *args):
self.__netz = netz
super().__init__(*args)
@property
def netz(self) -> str:
return self.__netz
@netz.setter
def netz(self, netz:str):
self.__netz = netz
# Python unterscheidet zwischen Klassenmethoden und statischen Methoden.
# Eine Klassenmethode kann auf Klassenattribute über cls zugreifen. Eine statische Methode kann das nicht.
@staticmethod
def klingeln(anzahl:int = 1):
print(anzahl * "*klingel*")
python/test.ipynb
+69
View File
@@ -0,0 +1,69 @@
{
"cells": [
{
"metadata": {},
"cell_type": "markdown",
"source": "# Test",
"id": "5f992ca0ee06c01c"
},
{
"metadata": {
"collapsed": true,
"ExecuteTime": {
"end_time": "2026-07-22T08:14:47.152767500Z",
"start_time": "2026-07-22T08:14:47.121874300Z"
}
},
"cell_type": "code",
"source": [
"a = 50\n",
"print(50)"
],
"id": "cc6e758282212d7a",
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"50\n"
]
}
],
"execution_count": 1
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2026-07-22T08:15:04.685063100Z",
"start_time": "2026-07-22T08:15:04.670671300Z"
}
},
"cell_type": "code",
"source": "a = a + 10",
"id": "7359f0aee5a53934",
"outputs": [],
"execution_count": 2
}
],
"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
}