J'ai étudié les modèles de conception (mémo personnel), partie 8 (modèle proxy, modèle de commande, modèle d'interprétation)
introduction
Cet article est un mémo d'étude personnel. J'écris un article motivé par l'obsession que ce que j'entre doit être une sortie. J'écris cet article sur Qiita avec l'espoir que quelqu'un qui le connaît pourra signaler les erreurs et donner des conseils.
Je vis une vie professionnelle en tant qu'ingénieur, mais je n'ai pas bien appris les modèles de conception, alors j'ai essayé d'étudier.
Ce qui est décrit ici https://github.com/ck-fm0211/notes_desigh_pattern Je télécharge sur.
Journal passé
J'ai étudié les modèles de conception (mémo personnel) Partie 1 J'ai étudié les modèles de conception (mémo personnel) Partie 2 J'ai étudié les modèles de conception (mémo personnel) Partie 3 J'ai étudié les modèles de conception (mémo personnel) Partie 4 J'ai étudié les modèles de conception (mémo personnel) Partie 5 J'ai étudié les modèles de conception (mémo personnel) Partie 6 J'ai étudié les modèles de conception (mémo personnel) Partie 7
Modèle proxy
--Proxy: Proxy
- L'objet proxy est chargé d'un traitement qui peut être effectué par une personne autre que la personne elle-même. --L'objet principal prend le relais et traite le traitement qui ne peut pas être effectué par l'objet proxy.
En fait utiliser
Matière
- M. Tanaka, qui négocie avec les clients en tant que vendeur ――J'ai reçu des questions de clients, mais certaines d'entre elles n'ont pas pu trouver de réponse, alors je les ai ramenées à la maison «J'ai vérifié avec mon patron, M. Suzuki, et j'ai de nouveau répondu au client.
- Objet agent: M. Tanaka
- Objet personnel: M. Suzuki
# -*- coding:utf-8 -*-
from abc import ABCMeta, abstractmethod
class Sales(metaclass=ABCMeta):
"""Interface de vente"""
def __init__(self):
pass
@staticmethod
@abstractmethod
def question1():
pass
@staticmethod
@abstractmethod
def question2():
pass
@staticmethod
@abstractmethod
def question3():
pass
class Suzuki(Sales):
"""Classe Suzuki-san (objet personnel)"""
@staticmethod
def question1():
print("Réponse 1")
@staticmethod
def question2():
print("Réponse 2")
@staticmethod
def question3():
print("Réponse 3")
class Tanaka(Sales):
"""Classe M. Tanaka (objet agent)"""
@staticmethod
def question1():
print("C'est la "Réponse 1"")
@staticmethod
def question2():
print("C'est la "Réponse 2"")
@staticmethod
def question3():
print("C'est"")
#Je ne peux pas répondre, alors demandez au professeur Suzuki
Suzuki().question3()
print("Sera")
class Client:
"""Classe de client"""
@staticmethod
def main():
#question 1
Tanaka().question1()
#question 2
Tanaka().question2()
#question 3
Tanaka().question3()
if __name__ == '__main__':
c = Client()
c.main()
C'est la "Réponse 1"
C'est la "Réponse 2"
C'est"
Réponse 3
Sera
Résumé des modèles de proxy
Modèle de commande
- Envoyer une demande à un objet revient à appeler une méthode sur cet objet.
- Le contenu de la requête est exprimé par le type d'argument passé à la méthode.
- Si vous souhaitez envoyer diverses requêtes, vous devez augmenter le nombre et les types d'arguments.
- Faites de la requête elle-même un objet et passez cet objet en argument.
- Un modèle qui transforme une requête en objet Command et vous permet d'en utiliser plusieurs combinaisons.
En fait utiliser
Matière
«Dans le cours de sciences, j'ai décidé de mener une expérience de solution saline saturée," Combien de g de sel se dissout dans 100 g d'eau? " La procédure est la suivante.
Expérience pour faire une solution saturée de sel en ajoutant 1 g de sel à 100 g d'eau
- Mettez 100g d'eau dans le bécher
- Mettez 1g de sel dans le bécher
- Remuer
- Si complètement fondu, revenir à 2
- Si le sel n'est pas dissous, enregistrez la quantité d'eau, la quantité de sel et la concentration à ce moment-là.
—— Faites également une expérience «Combien de g d'eau faut-il pour dissoudre les 10 g de sel». La procédure est la suivante.
Expérience pour faire une solution saturée de sel en ajoutant 10 g d'eau à 10 g de sel
- Mettez 10g de sel dans le bécher
- Mettez 10g d'eau dans le bécher
- Remuer
- S'il ne fond pas complètement, revenez à 2.
- Lorsque le sel est complètement dissous, enregistrez la quantité d'eau, la quantité de sel et la concentration à ce moment-là.
«Il est difficile de demander à tous les élèves de décrire la méthode d'expérimentation, je vais donc préparer un ensemble d'expériences contenant la méthode d'expérimentation et le donner aux élèves pour qu'ils expérimentent.
# -*- coding:utf-8 -*-
ADD_SALT = 1 #Lors de l'ajout de sel et de l'agitation
ADD_WATER = 2 #Lors de l'ajout d'eau et de l'agitation
class Beaker:
"""Ensemble expérimental"""
def __init__(self, water: float, salt: float):
self._water = water
self._salt = salt
self._melted = False
self.mix()
def mix(self):
"""
Méthode pour remuer la solution
Définir s'il a fondu ou s'il n'a pas fondu
La concentration de solution saline saturée à température ambiante est d'environ 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"eau:{self._water}g")
print(f"Sel:{self._salt}g")
print(f"concentration:{self.get_density()}%")
def experiment(self, param: int):
"""Méthode pour réaliser l'expérience"""
if param == ADD_SALT:
#Lors de la réalisation d'une expérience pour faire une solution saline saturée en ajoutant 1 g de sel à la fois
#Ajouter du sel complètement dissous
while self.is_melted():
self.add_salt(1) #Ajouter 1g de sel
self.mix() #mélanger
print("Expérience pour ajouter 1g de sel à la fois")
self.note()
elif param == ADD_WATER:
#Lors de la réalisation d'une expérience pour faire une solution saline saturée en ajoutant 10 g d'eau à la fois
#Ajouter de l'eau tout en restant non dissous
while not self.is_melted():
self.add_water(10) #Ajouter 10g d'eau
self.mix() #mélanger
print("Expérience pour ajouter 10 g d'eau à la fois")
self.note()
class Student:
"""Des étudiants à expérimenter"""
def main(self):
#Expérience pour faire une solution saturée de sel en ajoutant 1 g de sel à 100 g d'eau
Beaker(100, 0).experiment(ADD_SALT)
#Expérience pour faire une solution saturée de sel en ajoutant 10 g d'eau à 10 g de sel
Beaker(0, 10).experiment(ADD_WATER)
if __name__ == '__main__':
s = Student()
s.main()
- Si vous souhaitez effectuer une expérience supplémentaire (une expérience pour faire 100 g de solution saline avec une concentration de 10%), vous devez modifier la méthode de réalisation de l'expérience de la classe de l'ensemble d'expériences.
MAKE_SALT_WATER = 3 #Lors de la préparation d'une solution saline
# ...
class Beaker:
# ...
def experiment(self, param: int):
"""Méthode pour réaliser l'expérience"""
if param == ADD_SALT:
# ...
elif param == ADD_WATER:
# ...
elif param == MAKE_SALT_WATER:
#Expérience pour faire une solution saline
self.mix()
#Mesurez la concentration et écrivez-la dans un cahier
print("Expérience pour faire une solution saline")
self.note()
# ...
- Si vous augmentez le modèle de l'expérience, vous ajouterez une instruction if à la classe d'ensemble d'expériences, et vous devrez augmenter les paramètres, ce qui n'est pas extensible.
- Arrêtez d'exprimer le contenu de l'expérience avec int et exprimez l'expérience elle-même avec un objet Command.
- En donnant le contenu de l'expérience, c'est-à-dire l'objet Command, une interface commune, la classe d'ensemble d'expériences peut exécuter la méthode qui exécute l'expérience commune quel que soit le type de contenu d'expérience (objet Command) reçu. ..
Code expérimental
# -*- coding:utf-8 -*-
from abc import ABCMeta, abstractmethod
class Beaker:
"""Ensemble expérimental"""
def __init__(self, water: float, salt: float):
self._water = water
self._salt = salt
self._melted = False
self.mix()
def mix(self):
"""
Méthode pour remuer la solution
Définir s'il a fondu ou s'il n'a pas fondu
La concentration de solution saline saturée à température ambiante est d'environ 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"eau:{self._water}g")
print(f"Sel:{self._salt}g")
print(f"concentration:{self.get_density()}%")
Interface commune
class Command(metaclass=ABCMeta):
"""Super classe qui fournit une interface commune pour les classes qui représentent le contenu de l'expérience"""
def __init__(self):
self._beaker = None
def set_beaker(self, beaker: Beaker):
self._beaker = beaker
def execute(self):
pass
Chaque classe de contenu d'expérience (objet Command)
class AddSaltCommand(Command):
"""Classe de commande pour les expériences dans lesquelles 1 g de sel est ajouté à la fois"""
def execute(self):
while self._beaker.is_melted():
self._beaker.add_salt(1)
self._beaker.mix()
print("Expérience pour ajouter 1g de sel à la fois")
self._beaker.note()
class AddWaterCommand(Command):
"""Classe de commande pour les expériences dans lesquelles 10 g d'eau sont ajoutés à la fois"""
def execute(self):
while not self._beaker.is_melted():
self._beaker.add_water(10)
self._beaker.mix()
print("Expérience pour ajouter 10 g d'eau à la fois")
self._beaker.note()
class MakeSaltWaterCommand(Command):
"""Classe de commande pour les expériences pour faire une solution saline"""
def execute(self):
self._beaker.mix()
print("Expérience pour faire une solution saline")
self._beaker.note()
Classe étudiante
class Student:
"""Des étudiants à expérimenter"""
def main(self):
add_salt = AddSaltCommand()
add_salt.set_beaker(Beaker(100, 0)) #Préparez un bécher contenant 100g d'eau
add_water = AddWaterCommand()
add_water.set_beaker(Beaker(10, 10)) #Préparez un bécher contenant 10 g de sel
make_saltwater = MakeSaltWaterCommand()
make_saltwater.set_beaker(Beaker(90, 10)) #Préparez un bécher contenant 90 g d'eau et 10 g de sel.
add_salt.execute() #Expérience pour faire une solution saturée de sel en ajoutant 1 g de sel à 100 g d'eau
add_water.execute() #Expérience pour faire une solution saturée de sel en ajoutant 10 g d'eau à 10 g de sel
make_saltwater.execute() # 10%Expérience pour faire 100g de solution saline
- En appliquant le modèle de commande, vous pouvez ajouter diverses expériences sans changer le code source de l'ensemble d'expériences. ――Il est également possible de créer une nouvelle expérience en combinant des contenus d'expérience existants.
- Si vous décrivez la méthode d'exécution du contenu de l'expérience existant dans la méthode d'exécution du nouveau contenu de l'expérience, lorsque le nouveau contenu de l'expérience est exécuté, le contenu de l'expérience existant sera également exécuté dans l'ordre décrit. ―― La réutilisabilité est également élevée.
Résumé des modèles de commande
Modèle d'interprète
--Interprète: Interprète / Explicateur
- Il y a des moments où vous souhaitez effectuer un traitement basé sur les résultats de l'analyse du contenu d'un fichier écrit dans un format. ――Le modèle Interpreter est le modèle optimal pour réaliser le traitement selon la procédure obtenue par un tel "résultat d'analyse".
En fait utiliser
Matière
―― Réfléchissez à la façon de préparer des ramen
- Le processus est le suivant
- Mettez la "soupe en poudre" dans la tasse de nouilles
- Versez de l'eau chaude
- Attendez 3 minutes
- Ajouter la soupe liquide
-
L'arbre de syntaxe est le suivant
-
Essayez d'extraire le "processus" et la "cible du processus" de cet arbre de syntaxe. ――Il existe deux catégories de «traitement»: «ajouter» et «attendre 3 minutes». ――D'un autre côté, ce qui est classé comme «cible de processus» n'est pas seulement «soupe en poudre», «nouilles», «eau chaude» et «soupe liquide», mais aussi «soupe en poudre et nouilles ajoutées» et «soupe en poudre et nouilles ajoutées». «Eau chaude ajoutée» et «soupe en poudre plus nouilles plus eau chaude pendant 3 minutes» sont également considérées comme traitées.
-
De cette manière, la "cible de traitement" inclut également le "résultat du traitement", donc pour assimiler ces deux, le modèle Interpreter a la même structure que le modèle Composit.
# -*- coding:utf-8 -*-
from abc import ABCMeta, abstractmethod
class Operand(metaclass=ABCMeta):
"""Interface représentant la cible de traitement"""
@abstractmethod
def get_operand_string(self):
pass
- La classe qui représente la "cible du traitement" et le "résultat du traitement" implémente cette interface.
class Ingredient(Operand):
"""Classe qui représente la cible de traitement"""
def __init__(self, operand_string: str):
self._operand_string = operand_string
def get_operand_string(self) -> str:
return self._operand_string
class Expression(Operand):
"""Classe qui représente le résultat du traitement"""
def __init__(self, operator):
"""Prend un opérateur qui représente le contenu du traitement comme argument"""
self._operand_string = None
self._operator = operator
def get_operand_string(self):
return self._operator.execute().get_operand_string()
- L'interface et la classe d'implémentation qui représentent le processus sont les suivantes.
class Operator(metaclass=ABCMeta):
"""Interface représentant le traitement"""
@abstractmethod
def execute(self):
pass
class Plus(Operator):
"""Une classe qui représente le processus d'ajout"""
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()}Quand{self._operand2.get_operand_string()}Ajouter")
class Wait(Operator):
"""Une classe qui représente le processus "d'attente""""
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()}À{self._minute}Ce qui a été placé")
――Lorsque vous l'exécutez, cela ressemble à ceci
if __name__ == '__main__':
#Matériel
material1 = Ingredient("nouilles")
material2 = Ingredient("Soupe en poudre")
material3 = Ingredient("eau chaude")
material4 = Ingredient("Soupe liquide")
#Processus
#Ajouter les nouilles et la soupe en poudre
step1 = Plus(material1, material2).execute()
#Ajouter de l'eau chaude
step2 = Plus(step1, material3).execute()
#Attendez 3 minutes
step3 = Wait(3, step2).execute()
#Ajouter de la soupe liquide
step4 = Plus(step3, material4).execute()
print(f"{step4.get_operand_string()}: C'est la tasse de ramen!")
Nouilles et soupe en poudre ajoutées, eau chaude ajoutée pendant 3 minutes et soupe liquide ajoutée: c'est une tasse de ramen!
- Dans le modèle Interpreter, une règle grammaticale est exprimée par une classe.
- Dans le cas de l'exemple, les processus tels que "ajouter" et "attendre" sont exprimés dans une classe, et il est possible d'exécuter les processus selon le résultat de l'analyse de la syntaxe.
Résumé des modèles d'interprétation
en conclusion
――Enfin c'est fini ――Il semble que vous deviez en être très conscient pour les maîtriser dans les affaires réelles «J'ai découvert que je devais m'entraîner en le lisant encore et encore et en écrivant selon différents modèles.
- ** Il y a un long chemin à parcourir avant de pouvoir écrire un bon code ** ...
Recommended Posts