J'ai étudié les modèles de conception (mémo personnel) Partie 5 (modèle composite, modèle décorateur, modèle visiteur)
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
Motif composite
-Le motif composite facilite la manipulation des structures récursives en "identifiant le contenu avec le conteneur".
- Exemple: système de fichiers
- Si vous souhaitez supprimer tous les fichiers et dossiers d'un certain dossier, il est pratique de pouvoir les supprimer de la même manière sans savoir s'il s'agit d'un fichier ou d'un dossier.
En fait utiliser
Matière
- Dans l'exemple de cas, considérez les répertoires et les fichiers.
- Essayez de créer une classe qui représente des fichiers et des répertoires sans connaître le modèle composite.
class File:
def __init__(self, name):
self._name = name
def remove(self):
print("{}A été supprimée".format(self._name))
- La classe Directory, qui représente un répertoire, gère les objets des répertoires et des fichiers sous elle comme un objet List, et lorsque la méthode remove est appelée, supprime tous les objets contenus dans la liste, puis se supprime. Sera supprimé
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("Ne peut pas être supprimé")
i += 1
print("{}A été supprimée".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()
- Il n'y a pas de problème pour l'instant. C'est ennuyeux quand la requête "Je veux que le répertoire contienne non seulement des répertoires et des fichiers mais aussi des liens symboliques" sort. -Dans le modèle composite, le contenu du conteneur et le conteneur sont assimilés. Assurez-vous de mettre en œuvre une interface avec un conteneur et un contenu communs pour l'identification. --Faire en sorte que le fichier et le répertoire implémentent une interface commune DirectoryEntry
class DirectoryEntry(metaclass=ABCMeta):
@abstractmethod
def remove(self):
pass
--Définissez uniquement la méthode remove dans l'interface DirectoryEntry --Implémenter la classe File et la classe Directory sous la forme de l'implémentation de ceci.
class File(DirectoryEntry):
def __init__(self, name):
self._name = name
def remove(self):
print("{}A été supprimée".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("{}A été supprimée".format(self._name))
- En faisant de la classe Directory et de la classe File une classe qui implémente la classe DirectoryEntry, dans la méthode remove de la classe Directory, peu importe que la situation réelle soit une instance de la classe File ou une instance de la classe Directory. Peut également être traité comme un objet DirectoryEntry.
- En utilisant le modèle composite de cette manière, vous pouvez gérer de manière flexible la nécessité d'ajouter la classe SymbolicLink. La classe --SymbolicLink doit être implémentée pour implémenter l'interface DirectoryEntry.
class SymbolicLink(DirectoryEntry):
def __init__(self, name):
self._name = name
def remove(self):
print("{}A été supprimée".format(self._name))
Résumé du motif composite
Motif décorateur
- Le modèle Decorator fournit une méthode d'extension de fonction plus flexible en assimilant le cadre décoratif au contenu. ――Le motif Decorator est une image des fonctions de superposition une par une. C'est une image de mettre une décoration avec une certaine fonction sur le noyau.
En fait utiliser
Matière
――A la boutique de crème glacée, vous pouvez choisir librement les garnitures. Le client n'a pas à faire de garnitures et peut sélectionner plusieurs garnitures en couches. --Définissez l'interface suivante comme interface commune pour la crème glacée.
class Icecream(metaclass=ABCMeta):
@abstractmethod
def get_name(self):
pass
@abstractmethod
def how_sweet(self):
pass
―― En tant que classes avec ces interfaces, la classe de crème glacée à la vanille, la classe de crème glacée au matcha, etc. sont fournies comme suit.
class VanillaIcecream(Icecream):
def get_name(self):
return "Glace à la vanille"
def how_sweet(self):
return "Saveur vanille"
class GreenTeaIcecream(Icecream):
def get_name(self):
return "Glace au matcha"
def how_sweet(self):
return "Saveur de matcha"
- Envisagez d'ajouter des garnitures à ces classes d'implémentation d'interface de crème glacée.
- Considérez les noix de cajou et les amandes en tranches comme garniture.
- La crème glacée à la vanille garnie de noix de cajou et de crème glacée à la vanille garnie d'amandes tranchées est requise.
- Ici, en ajoutant des garnitures, le nom (valeur de retour de la méthode getName) change et le goût (valeur de retour de la méthode howSweet ()) ne change pas.
- Afin de répondre à ces demandes, une méthode de création d'une classe de crème glacée à la vanille et aux noix de cajou peut être considérée comme représentant une glace à la vanille garnie de noix de cajou.
class CashewNutsVanillaIcecream(Icecream):
def get_name(self):
return "Glace aux noix de cajou et à la vanille"
«Ce genre d '« ajout de fonctions utilisant l'héritage »devient très fixe. --Par exemple, si vous voulez une instance qui représente la crème glacée au matcha avec des noix de cajou, vous avez besoin de la classe de succession de crème glacée au matcha.
- Le modèle Decorator est efficace lorsque vous souhaitez ajouter de manière flexible diverses fonctions de cette manière. --Dans la conception utilisant le modèle Decorator, préparez une autre classe qui n'a que la partie fonction d'extension, donnez à la variable d'instance de cette classe l'instance à étendre et implémentez la même interface que la cible d'extension.
class CashewNutsToppingIcecream(Icecream):
def __init__(self, ice: Icecream):
self._ice = ice
def get_name(self):
name = "Noix de cajou"
name += self._ice.get_name()
return name
def how_sweet(self):
return self._ice.how_sweet()
--CashewNutsToppingIcecream classe est une classe qui représente la crème glacée garnie de noix de cajou. --Cette classe implémente l'interface Icecream, et sa méthode getName () renvoie la valeur obtenue par getName () de sa propre variable d'instance ice (instance Icecream) plus la chaîne "noix de cajou". Renvoie comme. De plus, dans la méthode howSweet (), la valeur de retour de la méthode howSweet () de la variable d'instance ice est renvoyée telle quelle. ―― En concevant comme ceci, comme indiqué ci-dessous, de la glace à la vanille garnie de noix de cajou, de la crème glacée au matcha garnie de noix de cajou, de la glace à la vanille garnie d'amandes tranchées, d'amandes tranchées et de noix de cajou. Il est possible de garnir dans diverses combinaisons telles que la crème glacée à la vanille garnie des deux.
ice1 = CashewNutsToppingIcecream(VanillaIcecream()) #Glace à la vanille avec garniture de noix de cajou
ice2 = CashewNutsToppingIcecream(GreenTeaIcecream()) #Glace au matcha avec garniture de noix de cajou
Résumé des modèles de décorateur
Modèle de visiteur
--Dans le modèle Visiteur, il est facile d'ajouter un traitement en décrivant le "traitement" dans l'objet Visiteur qui est le visiteur.
- L'objet Acceptor à traiter doit implémenter la méthode accept (Visiteur visiteur) qui accepte l'objet Visiteur. --Exemple ――Si vous voulez faire les «aqueducs» de votre maison, appelez «l'entrepreneur en eau» de votre maison, dites «Merci». ――En outre, nous pouvons appeler un entrepreneur électricien ou un entrepreneur en rénovation. «À ces visiteurs, vous dites« Eh bien, merci »et vous laissez la plupart du travail à vous. ――Il peut y avoir des différences dans la façon dont vous nous laissez le soin, mais à la fin, nous laisserons tout au vendeur. ――Si un nouveau fournisseur de services apparaît, chaque ménage n'a pas besoin de changer d'attitude, il suffit d'appeler le fournisseur et de lui dire «Merci». Pour recevoir le nouveau service. être capable de.
- Le modèle de visiteur est un modèle qui vous permet d'ajouter un traitement sans ajouter de traitement du côté réception.
En fait utiliser
Matière
- Prenons une visite à domicile comme exemple. ――Dans chaque famille, que vous soyez professeur ou tante du quartier, lorsqu'un visiteur vous rend visite, si vous n'êtes pas étranger, dites "Bienvenue" et acceptez-le. ――À ce stade, envisagez d'appliquer chaque famille en tant qu'accepteur et l'enseignant en tant que visiteur en l'appliquant au modèle Visiteur.
- Dans le modèle Visiteur, le visiteur visite la maison, qui est la cible de la visite. La famille visitée accepte l'enseignant en disant «Bienvenue». «À ce stade, que vous soyez un nouveau venu ou un vétéran, il n'y a pas de changement du côté qui accepte l'enseignant.
# -*- coding:utf-8 -*-
from abc import ABCMeta, abstractmethod
#Classe des enseignants
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
#Classe de professeur débutant
class RookieTeacher(Teacher):
def __init__(self, students):
super().__init__(students)
def visit(self, student_home):
print("Bonjour enseignant")
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
#Cours à domicile
class Home(metaclass=ABCMeta):
@staticmethod
def praised_child():
pass
@staticmethod
def reproved_child():
pass
#Interface d'acceptation
class TeacherAcceptor(metaclass=ABCMeta):
def accept(self, teacher: Teacher):
pass
#La famille de Suzuki
class Suzuki(Home, TeacherAcceptor):
@staticmethod
def praised_child():
print("Suzuki Mother: Oh, si tu es professeur, fais une blague")
@staticmethod
def reproved_child():
print("Suzuki Mother: C'est seulement pour mon enfant ...")
def accept(self, teacher: Teacher):
teacher.visit(self.__class__)
#La famille de M. Tanaka
class Tanaka(Home, TeacherAcceptor):
@staticmethod
def praised_child():
print("Tanaka Mother: Oh, si vous êtes enseignant, faites une blague")
@staticmethod
def reproved_child():
print("Mère Tanaka: Pas question, c'est seulement pour mon enfant ...")
def accept(self, teacher: Teacher):
teacher.visit(self.__class__)
if __name__ == "__main__":
rt = RookieTeacher(["suzuki", "tanaka"])
rt.visit(Suzuki())
rt.visit(Tanaka())
―― La méthode d'acceptation de chaque ménage appelle la méthode de visite de l'enseignant (visiteur) pour réaliser un traitement commun.
Résumé des modèles de visiteurs
Impressions
――Je pense qu'il y a un meilleur exemple ...
Recommended Posts