09 – Module & OOP | Python Classic

Lernziele dieses Kapitels

Du importierst Module aus der Python-Standardbibliothek
Du erstellst eigene Module und verstehst __name__ == '__main__'
Du definierst Klassen mit Attributen und Methoden
Du baust PyBuddy als Klasse mit Vererbung

Module importieren

Python hat eine riesige Standardbibliothek — fertige Werkzeuge für Mathe, Zufallszahlen, Datum, JSON und mehr. Du musst das Rad nicht neu erfinden!

import math — Mathematische Funktionen
import random — Zufallszahlen
import datetime — Datum und Uhrzeit
from math import sqrt — Nur eine Funktion importieren
import random as rnd — Alias vergeben

import random
import math
from datetime import datetime

# Zufallszahl
wurf = random.randint(1, 6)
print(f"Würfel: {wurf}")

# Wurzel
print(math.sqrt(16))  # 4.0

# Aktuelles Datum
jetzt = datetime.now()
print(jetzt.strftime("%d.%m.%Y %H:%M"))

# Alias
import random as rnd
print(rnd.choice(["Kopf", "Zahl"]))

Ausgabe

Würfel: 4 4.0 30.05.2026 14:30 Kopf

Du kennst bereits JavaScript aus dem JS-Quest. Hier ist der direkte Vergleich:

Python

import random
import math
from datetime import datetime

JavaScript

// JavaScript (Node.js):
const random = require('crypto');
const math = Math;
const now = new Date();

Merke: Python: import modul lädt Module. JavaScript (Node.js): require() oder ES6 import. Python's Standardbibliothek ist besonders umfangreich.

Eigene Module erstellen

Jede .py-Datei ist ein Modul! Du kannst Funktionen in eine Datei schreiben und sie in anderen Dateien importieren. Der Code unter if __name__ == '__main__': läuft nur, wenn die Datei direkt ausgeführt wird — nicht beim Import.

# Datei: hilfen.py
def durchschnitt(zahlen):
    """Berechnet den Durchschnitt einer Zahlenliste."""
    return sum(zahlen) / len(zahlen)

def max_wert(a, b):
    return a if a > b else b

if __name__ == "__main__":
    # Test-Code, der nur beim direkten Ausführen läuft
    print(durchschnitt([1, 2, 3, 4, 5]))

# Datei: main.py
import hilfen

noten = [2, 3, 1, 4, 2]
print(f"Durchschnitt: {hilfen.durchschnitt(noten):.2f}")
print(f"Größer: {hilfen.max_wert(10, 25)}")

Ausgabe

Durchschnitt: 2.40 Größer: 25

Klassen und Objekte

Mit Klassen erstellst du eigene Datentypen. Eine Klasse ist wie ein Bauplan für Objekte. __init__ ist der Konstruktor — er wird beim Erstellen aufgerufen. self referenziert das aktuelle Objekt.

class Spieler:
    """Repräsentiert einen Spieler."""
    
    def __init__(self, name, level=1):
        self.name = name
        self.level = level
        self.xp = 0
    
    def level_up(self):
        self.level += 1
        self.xp = 0
        return f" {self.name} ist jetzt Level {self.level}!"
    
    def __str__(self):
        return f"{self.name} (Level {self.level}, {self.xp} XP)"

# Objekt erstellen
p1 = Spieler("PyKnight", 3)
print(p1)
print(p1.level_up())
print(p1)

Ausgabe

PyKnight (Level 3, 0 XP) PyKnight ist jetzt Level 4! PyKnight (Level 4, 0 XP)

Du kennst bereits JavaScript aus dem JS-Quest. Hier ist der direkte Vergleich:

Python

class Spieler:
    def __init__(self, name):
        self.name = name

JavaScript

class Spieler {
    constructor(name) {
        this.name = name;
    }
}

Merke: Python: __init__(self, ...) ist der Konstruktor. JavaScript: constructor(...). self in Python ist this in JS.

Vererbung

Mit Vererbung erstellst du spezialisierte Klassen, die Eigenschaften und Methoden einer Eltern-Klasse übernehmen. Das spart Code und macht ihn übersichtlicher.

# Eltern-Klasse
class Charakter:
    def __init__(self, name, hp):
        self.name = name
        self.hp = hp
    
    def ist_am_leben(self):
        return self.hp > 0

# Kind-Klasse
class Magier(Charakter):
    def __init__(self, name, hp, mana):
        super().__init__(name, hp)
        self.mana = mana
    
    def zaubern(self, ziel):
        if self.mana >= 10:
            self.mana -= 10
            return f" {self.name} zaubert auf {ziel}!"
        return " Nicht genug Mana!"

m = Magier("Gandalf", 100, 50)
print(m.ist_am_leben())  # True (von Charakter geerbt)
print(m.zaubern("Drache"))
print(f"Mana: {m.mana}")

Ausgabe

True Gandalf zaubert auf Drache! Mana: 40

Du kennst bereits JavaScript aus dem JS-Quest. Hier ist der direkte Vergleich:

Python

class Magier(Charakter):
    def __init__(self, name, hp, mana):
        super().__init__(name, hp)
        self.mana = mana

JavaScript

class Magier extends Charakter {
    constructor(name, hp, mana) {
        super(name, hp);
        this.mana = mana;
    }
}

Merke: Python: class Kind(Eltern) und super().__init__(). JavaScript: class Kind extends Eltern und super(). Fast identisch!

Magic Methods

Magic Methods (oder Dunder-Methods) beginnen und enden mit zwei Unterstrichen. Sie ermöglichen es, Operatoren und eingebaute Funktionen für deine Klassen anzupassen.

class Inventar:
    def __init__(self):
        self.items = []
    
    def add(self, item):
        self.items.append(item)
    
    def __len__(self):
        return len(self.items)
    
    def __contains__(self, item):
        return item in self.items
    
    def __str__(self):
        return f"Inventar({len(self.items)} Items): {', '.join(self.items)}"

inv = Inventar()
inv.add("Schwert")
inv.add("Schild")

print(len(inv))           # 2
print("Schwert" in inv)  # True
print(inv)                # Inventar(2 Items): Schwert, Schild

Ausgabe

2 True Inventar(2 Items): Schwert, Schild

Erstelle hilfen.py mit 3 Funktionen (z.B. flaeche_rechteck, umfang_kreis, durchschnitt). Importiere sie in main.py und teste sie.

Erstelle hilfen.py
Schreibe 3 Hilfsfunktionen
Erstelle main.py
Importiere und teste die Funktionen

Hinweis: # hilfen.py import math def flaeche(a, b): return a * b def umfang(r): return 2 * math.pi * r def durchschnitt(l): return sum(l) / len(l) # main.py import hilfen print(hilfen.flaeche(5, 3)) print(hilfen.durchschnitt([1, 2, 3, 4, 5]))

# hilfen.py
import math

def flaeche(a, b):
    return a * b

def umfang(r):
    return 2 * math.pi * r

def durchschnitt(l):
    return sum(l) / len(l)

# main.py
import hilfen
print(hilfen.flaeche(5, 3))
print(hilfen.durchschnitt([1, 2, 3, 4, 5]))

Erstelle eine Klasse Charakter mit Name, HP und Level. Erstelle eine Unterklasse Heiler mit einer heilen()-Methode, die HP wiederherstellt.

Erstelle rpg.py
Erstelle Klasse Charakter
Erstelle Unterklasse Heiler
Implementiere heilen() mit Mana-Kosten

Hinweis: class Charakter: def __init__(self, name, hp): self.name = name self.hp = hp self.max_hp = hp class Heiler(Charakter): def __init__(self, name, hp, mana): super().__init__(name, hp) self.mana = mana def heilen(self, ziel): if self.mana >= 20: self.mana -= 20 ziel.hp = min(ziel.hp + 30, ziel.max_hp) return f" {ziel.name} geheilt!" return " Kein Mana!" p = Charakter("Krieger", 100) h = Heiler("Heiler", 80, 50) p.hp -= 40 print(h.heilen(p)) print(f"HP: {p.hp}")

class Charakter:
    def __init__(self, name, hp):
        self.name = name
        self.hp = hp
        self.max_hp = hp

class Heiler(Charakter):
    def __init__(self, name, hp, mana):
        super().__init__(name, hp)
        self.mana = mana
    
    def heilen(self, ziel):
        if self.mana >= 20:
            self.mana -= 20
            ziel.hp = min(ziel.hp + 30, ziel.max_hp)
            return f" {ziel.name} geheilt!"
        return " Kein Mana!"

p = Charakter("Krieger", 100)
h = Heiler("Heiler", 80, 50)
p.hp -= 40
print(h.heilen(p))
print(f"HP: {p.hp}")

PyBuddy wird zur Klasse! Er soll einen Namen haben, den Nutzer begrüßen können und einen Befehl verarbeiten. Nutze __init__ und Methoden.

Öffne pybuddy/main.py
Erstelle Klasse PyBuddy
Implementiere __init__, begruesse(), status()
Teste die Methoden

Hinweis: # pybuddy/main.py class PyBuddy: def __init__(self, name): self.name = name self.version = "1.0" def begruesse(self, nutzer): return f" Hallo {nutzer}! Ich bin {self.name} v{self.version}." def status(self): return f" {self.name} läuft einwandfrei." bot = PyBuddy("PyBuddy") print(bot.begruesse("Max")) print(bot.status())

# pybuddy/main.py
class PyBuddy:
    def __init__(self, name):
        self.name = name
        self.version = "1.0"
    
    def begruesse(self, nutzer):
        return f" Hallo {nutzer}! Ich bin {self.name} v{self.version}."
    
    def status(self):
        return f" {self.name} läuft einwandfrei."

bot = PyBuddy("PyBuddy")
print(bot.begruesse("Max"))
print(bot.status())

Didaktische Pause

In League of Legends hat jeder Champion eine Basisklasse mit HP, Mana und Position. Jeder spezielle Champion (Kind-Klasse) erbt diese Eigenschaften und fügt eigene Fähigkeiten hinzu — genau wie die Vererbung, die du gerade gelernt hast!

Zusammenfassung

import math, random, datetime — Standardbibliothek nutzen
Jede .py-Datei ist ein Modul mit __name__ == '__main__'
class Name: → Klasse mit __init__ und Methoden
Vererbung: class Kind(Eltern) mit super()
Magic Methods machen Klassen pythonic

Module & OOP

Lernziele dieses Kapitels

Module importieren

Eigene Module erstellen

Klassen und Objekte

Vererbung

Magic Methods

Warm-Up: Eigenes Hilfsmodul

Challenge: RPG-Charakter-System

PyBuddy-Checkpoint: PyBuddy-Klasse

Zusammenfassung