[PYTHON] J'ai étudié les modèles de conception (mémo personnel) Partie 6 (modèle de chaîne de responsabilité, modèle de façade, modèle de médiateur)
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
Modèle de chaîne de responsabilité
――Le modèle de Chaîne de Respoisibilité est un modèle qui vous fait imaginer un état dans lequel ceux qui ont la «responsabilité» sont connectés en forme de «chaîne». --Exemple:
- Si vous demandez au "responsable de section" de régler quelque chose, le responsable de section l'approuvera si cela peut être traité avec l'approbation du responsable de section.
- Pour les éléments qui ne peuvent pas être traités par le responsable de section, le "responsable" sera invité à prendre une décision. ――Bien entendu, si le contenu ne peut pas être approuvé par le réalisateur, l'approbation sera confiée à une personne de rang supérieur en charge de l'approbation.
- Un modèle qui relie la «personne responsable» dans une «chaîne» et exprime que «quelqu'un» traitera à «un certain stade».
En fait utiliser
Matière
―― Pensez à la décision à l'école
- Etudiant A "Combien coûte la collation pour l'excursion?"
- Professeur débutant "jusqu'à 300 yens" ← Approbation du nouveau professeur
- Élève B "Les bananes tiennent-elles dans une collation?"
- Professeur débutant "Je ne peux pas juger"
- Professeur vétéran "Je ne peux pas entrer dans la collation" ← Décision d'un enseignant vétéran
- Les parents de l'élève "Puis-je avoir un téléphone portable?"
- Enseignant débutant / enseignant vétéran "Je ne peux pas juger" --Décision lors de la réunion du personnel ← Approbation de niveau supérieur
―― La chaîne selon laquelle "la personne responsable décide de ce qu'elle peut juger à sa discrétion et laisse le jugement à la personne suivante en charge si elle ne peut pas juger par elle-même"
- Pour utiliser le modèle de chaîne de responsabilité, créez une «classe qui représente une personne responsable générale» et héritez-en pour créer des classes telles que des étudiants, de nouveaux enseignants, des enseignants vétérans et des réunions du personnel. «La« classe qui représente le responsable général »a une méthode pour« juger »et une variable de champ qui représente la« prochaine personne responsable »pour demander un jugement s'il ne peut être jugé par soi-même.
- La classe qui représente chaque personne responsable est créée en héritant de cette "classe qui représente une personne responsable générale".
# -*- coding:utf-8 -*-
from abc import ABCMeta, abstractmethod
class Responsible(metaclass=ABCMeta):
def __init__(self, responsible_person: str):
self._responsible_person = responsible_person
self._next_level: Responsible = None
@abstractmethod
def set_next(self, next_level):
self._next_level = next_level
return self._next_level
@abstractmethod
def be_able_to_judge(self, question: Question) -> bool:
pass
@staticmethod
@abstractmethod
def judge(question: Question):
pass
@abstractmethod
def put_question(self, question: Question):
if self.be_able_to_judge(question):
self.judge(question)
elif self._next_level is not None:
self._next_level.put_question(question)
else:
print("Personne ne pouvait juger. Essayez-le.")
class Question:
"""
Une instance String qui stocke le contenu de la question sous forme de champ,
Il a une instance Level qui représente la difficulté de la question.
"""
def __init__(self, question: str, level: Level):
self._question = question
self._level = level
class Level:
"""
Une valeur de type int qui représente le niveau de difficulté sous forme de champ,
Moins que de comparer sa propre difficulté avec la difficulté de l'argument Level object(Level level)Avoir une méthode
"""
def __init__(self, level: int):
self._level: int = level
def less_than(self, level: Level):
pass
class RookieTeachee(Responsible):
def __init__(self, responsible_person):
super().__init__(responsible_person)
self._level = Level(2)
def be_able_to_judge(self, question: Question):
if question._level.less_than(self._level):
return True
return False
@staticmethod
def judge(question: Question):
#・ ・ ・
―― En divisant chaque «responsable» en classes, le rôle de chaque responsable peut être limité. «En clarifiant le rôle du responsable et en divisant le responsable en classes, il devient possible de réorganiser avec plus de souplesse la« chaîne »qu'est le flux du jugement. ―― D'un autre côté, il est possible que la vitesse de traitement ralentisse car elle suit la chaîne à chaque fois. ――Il est nécessaire de juger en fonction de la situation si un programme axé sur la vitesse est nécessaire ou si la flexibilité est requise.
Résumé des modèles de chaîne de responsabilité
Motif de façade
--Le modèle de façade est un modèle qui permet d'utiliser simplement la procédure d'utilisation de plusieurs classes existantes en combinaison en créant une classe qui sert de "fenêtre".
En fait utiliser
Matière
«Je suis allé à la bibliothèque pour emprunter un livre, mais je ne sais pas où il se trouve. «J'ai une liste de livres et un livre de prêt, mais je ne sais pas comment les utiliser.
# -*- coding:utf-8 -*-
class BookList:
"""Liste des collections"""
@staticmethod
def search_book(book_name):
location = None
#Rechercher par nom de livre
#Renvoie l'emplacement, le cas échéant, nul dans le cas contraire
return location
class LendingList:
"""Livre de prêt"""
@staticmethod
def check(book_name):
#Consultez le livre de prêt
#Renvoie vrai si loué, faux sinon
return True
class Visitor:
@staticmethod
def main(args):
#Où est le livre que vous souhaitez emprunter?
#Quand et où utilisez-vous quelle méthode?
pass
--Demander au secrétaire ――C'est la "fenêtre"
class Visitor:
@staticmethod
def main(args):
#Demandez au commis au comptoir pour l'emplacement
shisho = Librarian()
location = shisho.search_book("Livre illustré d'insectes")
if location == "Prêt":
print("Est-ce en prêt! !!")
elif location == "Le livre n'est pas en possession":
print("N'est-ce pas! !! !!")
else:
print("Je vous remercie")
class Librarian:
@staticmethod
def search_book(book_name):
#Trouver un livre
location = BookList.search_book(book_name)
#Lorsque l'emplacement du livre n'est pas Aucun (en possession)
if location is not None:
#Vérifiez s'il est prêté
if LendingList.check(book_name):
#Lors de la location
return "Prêt"
else:
#Lorsqu'il n'est pas prêté
return location
else:
#Lorsqu'il n'est pas en possession
return "Le livre n'est pas en possession"
Résumé du modèle de façade
Motif médiateur
- Un modèle qui est efficace lorsqu'il est utilisé lorsqu'il est nécessaire de procéder au traitement tout en effectuant des ajustements entre un grand nombre d'objets. --Exemple --Un policier qui maintient la circulation à une intersection où le signal est interrompu
- Jugez de la situation et dites «arrêter» et «avancer»
- Un modèle qui utilise une classe qui agit comme un «arbitre» qui reçoit les demandes de chaque objet, prend les décisions appropriées et donne des instructions afin de faire des ajustements entre plusieurs objets.
En fait utiliser
Matière
--Application correspondante
- Regardez la situation et répondez à la demande
# -*- coding:utf-8 -*-
class Concierge:
def __init__(self):
self._user_dict = {}
def add_user(self, user: User):
self._user_dict[user.get_name()] = user
@staticmethod
def consultation(colleagueInLove: User, secretLover: User):
possibility = 0
#Dérivation de la possibilité en tenant compte de diverses situations
return possibility
class User:
def __init__(self):
self._name = None
def get_name(self):
return self._name
class John(User):
def __init__(self):
super().__init__()
self._name = "John"
self._secret_lover = None
self._tension = None
self._mediator = Concierge()
def get_name(self):
return self._name
def set_secret_lover(self, user: User):
self._secret_lover = user
def needs_advice(self):
self._tension = self._mediator.consultation(self, self._secret_lover)
- Le modèle Mediator peut être utilisé pour les interfaces d'entrée, etc. --Exemple Lorsque vous souhaitez créer un "bouton qui ne devient" valide "que s'il répond à certaines conditions intimement liées"
- "Lorsque le bouton radio A est sélectionné et qu'il y a une entrée dans la zone de texte" ou "lorsque le bouton radio B est sélectionné et que la case C ou D est cochée", " Les boutons qui deviennent "activés" vérifient "s'il y a une entrée dans la zone de texte" lorsque "le bouton radio A" est coché, ou "la case à cocher C ou D est cochée" lorsque le bouton radio B est sélectionné. Si vous avez un programme qui vérifie "si c'est fait", ce sera un programme qui doit être vérifié même lorsque la case C est cochée ou la case D n'est pas cochée. ―― Au fur et à mesure que les conditions deviennent plus complexes, vous perdrez le contrôle de l'endroit et de ce que vous vérifiez.
- Dans le modèle Mediator, chaque objet contacte Mediator lorsque son état change, et Mediator juge de manière exhaustive non seulement l'état de l'objet modifié mais aussi l'état de chaque objet, et appuie sur un "bouton". Il est conçu pour transmettre «valide» et «invalide» à l'objet indiqué, ce qui rend la gestion relativement facile.
Résumé des modèles Mediator
Recommended Posts