Wie man in Python das richtige Entwurfsmuster auswählt, mit Beispielen

Entwurfsmuster sind bewährte Lösungen für häufige Probleme in der Softwareentwicklung. Sie bieten eine wiederverwendbare Vorlage zur Lösung von Designproblemen und verbessern so die Wartbarkeit und Flexibilität des Codes.

Aber woher wissen Sie bei so vielen verfügbaren Entwurfsmustern, welches Sie für ein bestimmtes Problem in Python implementieren sollten? In diesem Artikel untersuchen wir die Schritte zur Auswahl des richtigen Entwurfsmusters und stellen Beispiele für jedes Muster bereit, damit Sie diese besser verstehen und effektiv anwenden können.

1. Verstehen Sie das Problem

Der erste Schritt bei der Auswahl eines Entwurfsmusters besteht darin, das Problem, das Sie lösen möchten, klar zu verstehen. Stellen Sie sich folgende Fragen:

Was ist das erwartete Verhalten?
Was sind die Einschränkungen des Systems?
Was sind die möglichen Erweiterungs- oder Variationspunkte?

2. Kategorisieren Sie das Entwurfsmuster

Designmuster werden im Allgemeinen in drei Kategorien eingeteilt:

Kreativ: Betrifft die Erstellung von Objekten.
Strukturell: Betrifft die Zusammensetzung von Objekten.
Verhalten: Betrifft Interaktionen zwischen Objekten.
Die Identifizierung der Kategorie, die zu Ihrem Problem passt, kann dabei helfen, die Anzahl relevanter Muster einzugrenzen.

3. Wählen Sie das entsprechende Designmuster

Nachdem Sie das Problem und seine Kategorie verstanden haben, überprüfen Sie die Entwurfsmuster in dieser Kategorie, um dasjenige zu finden, das am besten zu Ihrer Situation passt. Bedenken Sie Folgendes:

Flexibilität: Bietet das Muster die nötige Flexibilität?
Komplexität: Führt es nicht zu unnötiger Komplexität?
Erweiterbarkeit: Erleichtert es zukünftige Erweiterungen?

1. Beispiele für Entwurfsmuster in Python Singleton Wann sollte man es verwenden? Wenn Sie sicherstellen müssen, dass eine Klasse nur eine Instanz hat, und einen globalen Zugriffspunkt auf diese Instanz bereitstellen müssen.

Beispiel in Python:
`Klasse SingletonMeta(Typ):
_instance = {}

def __call__(cls, *args, **kwargs):
    if cls not in cls._instance:
        cls._instance[cls] = super().__call__(*args, **kwargs)
    return cls._instance[cls]

Klasse Logger(metaclass=SingletonMeta):
def log(self, message):
print(f"[LOG]: {Nachricht}")

Verwenden

logger1 = Logger()
logger2 = Logger()

print(logger1 ist logger2) # Ausgabe: True

logger1.log("Singleton-Muster in Aktion.")
`
Warum funktioniert es?
SingletonMeta ist eine Metaklasse, die die Erstellung von Logger-Instanzen steuert. Wenn bereits eine Instanz vorhanden ist, wird diese zurückgegeben, um sicherzustellen, dass es nur eine Instanz gibt.

Fabrik
Wann sollte man es verwenden?
Wenn Sie eine übergeordnete Klasse mit mehreren untergeordneten Klassen haben und basierend auf den Eingabedaten eine der untergeordneten Klassen zurückgeben müssen.

Beispiel in Python:
`Klassenform:
def draw(self):
passieren

Klassenkreis (Form):
def draw(self):
print("Einen Kreis zeichnen.")

Klasse Quadrat (Form):
def draw(self):
print("Ein Quadrat zeichnen.")

def shape_factory(shape_type):
if shape_type == "circle":
return Circle()
elif shape_type == "square":
return Square()
sonst:
raise ValueError("Unbekannter Formtyp.")

Verwenden

shape = shape_factory("circle")
shape.draw() # Ausgabe: Einen Kreis zeichnen.
`
Warum funktioniert es?
Die Factory kapselt die Objekterstellungslogik und ermöglicht die Erstellung von Instanzen, ohne die zugrunde liegende Logik offenzulegen.

Beobachten
Wann sollte man es verwenden?
Wenn Sie ein Objekt (das Subjekt) haben, das mehrere andere Objekte (Beobachter) benachrichtigen muss, wenn eine Zustandsänderung auftritt.

Beispiel in Python:
`Klassenthema:
def init(self):
self._observers = []

def __call__(cls, *args, **kwargs):
    if cls not in cls._instance:
        cls._instance[cls] = super().__call__(*args, **kwargs)
    return cls._instance[cls]

Klassenbeobachter:
def update(self, message):
passieren

Klasse EmailObserver(Observer):
def update(self, message):
print(f"E-Mail-Benachrichtigung: {Nachricht}")

Klasse SMSObserver(Observer):
def update(self, message):
print(f"SMS-Benachrichtigung: {Nachricht}")

Verwenden

Betreff = Betreff()
subject.attach(EmailObserver())
subject.attach(SMSObserver())

subject.notify("Observer-Muster implementiert.")
`
Warum funktioniert es?
Das Subjekt führt eine Liste von Beobachtern und benachrichtigt sie über Änderungen, was eine entkoppelte Kommunikation ermöglicht.
Strategie
Wann sollte man es verwenden?
Wenn Sie mehrere Algorithmen zur Ausführung einer Aufgabe haben und diese dynamisch austauschen möchten.

Beispiel in Python:
`Typen importieren

Klasse TextProcessor:
def init(self, formatter):
self.formatter =types.MethodType(formatter, self)

def attach(self, observer):
    self._observers.append(observer)

def notify(self, message):
    for observer in self._observers:
        observer.update(message)

def Uppercase_formatter(self, text):
return text.upper()

def Lowercase_formatter(self, text):
return text.lower()

Verwenden

Prozessor = TextProcessor(uppercase_formatter)
print(processor.process("Hello World")) # Ausgabe: HELLO WORLD

processor.formatter =types.MethodType(lowercase_formatter, Prozessor)
print(processor.process("Hello World")) # Ausgabe: Hallo Welt
`
Warum funktioniert es?
Mit dem Strategiemuster können Sie den von einem Objekt verwendeten Algorithmus im Handumdrehen ändern, indem Sie dem Format eine neue Funktion zuweisen.

Dekorateur
Wann sollte man es verwenden?
Wenn Sie einem Objekt dynamisch neue Funktionen hinzufügen möchten, ohne seine Struktur zu ändern.

Beispiel in Python:
`defbold_decorator(func):
def wrapper():
return „“ func() „“
Rücksendeverpackung

def italic_decorator(func):
def wrapper():
return „“ func() „“
Rücksendeverpackung

@bold_decorator
@italic_decorator
def say_hello():
gib „Hallo“ zurück

Verwenden

print(say_hello()) # Ausgabe: Hallo
`

Warum funktioniert es?
Mit Dekoratoren können Sie eine Funktion umschließen, um Funktionalität hinzuzufügen, z. B. hier eine Formatierung, ohne die ursprüngliche Funktion zu ändern.

Anpassen
Wann sollte man es verwenden?
Wenn Sie eine vorhandene Klasse verwenden müssen, deren Schnittstelle jedoch nicht Ihren Anforderungen entspricht.

Beispiel in Python:
`Klasse EuropeanSocketInterface:
def Spannung(selbst): bestanden
def live(self): pass
def neutral(selbst): bestanden

Klasse EuropeanSocket(EuropeanSocketInterface):
Def. Spannung (selbst):
Rückgabe 230

def __call__(cls, *args, **kwargs):
    if cls not in cls._instance:
        cls._instance[cls] = super().__call__(*args, **kwargs)
    return cls._instance[cls]

Klasse USASocketInterface:
def Spannung(selbst): bestanden
def live(self): pass
def neutral(selbst): bestanden

Klassenadapter(USASocketInterface):
def init(self, European_socket):
self.european_socket = European_socket

def attach(self, observer):
    self._observers.append(observer)

def notify(self, message):
    for observer in self._observers:
        observer.update(message)

Verwenden

euro_socket = EuropeanSocket()
adapter = Adapter(euro_socket)
print(f"Spannung: {adapter.spannung()}V") # Ausgabe: Spannung: 110V
`
Der Adapter übersetzt die Schnittstelle einer Klasse in eine andere Schnittstelle, die der Client erwartet, und ermöglicht so die Kompatibilität zwischen inkompatiblen Schnittstellen.

Befehl
Wann sollte man es verwenden?
Wenn Sie eine Anfrage als Objekt kapseln möchten, können Sie Clients mit unterschiedlichen Anfragen, Warteschlangen oder Protokollierungen konfigurieren.

Beispiel in Python:
`class-Befehl:
defexecute(self):
passieren

Klasse LightOnCommand(Befehl):
def init(self, light):
self.light = Licht

def process(self, text):
    return self.formatter(text)

Klasse LightOffCommand(Befehl):
def init(self, light):
self.light = Licht

def live(self):
    return 1

def neutral(self):
    return -1

Klasse Licht:
def turn_on(self):
print("Licht eingeschaltet")

def voltage(self):
    return 110

def live(self):
    return self.european_socket.live()

def neutral(self):
    return self.european_socket.neutral()

Klasse RemoteControl:
def subscribe(self, command):
command.execute()

Verwenden

Licht = Licht()
on_command = LightOnCommand(light)
off_command = LightOffCommand(light)

remote = RemoteControl()
remote.submit(on_command) # Ausgabe: Licht eingeschaltet
remote.submit(off_command) # Ausgabe: Licht ausgeschaltet
`
Warum funktioniert es?
Das Befehlsmuster wandelt eine Operation in ein Objekt um, sodass Aktionen konfiguriert, in die Warteschlange gestellt oder abgebrochen werden können.

5. Fazit

Die Auswahl des richtigen Entwurfsmusters in Python erfordert ein klares Verständnis des zu lösenden Problems und der verfügbaren Muster. Indem Sie das Problem kategorisieren und die Vorteile jedes Musters analysieren, können Sie dasjenige auswählen, das die effektivste Lösung bietet.

Denken Sie daran, dass Entwurfsmuster Werkzeuge zur Verbesserung Ihres Codes sind und keine strengen Regeln, die es zu befolgen gilt. Setzen Sie sie mit Bedacht ein, um sauberen, wartbaren und skalierbaren Python-Code zu schreiben.

6. Zusätzliche Ressourcen

Bücher:
Designmuster: Elemente wiederverwendbarer objektorientierter Software von Erich Gamma et al.
Head First Design Patterns von Eric Freeman und Elisabeth Robson.
Websites:
Refactoring.Guru
Tauchen Sie ein in Designmuster
Danke fürs Lesen! Teilen Sie Ihre Erfahrungen mit Python-Designmustern gerne in den Kommentaren.

Das obige ist der detaillierte Inhalt vonWie man in Python das richtige Entwurfsmuster auswählt, mit Beispielen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!