Python Polymorphism

Python Polymorphism: Polymorphismus ist ein zentrales Konzept der objektorientierten Programmierung, das es ermöglicht, dass verschiedene Klassen über dieselbe Schnittstelle interagieren können. In Python bezieht sich Polymorphismus insbesondere darauf, dass eine Methode in verschiedenen Klassen unterschiedlich implementiert werden kann, während sie den gleichen Namen behält. Dies fördert die Flexibilität und Wiederverwendbarkeit des Codes.

1. Arten von Polymorphismus

Es gibt zwei Hauptarten von Polymorphismus in Python:

• Methodenüberladung: Dies ist die Fähigkeit, mehrere Methoden mit dem gleichen Namen, aber unterschiedlichen Parametern zu definieren. Python unterstützt dies nicht nativ, bietet jedoch Alternativen wie Standardwerte und Variablenargumente.
• Methodenüberschreibung: Dies ist die Fähigkeit einer Unterklasse, eine Methode der Oberklasse zu überschreiben, um spezifisches Verhalten bereitzustellen.

2. Methodenüberschreibung

Bei der Methodenüberschreibung implementiert eine Unterklasse eine Methode mit dem gleichen Namen wie in der Oberklasse, um das Verhalten zu ändern.

Beispiel

class Tier:
    def sprechen(self):
        return "Ein Tier macht Geräusche."

class Hund(Tier):
    def sprechen(self):
        return "Wuff!"

class Katze(Tier):
    def sprechen(self):
        return "Miau!"

def tier_sprechen(tier):
    print(tier.sprechen())

mein_hund = Hund()
mein_katze = Katze()

tier_sprechen(mein_hund)  # Ausgabe: Wuff!
tier_sprechen(mein_katze)  # Ausgabe: Miau!

In diesem Beispiel haben sowohl Hund als auch Katze die Methode sprechen() aus der Oberklasse Tier überschrieben, um spezifisches Verhalten bereitzustellen. Die Funktion tier_sprechen() demonstriert den Polymorphismus, indem sie verschiedene Tierobjekte verarbeitet.

3. Polymorphismus mit Funktionsparametern

Polymorphismus ermöglicht es Ihnen, Funktionen zu erstellen, die mit verschiedenen Objekten arbeiten können, solange diese Objekte die erforderlichen Methoden implementieren.

Beispiel

class Vogel:
    def fliegen(self):
        return "Ich fliege!"

class Flugzeug:
    def fliegen(self):
        return "Ich bin ein Flugzeug und fliege hoch!"

def fliegen_lassen(objekt):
    print(objekt.fliegen())

mein_vogel = Vogel()
mein_flugzeug = Flugzeug()

fliegen_lassen(mein_vogel)     # Ausgabe: Ich fliege!
fliegen_lassen(mein_flugzeug)  # Ausgabe: Ich bin ein Flugzeug und fliege hoch!

Hier sehen Sie, dass sowohl Vogel als auch Flugzeug eine Methode fliegen() haben. Die Funktion fliegen_lassen() kann mit beiden Objekten arbeiten, da sie die gleiche Schnittstelle bereitstellen.

4. Polymorphismus mit Operatoren

In Python können auch Operatoren polymorph sein. Zum Beispiel können benutzerdefinierte Klassen die Methoden __add__, __sub__ usw. überschreiben, um Operatoren für ihre Objekte zu definieren.

Beispiel

class Punkt:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, anderer):
        return Punkt(self.x + anderer.x, self.y + anderer.y)

p1 = Punkt(1, 2)
p2 = Punkt(3, 4)
p3 = p1 + p2  # Verwendung des + Operators

print(f"Punkt 3: ({p3.x}, {p3.y})")  # Ausgabe: Punkt 3: (4, 6)

5. Polymorphismus mit Abstrakten Klassen

Abstrakte Klassen ermöglichen die Definition von Methoden, die in Unterklassen implementiert werden müssen. Dadurch wird Polymorphismus erreicht, da alle Unterklassen eine gemeinsame Schnittstelle implementieren.

Beispiel

from abc import ABC, abstractmethod

class Fahrzeug(ABC):
    @abstractmethod
    def fahren(self):
        pass

class Auto(Fahrzeug):
    def fahren(self):
        return "Das Auto fährt."

class Fahrrad(Fahrzeug):
    def fahren(self):
        return "Das Fahrrad fährt."

def fahrzeug_fahren(fahrzeug):
    print(fahrzeug.fahren())

mein_auto = Auto()
mein_fahrrad = Fahrrad()

fahrzeug_fahren(mein_auto)      # Ausgabe: Das Auto fährt.
fahrzeug_fahren(mein_fahrrad)   # Ausgabe: Das Fahrrad fährt.

Häufig gestellte Fragen