[PYTHON] Ich habe über Designmuster (persönliches Memo) Teil 5 (Verbundmuster, Dekorationsmuster, Besuchermuster) studiert.
Einführung
Dieser Artikel ist ein persönliches Studienmemo. Ich schreibe einen Artikel, der von der Besessenheit getrieben ist, dass das, was ich eingebe, ausgegeben werden muss. Ich schreibe diesen Artikel über Qiita in der Hoffnung, dass jemand, der damit vertraut ist, auf Fehler hinweisen und Ratschläge geben kann.
Ich lebe ein Berufsleben als Ingenieur, aber ich habe nicht richtig über Entwurfsmuster gelernt, also habe ich versucht zu studieren.
Was ist hier beschrieben https://github.com/ck-fm0211/notes_desigh_pattern Ich lade auf.
Vergangenes Protokoll
Ich habe über Entwurfsmuster (persönliches Memo) Teil 1 studiert Ich habe über Entwurfsmuster (persönliches Memo) Teil 2 studiert Ich habe über Entwurfsmuster (persönliches Memo) Teil 3 studiert Ich habe über Entwurfsmuster (persönliches Memo) Teil 4 studiert
Zusammengesetztes Muster
-Das zusammengesetzte Muster erleichtert die Handhabung rekursiver Strukturen, indem "der Inhalt mit dem Container identifiziert wird". --Beispiel: Dateisystem
- Wenn Sie alle Dateien und Ordner unter einem bestimmten Ordner löschen möchten, ist es praktisch, sie auf die gleiche Weise löschen zu können, ohne zu wissen, ob es sich um eine Datei oder einen Ordner handelt.
Eigentlich verwenden
Gegenstand
- Berücksichtigen Sie im Beispielfall Verzeichnisse und Dateien. --Versuchen Sie, eine Klasse zu erstellen, die Dateien und Verzeichnisse darstellt, ohne das zusammengesetzte Muster zu kennen.
class File:
def __init__(self, name):
self._name = name
def remove(self):
print("{}Wurde gelöscht".format(self._name))
- Die Directory-Klasse, die ein Verzeichnis darstellt, verwaltet die Objekte der Verzeichnisse und Dateien darunter als List-Objekt. Wenn die Methode remove aufgerufen wird, werden alle in der Liste enthaltenen Objekte gelöscht und anschließend selbst entfernt. Wird gelöscht
class Directory:
def __init__(self, name):
self._name = name
self._list = []
def add(self, arg):
self._list.append(arg)
def remove(self):
itr = iter(self._list)
i = 0
while next(itr, None) is not None:
obj = self._list[i]
if isinstance(obj, File):
obj.remove()
elif isinstance(obj, Directory):
obj.remove()
else:
print("Kann nicht gelöscht werden")
i += 1
print("{}Wurde gelöscht".format(self._name))
if __name__ == "__main__":
file1 = File("file1")
file2 = File("file2")
file3 = File("file3")
file4 = File("file4")
dir1 = Directory("dir1")
dir1.add(file1)
dir2 = Directory("dir2")
dir2.add(file2)
dir2.add(file3)
dir1.add(dir2)
dir1.add(file4)
dir1.remove()
- Bisher gibt es kein Problem. Es ist ärgerlich, wenn die Anfrage "Ich möchte, dass das Verzeichnis nicht nur Verzeichnisse und Dateien, sondern auch symbolische Links enthält" herauskommt.
- Im zusammengesetzten Muster werden der Inhalt des Containers und des Containers gleichgesetzt. Stellen Sie sicher, dass Sie eine Schnittstelle mit einem gemeinsamen Container und Inhalten zur Identifizierung implementieren.
- Lassen Sie Datei und Verzeichnis eine gemeinsame Schnittstelle DirectoryEntry implementieren
class DirectoryEntry(metaclass=ABCMeta):
@abstractmethod
def remove(self):
pass
- Definieren Sie nur die Methode remove in der DirectoryEntry-Schnittstelle
- Implementieren Sie die File-Klasse und die Directory-Klasse in Form der Implementierung.
class File(DirectoryEntry):
def __init__(self, name):
self._name = name
def remove(self):
print("{}Wurde gelöscht".format(self._name))
class Directory(DirectoryEntry):
def __init__(self, name):
self._name = name
self._list = []
def add(self, entry: DirectoryEntry):
self._list.append(entry)
def remove(self):
itr = iter(self._list)
i = 0
while next(itr, None) is not None:
obj = self._list[i]
obj.remove()
i += 1
print("{}Wurde gelöscht".format(self._name))
- Indem Sie sowohl die Directory-Klasse als auch die File-Klasse zu einer Klasse machen, die die DirectoryEntry-Klasse implementiert, spielt es bei der remove-Methode der Directory-Klasse keine Rolle, ob die tatsächliche Situation eine Instanz der File-Klasse oder eine Instanz der Directory-Klasse ist. Kann auch als DirectoryEntry-Objekt behandelt werden.
- Indem Sie das zusammengesetzte Muster auf diese Weise verwenden, können Sie die Notwendigkeit, die SymbolicLink-Klasse hinzuzufügen, flexibel handhaben. --SymbolicLink-Klasse sollte implementiert werden, um die DirectoryEntry-Schnittstelle zu implementieren.
class SymbolicLink(DirectoryEntry):
def __init__(self, name):
self._name = name
def remove(self):
print("{}Wurde gelöscht".format(self._name))
Zusammenfassung des zusammengesetzten Musters
Dekorationsmuster
- Das Dekorationsmuster bietet eine flexiblere Funktionserweiterungsmethode, indem der dekorative Rahmen mit dem Inhalt gleichgesetzt wird. ――Das Dekorationsmuster ist ein Bild von Überlagerungsfunktionen nacheinander. Es ist ein Bild, wie man eine Dekoration mit einer bestimmten Funktion auf den Kern legt.
Eigentlich verwenden
Gegenstand
――In der Eisdiele können Sie Beläge frei wählen. Der Kunde muss keine Beläge herstellen und kann mehrere Beläge in Schichten auswählen.
- Definieren Sie die folgende Schnittstelle als allgemeine Schnittstelle für Eiscreme.
class Icecream(metaclass=ABCMeta):
@abstractmethod
def get_name(self):
pass
@abstractmethod
def how_sweet(self):
pass
――Als Klassen mit diesen Schnittstellen werden Vanilleeisklasse, Matcha-Eisklasse usw. wie folgt bereitgestellt.
class VanillaIcecream(Icecream):
def get_name(self):
return "Vanille-Eiscreme"
def how_sweet(self):
return "Vanillegeschmack"
class GreenTeaIcecream(Icecream):
def get_name(self):
return "Matcha-Eis"
def how_sweet(self):
return "Matcha-Geschmack"
- Überlegen Sie, ob Sie diesen Implementierungsklassen für die Eiscreme-Oberfläche Toppings hinzufügen möchten.
- Bei Belägen sollten Sie Cashewnüsse und Mandelscheiben in Betracht ziehen.
- Vanilleeis mit Cashewnüssen und Vanilleeis mit Mandelscheiben sind erforderlich.
- Hier ändert sich durch Hinzufügen von Belägen der Name (Rückgabewert der Methode getName) und der Geschmack (Rückgabewert der Methode howSweet ()) nicht.
- Um diesen Anforderungen gerecht zu werden, kann eine Methode zur Erstellung einer Vanilleeisklasse für Cashewnüsse als Vanilleeis mit Cashewnüssen angesehen werden.
class CashewNutsVanillaIcecream(Icecream):
def get_name(self):
return "Cashewnuss-Vanilleeis"
――Diese Art der "Hinzufügung von Funktionen durch Vererbung" wird sehr fest.
- Wenn Sie beispielsweise eine Instanz möchten, die Matcha Ice Cream mit Cashewnüssen darstellt, benötigen Sie die Matcha Ice Cream Succession Class.
- Das Decorator-Muster ist effektiv, wenn Sie auf diese Weise verschiedene Funktionen flexibel hinzufügen möchten.
- Bereiten Sie im Entwurf mit dem Decorator-Muster eine andere Klasse vor, die nur den Teil der Erweiterungsfunktion enthält, geben Sie der Instanzvariablen dieser Klasse die zu erweiternde Instanz und implementieren Sie dieselbe Schnittstelle wie das Erweiterungsziel.
class CashewNutsToppingIcecream(Icecream):
def __init__(self, ice: Icecream):
self._ice = ice
def get_name(self):
name = "Cashewnüsse"
name += self._ice.get_name()
return name
def how_sweet(self):
return self._ice.how_sweet()
--CashewNutsToppingIcecream-Klasse ist eine Klasse, die Eiscreme mit Cashewnüssen darstellt. --Diese Klasse implementiert die Icecream-Schnittstelle und die Methode getName () gibt den Wert zurück, den getName () für die eigene Instanzvariable ice (Icecream-Instanz) plus die Zeichenfolge "Cashewnüsse" erhalten hat. Rückgabe als. Darüber hinaus gibt die howSweet () -Methode den Rückgabewert der howSweet () -Methode der Instanzvariablen ice unverändert zurück. ――Mit diesem Design, wie unten gezeigt, Vanilleeis mit Cashewnüssen, Matcha-Eis mit Cashewnüssen, Vanilleeis mit Mandelscheiben, Mandelscheiben und Cashewnüssen. Es ist möglich, verschiedene Kombinationen wie Vanilleeis mit beiden zu belegen.
ice1 = CashewNutsToppingIcecream(VanillaIcecream()) #Vanilleeis mit Cashewnuss-Belag
ice2 = CashewNutsToppingIcecream(GreenTeaIcecream()) #Matcha-Eis mit Cashewnuss-Belag
Zusammenfassung der Dekorationsmuster
Besuchermuster
- Im Besuchermuster ist es einfach, eine Verarbeitung hinzuzufügen, indem "Verarbeitung" im Besucherobjekt beschrieben wird, das der Besucher ist.
- Das zu verarbeitende Acceptor-Objekt muss die Methode accept (Besucherbesucher) implementieren, die das Besucherobjekt akzeptiert. --Beispiel ――Wenn Sie "Wasserwerke" für Ihr Haus ausführen möchten, rufen Sie einen "Wasserwerkunternehmer" in Ihrem Haus an, sagen Sie "Danke" und überlassen Sie alles uns. ―― Darüber hinaus können wir einen Elektroinstallateur oder einen Umbauunternehmer anrufen. ――Zu diesen Besuchern sagen Sie "Nun, danke" und überlassen den größten Teil der Arbeit Ihnen. ―― Es kann einige Unterschiede geben, wie Sie es uns überlassen, aber am Ende überlassen wir alles dem Verkäufer. ――Wenn ein neuer Dienstleister angezeigt wird, muss nicht jeder Haushalt seine Einstellung ändern. Rufen Sie einfach den Anbieter an und sagen Sie „Danke“. Um den neuen Dienst zu erhalten. in der Lage sein.
- Das Besuchermuster ist ein Muster, mit dem Sie die Verarbeitung hinzufügen können, ohne der Empfangsseite eine Verarbeitung hinzuzufügen.
Eigentlich verwenden
Gegenstand
- Nehmen Sie als Beispiel einen Hausbesuch. ――In jeder Familie, ob es sich um einen Lehrer oder eine Tante in der Nachbarschaft handelt, wenn ein Besucher zu Besuch ist und Sie kein Fremder sind, sagen Sie "Willkommen" und akzeptieren Sie es. ――Betrachten Sie zu diesem Zeitpunkt in Betracht, jede Familie als Akzeptor und den Lehrer als Besucher anzuwenden, indem Sie sie auf das Besuchermuster anwenden.
- Im Besuchermuster besucht der Besucher das Haus, das das Ziel des Besuchs ist. Die besuchte Familie akzeptiert den Lehrer und sagt: "Willkommen." ――Zur Zeit, egal ob Sie ein Neuling oder ein Veteran sind, ändert sich nichts an der Seite, die den Lehrer akzeptiert.
# -*- coding:utf-8 -*-
from abc import ABCMeta, abstractmethod
#Lehrerklasse
class Teacher(metaclass=ABCMeta):
def __init__(self, students):
self._students = students
@abstractmethod
def visit(self, student_home):
getattr(self, 'visit_' + student_home.__class__.__name__.lower())(student_home)
@abstractmethod
def get_student_list(self):
return self._students
#Anfängerlehrerklasse
class RookieTeacher(Teacher):
def __init__(self, students):
super().__init__(students)
def visit(self, student_home):
print("Hallo Lehrer")
super().visit(student_home)
@staticmethod
def visit_tanaka(tanaka):
tanaka.praised_child()
@staticmethod
def visit_suzuki(suzuki):
suzuki.reproved_child()
def get_student_list(self):
return self._students
#Heimklasse
class Home(metaclass=ABCMeta):
@staticmethod
def praised_child():
pass
@staticmethod
def reproved_child():
pass
#Akzeptanzschnittstelle
class TeacherAcceptor(metaclass=ABCMeta):
def accept(self, teacher: Teacher):
pass
#Suzukis Familie
class Suzuki(Home, TeacherAcceptor):
@staticmethod
def praised_child():
print("Suzuki Mutter: Oh, wenn du Lehrer bist, mach einen Witz")
@staticmethod
def reproved_child():
print("Suzuki Mutter: Das ist nur für mein Kind ...")
def accept(self, teacher: Teacher):
teacher.visit(self.__class__)
#Mr. Tanakas Familie
class Tanaka(Home, TeacherAcceptor):
@staticmethod
def praised_child():
print("Tanaka Mutter: Oh, wenn Sie Lehrer sind, machen Sie einen Witz")
@staticmethod
def reproved_child():
print("Tanaka Mutter: Auf keinen Fall, das ist nur für mein Kind ...")
def accept(self, teacher: Teacher):
teacher.visit(self.__class__)
if __name__ == "__main__":
rt = RookieTeacher(["suzuki", "tanaka"])
rt.visit(Suzuki())
rt.visit(Tanaka())
――Die Akzeptanzmethode jedes Haushalts nennt die Besuchsmethode des Lehrers (Besuchers), um eine gemeinsame Verarbeitung zu realisieren.
Zusammenfassung der Besuchermuster
Impressionen
――Ich denke, es gibt ein besseres Beispiel ...
Recommended Posts