[PYTHON] J'ai étudié les modèles de conception (mémo personnel) Partie 3 (modèle de prototype, modèle de constructeur)
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
Modèle de prototype
--Modèle de création d'une instance à partir du "prototype" préparé à l'avance --Exemple:
- Considérez un éditeur graphique qui n'a que la fonction "dessiner une ligne droite". ――Lorsque vous souhaitez dessiner une forme d'étoile avec cet éditeur de figures, vous pouvez créer une forme d'étoile en combinant des lignes droites. ――Si vous voulez beaucoup d'étoiles, vous devez répéter le processus de dessin d'une étoile en combinant des lignes droites. Dans un tel cas, si vous pouvez créer une forme d'étoile en enregistrant la première forme d'étoile créée (collection de lignes droites) en tant que "prototype" et en la copiant, le travail peut être simplifié.
En fait utiliser
Matière
--Je souhaite copier tout le contenu de l'instance
# -*- coding:utf-8 -*-
import copy
def main():
report1 = Report("title1", "content")
report2 = copy.deepcopy(report1)
print("title:", report1.title, report2.title)
print("content:", report1.content, report2.content)
class Report:
def __init__(self, title, content):
self.title = title
self.content = content
if __name__ == "__main__":
main()
title: title1 title1
content: content content
- Dans le cas de python, vous pouvez copier tout le contenu de l'instance en utilisant
copy.deepcopy. - Extension supplémentaire, essayez d'écrire un programme contenant une chaîne de caractères
# -*- coding:utf-8 -*-
import copy
class Product(object):
def use(self, s):
pass
def createClone(self):
pass
class Manager(object):
__showcase = dict()
def register(self, name, proto):
self.__showcase[name] = proto
def create(self, protoname):
p = self.__showcase.get(protoname)
return p.createClone()
class MessageBox(Product):
def __init__(self, decochar):
self.decochar = decochar
def use(self, s):
length = len(s)
deco = self.decochar * (length + 4)
print(deco)
print(self.decochar, s, self.decochar)
print(deco)
def createClone(self):
p = copy.deepcopy(self)
return p
class Underline(Product):
def __init__(self, ulchar):
self.ulchar = ulchar
def use(self, s):
length = len(s)
print('"%s"' % s)
print(" %s " % (self.ulchar * length))
def createClone(self):
p = copy.deepcopy(self)
return p
if __name__ == "__main__":
manager = Manager()
uline = Underline(".")
mbox = MessageBox("*")
sbox = MessageBox("/")
pbox = MessageBox("+")
uline2 = Underline("=")
manager.register("strong message", uline)
manager.register("star box", mbox)
manager.register("slash box", sbox)
manager.register("plus box", pbox)
manager.register("under line", uline2)
p1 = manager.create("strong message")
p1.use("Hello, world.")
p2 = manager.create("star box")
p2.use("Hello, world.")
p3 = manager.create("slash box")
p3.use("Hello, world.")
p4 = manager.create("plus box")
p4.use("Hello, world.")
p5 = manager.create("under line")
p5.use("Hello, world.")
--Résultat
"Hello, world."
.............
*****************
* Hello, world. *
*****************
/////////////////
/ Hello, world. /
/////////////////
+++++++++++++++++
+ Hello, world. +
+++++++++++++++++
"Hello, world."
=============
Résumé des modèles de prototypes
Modèle de constructeur
--Modèles pour obtenir des résultats dans différentes expressions dans le même processus de création --Exemple:
- Pensez à construire une maison ――Pour construire une maison, vous avez besoin de "quoi utiliser (= matériau)" et "comment construire (= processus)" --Il existe différents matériaux tels que le bois, le béton, les carreaux, etc. ――Il existe différents processus tels qu'une maison à un étage, à deux étages, inhabituelle, etc. ―― En préparant ces modèles à l'avance, vous pouvez répondre de manière flexible à la demande "Veuillez construire une maison avec des piliers en fer et des murs et des toits en béton en cours de construction d'une maison à un étage légèrement inhabituelle".
- Le modèle Builder rend la création d'un objet plus flexible en combinant une chose appelée Director qui détermine le "processus de création" et quelque chose appelé Builder qui détermine la "forme d'expression" et le "constructeur" de l'objet. Pattern pour pouvoir contrôler le "processus de création"
En fait utiliser
Matière
- Pensez à faire de l'eau salée et de l'eau sucrée dans une expérience scientifique
- La classe qui représente l'eau salée doit être indiquée dans le code source suivant (il en va de même pour la classe qui représente l'eau sucrée).
# -*- coding:utf-8 -*-
class SaltWater:
salt = None
water = None
@staticmethod
def salt_water(water, salt):
SaltWater.salt = salt
SaltWater.water = water
――Diverses exigences peuvent être prises en compte, mais en utilisant le modèle Builder, il sera possible de répondre aux exigences suivantes. ――Je veux utiliser la solution obtenue dans le même processus plusieurs fois. «Je veux faire de l'eau sucrée de la même manière.
-
Afin de répondre à ces demandes, le modèle Builder crée des classes qui sont Director et Builder.
-
Le rôle du directeur est de déterminer le "processus de création", et le rôle du constructeur est de déterminer la "forme d'expression".
-
Dans le cas de l'échantillon, le rôle du directeur est de déterminer que "40g de soluté sont dissous dans 100g de solvant, dont 70g sont jetés, puis 100g de solvant sont ajoutés, et enfin 15g de soluté sont ajoutés". ――Le rôle de Builder est de décider d'utiliser «l'eau comme solvant et le sel comme soluté».
-
L'interface Builder ressemble à ceci:
from abc import ABCMeta, abstractmethod
class Builder(metaclass=ABCMeta):
@abstractmethod
def add_solute(self):
pass
@abstractmethod
def add_solvent(self):
pass
@abstractmethod
def avandon_solution(self):
pass
@abstractmethod
def get_result(self):
pass
- L'interface Builder définit une méthode addSolute pour ajouter des solutés, une méthode addSolvent pour ajouter des solvants, une méthode abandonSolution pour éliminer les solutions et une méthode getResult pour obtenir des produits.
- La classe Director utilise l'interface Builder pour assembler des instances selon le "processus de création".
class Director:
def __init__(self):
self.builder = Builder()
def constract(self):
self.builder.add_solvent(100)
self.builder.add_solute(40)
self.builder.abandon_solution(70)
self.builder.add_solvent(100)
self.builder.add_solute(15)
- La classe Director sait seulement qu'elle reçoit quelque chose qui implémente l'interface Builder, elle n'a pas vraiment besoin de savoir quelle classe d'implémentation Builder est passée. Cela facilite le remplacement du Builder.
- La classe SaltWaterBuilder, qui est une classe d'implémentation Builder, est la suivante.
class SaltWaterBuilder(Builder):
def __init__(self):
self._salt_water = SaltWater(0,0)
def add_solute(self, salt_amount):
self._salt_water.salt += salt_amount
def add_solvent(self, water_amount):
self._salt_water.water += water_amount
def abandon_solution(self, salt_water_amount):
salt_delta = salt_water_amount * (self._salt_water.salt / (self._salt_water.salt + self._salt_water.water))
water_delta = salt_water_amount * (self._salt_water.water / (self._salt_water.salt + self._salt_water.water))
self._salt_water.salt -= salt_delta
self._salt_water.water -= water_delta
def get_result(self):
return self._salt_water
―― En concevant comme ça, vous pouvez librement combiner Director et Builder et créer des instances de manière plus flexible.
――Par exemple, en préparant Director qui connaît la procédure de création d'un document, HTMLBuilder à la sortie pour HTML, PlainTextBuilder à la sortie de texte brut, etc., le même document peut être sorti dans différents formats d'expression en fonction de la demande. devenir capable de.
Résumé des modèles Builder
Recommended Posts