[PYTHON] Ich habe über Entwurfsmuster (persönliches Memo) Teil 8 (Proxy-Muster, Befehlsmuster, Interpreter-Muster) 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 Ich habe über Entwurfsmuster (persönliches Memo) Teil 5 studiert Ich habe über Entwurfsmuster (persönliches Memo) Teil 6 studiert Ich habe über Entwurfsmuster (persönliches Memo) Teil 7 studiert
Proxy-Muster
--Proxy: Proxy
- Das Proxy-Objekt ist mit der Verarbeitung betraut, die von einer anderen Person als der Person selbst durchgeführt werden kann.
- Das Hauptobjekt übernimmt und verarbeitet die Verarbeitung, die vom Proxy-Objekt nicht ausgeführt werden kann.
Eigentlich verwenden
Gegenstand
- Herr Tanaka, der als Verkäufer mit Kunden verhandelt ――Ich habe einige Fragen von Kunden erhalten, aber einige konnten nicht beantwortet werden, deshalb habe ich sie mit nach Hause genommen »Ich habe mich bei meinem Chef, Mr. Suzuki, erkundigt und dem Kunden erneut geantwortet.
- Agent Objekt: Herr Tanaka
- Persönliches Objekt: Herr Suzuki
# -*- coding:utf-8 -*-
from abc import ABCMeta, abstractmethod
class Sales(metaclass=ABCMeta):
"""Verkaufsschnittstelle"""
def __init__(self):
pass
@staticmethod
@abstractmethod
def question1():
pass
@staticmethod
@abstractmethod
def question2():
pass
@staticmethod
@abstractmethod
def question3():
pass
class Suzuki(Sales):
"""Suzuki-san Klasse (persönliches Objekt)"""
@staticmethod
def question1():
print("Antwort 1")
@staticmethod
def question2():
print("Antwort 2")
@staticmethod
def question3():
print("Antwort 3")
class Tanaka(Sales):
"""Mr. Tanaka Klasse (Agentenobjekt)"""
@staticmethod
def question1():
print("Das ist "Antwort 1"")
@staticmethod
def question2():
print("Das ist "Antwort 2"")
@staticmethod
def question3():
print("das ist"")
#Ich kann nicht antworten, also fragen Sie Professor Suzuki
Suzuki().question3()
print("Wird sein")
class Client:
"""Kundenklasse"""
@staticmethod
def main():
#Frage 1
Tanaka().question1()
#Frage 2
Tanaka().question2()
#Frage 3
Tanaka().question3()
if __name__ == '__main__':
c = Client()
c.main()
Das ist "Antwort 1"
Das ist "Antwort 2"
das ist"
Antwort 3
Wird sein
Zusammenfassung der Proxy-Muster
Befehlsmuster
- Das Senden einer Anforderung an ein Objekt entspricht dem Aufrufen einer Methode für dieses Objekt.
- Der Inhalt der Anfrage wird dadurch ausgedrückt, welche Art von Argument an die Methode übergeben wird.
- Wenn Sie verschiedene Anfragen senden möchten, müssen Sie die Anzahl und Art der Argumente erhöhen.
- Machen Sie die Anfrage selbst zu einem Objekt und übergeben Sie dieses Objekt als Argument.
- Ein Muster, das eine Anforderung zu einem Befehlsobjekt macht und es Ihnen ermöglicht, mehrere Kombinationen davon zu verwenden.
Eigentlich verwenden
Gegenstand
――Im naturwissenschaftlichen Unterricht habe ich beschlossen, ein Experiment mit gesättigter Salzlösung durchzuführen: "Wie viele g Salz lösen sich in 100 g Wasser?" Das Verfahren ist wie folgt.
Experimentieren Sie, um eine gesättigte Salzlösung herzustellen, indem Sie 1 g Salz zu 100 g Wasser geben
- 100 g Wasser in das Becherglas geben
- 1 g Salz in das Becherglas geben
- Rühren
- Wenn alles vollständig geschmolzen ist, kehren Sie zu 2 zurück
- Wenn das Salz ungelöst bleibt, notieren Sie die Wassermenge, die Salzmenge und die Konzentration zu diesem Zeitpunkt.
—— Führen Sie außerdem ein Experiment durch: „Wie viele g Wasser werden benötigt, um alle 10 g Salz aufzulösen?“. Das Verfahren ist wie folgt.
Experimentieren Sie, um eine gesättigte Salzlösung herzustellen, indem Sie 10 g Wasser zu 10 g Salz geben
- 10 g Salz in das Becherglas geben
- 10 g Wasser in das Becherglas geben
- Rühren
- Wenn es nicht vollständig schmilzt, gehen Sie zurück zu 2.
- Wenn das Salz vollständig aufgelöst ist, notieren Sie die Wassermenge, die Salzmenge und die Konzentration zu diesem Zeitpunkt.
――Es ist schwierig, dass alle Schüler die Versuchsmethode beschreiben. Deshalb werde ich ein Versuchs-Set vorbereiten, das die Versuchsmethode enthält, und es den Schülern zum Experimentieren geben.
# -*- coding:utf-8 -*-
ADD_SALT = 1 #Beim Hinzufügen von Salz und Rühren
ADD_WATER = 2 #Beim Hinzufügen von Wasser und Rühren
class Beaker:
"""Versuchsaufbau"""
def __init__(self, water: float, salt: float):
self._water = water
self._salt = salt
self._melted = False
self.mix()
def mix(self):
"""
Methode zum Rühren der Lösung
Stellen Sie ein, ob es geschmolzen ist oder nicht geschmolzen ist
Die Konzentration der gesättigten Salzlösung bei Raumtemperatur beträgt etwa 26.4%
"""
if self.get_density() < 26.4:
self._melted = True
else:
self._melted = False
def is_melted(self) -> bool:
return self._melted
def add_salt(self, salt: float):
self._salt += salt
def add_water(self, water: float):
self._water += water
def get_density(self):
return (self._salt/(self._water + self._salt))*100
def note(self):
print(f"Wasser:{self._water}g")
print(f"Salz:{self._salt}g")
print(f"Konzentration:{self.get_density()}%")
def experiment(self, param: int):
"""Methode zur Durchführung des Experiments"""
if param == ADD_SALT:
#Bei der Durchführung eines Experiments zur Herstellung einer gesättigten Salzlösung durch Zugabe von jeweils 1 g Salz
#Fügen Sie Salz hinzu, während es vollständig aufgelöst ist
while self.is_melted():
self.add_salt(1) #1 g Salz hinzufügen
self.mix() #mischen
print("Experimentieren Sie, um jeweils 1 g Salz hinzuzufügen")
self.note()
elif param == ADD_WATER:
#Bei der Durchführung eines Experiments zur Herstellung einer gesättigten Salzlösung durch gleichzeitige Zugabe von 10 g Wasser
#Fügen Sie Wasser hinzu, während Sie ungelöst bleiben
while not self.is_melted():
self.add_water(10) #10 g Wasser hinzufügen
self.mix() #mischen
print("Experimentieren Sie, um jeweils 10 g Wasser hinzuzufügen")
self.note()
class Student:
"""Schüler zum Experimentieren"""
def main(self):
#Experimentieren Sie, um eine gesättigte Salzlösung herzustellen, indem Sie 1 g Salz zu 100 g Wasser geben
Beaker(100, 0).experiment(ADD_SALT)
#Experimentieren Sie, um eine gesättigte Salzlösung herzustellen, indem Sie 10 g Wasser zu 10 g Salz geben
Beaker(0, 10).experiment(ADD_WATER)
if __name__ == '__main__':
s = Student()
s.main()
- Wenn Sie ein zusätzliches Experiment durchführen möchten (ein Experiment zur Herstellung von 100 g Salzlösung mit einer Konzentration von 10%), müssen Sie die Methode ändern, um das Experiment der Experiment-Set-Klasse durchzuführen.
MAKE_SALT_WATER = 3 #Bei der Herstellung von Salzlösung
# ...
class Beaker:
# ...
def experiment(self, param: int):
"""Methode zur Durchführung des Experiments"""
if param == ADD_SALT:
# ...
elif param == ADD_WATER:
# ...
elif param == MAKE_SALT_WATER:
#Experimentieren Sie, um eine Salzlösung herzustellen
self.mix()
#Messen Sie die Konzentration und schreiben Sie sie in ein Notizbuch
print("Experimentieren Sie, um eine Salzlösung herzustellen")
self.note()
# ...
- Wenn Sie das Muster des Experiments erhöhen, fügen Sie der Experiment-Set-Klasse eine if-Anweisung hinzu, und Sie müssen die Parameter erhöhen, was nicht erweiterbar ist.
- Hören Sie auf, den Inhalt des Experiments mit int auszudrücken, und drücken Sie das Experiment selbst mit einem Befehlsobjekt aus.
- Indem die Versuchsgruppenklasse dem Versuchsinhalt, dh dem Befehlsobjekt, eine gemeinsame Schnittstelle gibt, kann sie die Methode ausführen, die das allgemeine Experiment ausführt, unabhängig von der Art des empfangenen Versuchsinhalts (Befehlsobjekt). ..
Experimenteller Code
# -*- coding:utf-8 -*-
from abc import ABCMeta, abstractmethod
class Beaker:
"""Versuchsaufbau"""
def __init__(self, water: float, salt: float):
self._water = water
self._salt = salt
self._melted = False
self.mix()
def mix(self):
"""
Methode zum Rühren der Lösung
Stellen Sie ein, ob es geschmolzen ist oder nicht geschmolzen ist
Die Konzentration der gesättigten Salzlösung bei Raumtemperatur beträgt etwa 26.4%
"""
if self.get_density() < 26.4:
self._melted = True
else:
self._melted = False
def is_melted(self) -> bool:
return self._melted
def add_salt(self, salt: float):
self._salt += salt
def add_water(self, water: float):
self._water += water
def get_density(self):
return (self._salt/(self._water + self._salt))*100
def note(self):
print(f"Wasser:{self._water}g")
print(f"Salz:{self._salt}g")
print(f"Konzentration:{self.get_density()}%")
Gemeinsame Schnittstelle
class Command(metaclass=ABCMeta):
"""Superklasse, die eine gemeinsame Schnittstelle für Klassen bietet, die Experimentinhalte darstellen"""
def __init__(self):
self._beaker = None
def set_beaker(self, beaker: Beaker):
self._beaker = beaker
def execute(self):
pass
Jede Experimentinhaltsklasse (Befehlsobjekt)
class AddSaltCommand(Command):
"""Befehlsklasse für Experimente, bei denen jeweils 1 g Salz hinzugefügt wird"""
def execute(self):
while self._beaker.is_melted():
self._beaker.add_salt(1)
self._beaker.mix()
print("Experimentieren Sie, um jeweils 1 g Salz hinzuzufügen")
self._beaker.note()
class AddWaterCommand(Command):
"""Befehlsklasse für Experimente, bei denen jeweils 10 g Wasser hinzugefügt werden"""
def execute(self):
while not self._beaker.is_melted():
self._beaker.add_water(10)
self._beaker.mix()
print("Experimentieren Sie, um jeweils 10 g Wasser hinzuzufügen")
self._beaker.note()
class MakeSaltWaterCommand(Command):
"""Befehlsklasse für Experimente zur Herstellung einer Salzlösung"""
def execute(self):
self._beaker.mix()
print("Experimentieren Sie, um eine Salzlösung herzustellen")
self._beaker.note()
Schülerklasse
class Student:
"""Schüler zum Experimentieren"""
def main(self):
add_salt = AddSaltCommand()
add_salt.set_beaker(Beaker(100, 0)) #Bereiten Sie ein Becherglas mit 100 g Wasser vor
add_water = AddWaterCommand()
add_water.set_beaker(Beaker(10, 10)) #Bereiten Sie ein Becherglas mit 10 g Salz vor
make_saltwater = MakeSaltWaterCommand()
make_saltwater.set_beaker(Beaker(90, 10)) #Bereiten Sie ein Becherglas vor, das 90 g Wasser und 10 g Salz enthält.
add_salt.execute() #Experimentieren Sie, um eine gesättigte Salzlösung herzustellen, indem Sie 1 g Salz zu 100 g Wasser geben
add_water.execute() #Experimentieren Sie, um eine gesättigte Salzlösung herzustellen, indem Sie 10 g Wasser zu 10 g Salz geben
make_saltwater.execute() # 10%Experimentieren Sie, um 100 g Salzlösung herzustellen
- Durch Anwenden des Befehlsmusters können Sie verschiedene Experimente hinzufügen, ohne den Quellcode des Experimentiersatzes zu ändern. ――Es ist auch möglich, ein neues Experiment zu erstellen, indem vorhandene Experimentinhalte kombiniert werden.
- Wenn Sie die Ausführungsmethode des vorhandenen Versuchsinhalts in der Ausführungsmethode des neuen Versuchsinhalts beschreiben, wird bei Ausführung des neuen Versuchsinhalts auch der vorhandene Versuchsinhalt in der beschriebenen Reihenfolge ausgeführt. ――Die Wiederverwendbarkeit ist ebenfalls hoch.
Zusammenfassung der Befehlsmuster
Interpretermuster
--Interpreter: Dolmetscher / Erklärer
- Es gibt Zeiten, in denen Sie eine Verarbeitung basierend auf den Analyseergebnissen des Inhalts einer in einem bestimmten Format geschriebenen Datei durchführen möchten. ――Das Interpreter-Muster ist das optimale Muster, um die Verarbeitung gemäß dem durch ein solches "Analyseergebnis" erhaltenen Verfahren zu realisieren.
Eigentlich verwenden
Gegenstand
»Denken Sie darüber nach, wie man Cup Ramen macht
- Der Prozess ist wie folgt
- Geben Sie "Pulversuppe" in die Cup-Nudeln
- Gießen Sie heißes Wasser
- Warten Sie 3 Minuten
- Flüssige Suppe hinzufügen
- Der Syntaxbaum lautet wie folgt
--Versuchen Sie, "Prozess" und "Prozessziel" aus diesem Syntaxbaum zu extrahieren. ――Es gibt zwei Kategorien von "Verarbeitung": "Hinzufügen" und "3 Minuten warten". ――Das "Prozessziel" ist dagegen nicht nur "Suppe in Pulverform", "Nudeln", "heißes Wasser" und "flüssige Suppe", sondern auch "Suppe in Pulverform plus Nudeln" und "Suppe in Pulverform plus Nudeln". "Heißes Wasser hinzugefügt" und "Suppe in Pulverform plus Nudeln plus heißes Wasser für 3 Minuten" gelten ebenfalls als behandelt.
- Auf diese Weise enthält das "Verarbeitungsziel" auch das "Verarbeitungsergebnis". Um diese beiden gleichzusetzen, hat das Interpreter-Muster dieselbe Struktur wie das Composit-Muster.
# -*- coding:utf-8 -*-
from abc import ABCMeta, abstractmethod
class Operand(metaclass=ABCMeta):
"""Schnittstelle, die das Verarbeitungsziel darstellt"""
@abstractmethod
def get_operand_string(self):
pass
- Die Klasse, die "Verarbeitungsziel" und "Verarbeitungsergebnis" darstellt, implementiert diese Schnittstelle.
class Ingredient(Operand):
"""Klasse, die das Verarbeitungsziel darstellt"""
def __init__(self, operand_string: str):
self._operand_string = operand_string
def get_operand_string(self) -> str:
return self._operand_string
class Expression(Operand):
"""Klasse, die das Verarbeitungsergebnis darstellt"""
def __init__(self, operator):
"""Nimmt einen Operator, der den Verarbeitungsinhalt darstellt, als Argument"""
self._operand_string = None
self._operator = operator
def get_operand_string(self):
return self._operator.execute().get_operand_string()
- Die Schnittstelle und die Implementierungsklasse, die den Prozess darstellen, lauten wie folgt.
class Operator(metaclass=ABCMeta):
"""Schnittstelle, die die Verarbeitung darstellt"""
@abstractmethod
def execute(self):
pass
class Plus(Operator):
"""Eine Klasse, die den Prozess des Hinzufügens darstellt"""
def __init__(self, operand1: Operand, operand2: Operand):
self._operand1 = operand1
self._operand2 = operand2
def execute(self) -> Operand:
return Ingredient(f"{self._operand1.get_operand_string()}Wann{self._operand2.get_operand_string()}Hinzufügen")
class Wait(Operator):
"""Eine Klasse, die den Prozess des "Wartens" darstellt"""
def __init__(self, minute: int, operand: Operand):
self._minute = minute
self._operand = operand
def execute(self) -> Operand:
return Ingredient(f"{self._operand.get_operand_string()}Zu{self._minute}Was wurde platziert")
――Wenn Sie es ausführen, sieht es so aus
if __name__ == '__main__':
#Material
material1 = Ingredient("Nudeln")
material2 = Ingredient("Pulversuppe")
material3 = Ingredient("heißes Wasser")
material4 = Ingredient("Flüssige Suppe")
#Prozess
#Fügen Sie Nudeln und Suppenpulver hinzu
step1 = Plus(material1, material2).execute()
#Heißes Wasser hinzufügen
step2 = Plus(step1, material3).execute()
#Warten Sie 3 Minuten
step3 = Wait(3, step2).execute()
#Fügen Sie flüssige Suppe hinzu
step4 = Plus(step3, material4).execute()
print(f"{step4.get_operand_string()}: Das ist Cup Ramen!")
Nudeln und Suppenpulver hinzugefügt, 3 Minuten lang heißes Wasser hinzugefügt und flüssige Suppe hinzugefügt: Das ist eine Tasse Ramen!
- Im Interpreter-Muster wird eine grammatikalische Regel von einer Klasse ausgedrückt.
- Im Beispielfall werden die Prozesse wie "add" und "wait" in einer Klasse ausgedrückt, und es ist möglich, die Prozesse gemäß dem Analyseergebnis der Syntax auszuführen.
Zusammenfassung der Interpreter-Muster
abschließend
»Endlich ist alles vorbei ――Wenn Sie diese Dinge nicht beachten, um sie im eigentlichen Geschäft zu verwenden, werden Sie anscheinend verdammten Code in Massenproduktion produzieren. ――Ich fand heraus, dass ich üben musste, indem ich es immer wieder las und in verschiedenen Mustern schrieb.
- ** Es ist noch ein langer Weg, bis Sie guten Code schreiben können ** ...
Recommended Posts