[PYTHON] J'ai étudié les modèles de conception (mémo personnel) Partie 7 (modèle d'observateur, modèle de souvenir, modèle d'état, modèle de poids mouche)

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

Modèle d'observateur

«Le but est d'observer les changements d'état, mais l'accent est plutôt mis sur la« notification »que sur« l'observation ». --Lorsque l'état d'une instance change, l'instance elle-même «notifie» le changement d'état à «l'observateur». --Exemple

• Pensez à la carte d'embarquement pour un avion.
• Si la personne qui a acheté la carte d'embarquement pour l'avion est obligée d'annuler, contactez la compagnie aérienne et dites-lui d'annuler. ――C'est la "compagnie aérienne" qui gère chaque passager, et le "passager" qui notifie l'annulation. —— Le «passager» contactera l '«aéroport» s'il souhaite ou n'a plus besoin du billet. ―― Ce mécanisme élimine le besoin pour les compagnies aériennes d'observer constamment tous les utilisateurs.

En fait utiliser

Matière

• Patron et subordonnés
• Demandez à plusieurs subordonnés de créer des livrables
• Dites à votre patron le rapport d'achèvement

• L'endroit où préparer l'interface Observer est la clé --Dans l'interface Observer, définissez une méthode de mise à jour qui sert de point de contact pour recevoir les notifications de la cible d'observation lorsque la cible d'observation change. --Créez une classe abstraite Subject à observer
• Implémentez une méthode add_observer pour ajouter librement des instances d'Observer et une méthode notify_observers pour notifier toutes les instances d'Observer possédées des changements.

Résumé des modèles d'observateur

Motif de souvenir

--Mémento: Souvenir, souvenir

• En enregistrant l'état de l'instance sous forme de snapshot, il est possible de restaurer l'état de l'instance à ce moment. --Il est possible que l'état de l'instance change régulièrement pendant l'exécution du programme.
• Une demande telle que "Je veux revenir à l'état précédent" ou "Je veux revenir à l'état à un certain point" peut se produire pour une instance qui a changé une fois.
• Le modèle Memento vous permet de capturer facilement l'état d'une instance à un certain moment comme un instantané, et même de le restaurer à partir de là. --Bien que des clones puissent être créés pour se souvenir de l'état de toutes les instances, le modèle Memento envisage de ne conserver que les informations dont vous avez besoin et de ne restaurer que les données dont vous avez besoin.

En fait utiliser

Matière

--Une addition ――Ajout de 1 à 5 ...

• 1+2+3+4+5=15 ――Suivant, si vous ajoutez 1 à 10 ...? --Modèle 1: 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = 55 '' --Modèle 2: 15 + 6 + 7 + 8 + 9 + 10 = 55 ''
• Le modèle 2 est le modèle Memento --Faire ce code

# -*- coding:utf-8 -*-


class Memento:
    """Classe de souvenir qui garde une trace"""
    result = -1 #Représente la progression du calcul

    def __init__(self, temp):
        """Constructeur qui reçoit la progression du calcul comme argument"""
        Memento.result = temp


class Calc:
    """Une classe qui représente un seul calcul."""
    temp = 0

    @staticmethod
    def plus(plus):
        """Méthode pour effectuer l'addition"""
        Calc.temp += plus

    @staticmethod
    def create_memento():
        """Une méthode pour obtenir la progression comme Memento"""
        return Memento(Calc.temp)

    @staticmethod
    def set_memento(memento: Memento):
        """Obtenez la progression du calcul de Memento et réglez-la sur temp"""
        Calc.temp = memento.result

    @staticmethod
    def get_temp():
        """Méthode pour obtenir le résultat du calcul"""
        return Calc.temp


class Calculator:

    def __init__(self):
        self.result_dict = {}

    def run(self):
        c = Calc()

        #Premier calcul
        for i in range(1, 6):
            c.plus(i)

        print(f"Addition jusqu'à 5: {c.get_temp()}")
        self.result_dict["Addition jusqu'à 5"] = c.create_memento()

        #Deuxième calcul
        c2 = Calc()
        c2.set_memento(self.result_dict["Addition jusqu'à 5"])

        #Premier calcul
        for i in range(6, 11):
            c2.plus(i)

        print(f"Addition jusqu'à 10: {c2.get_temp()}")
        self.result_dict["Addition jusqu'à 10"] = c2.get_temp()


if __name__ == '__main__':
    c = Calculator()
    c.run()

――En laissant une certaine étape comme "instantané", vous pouvez rapidement revenir à l'état à ce moment-là.

• Dans le modèle Memento, c'est à l'Originateur (ici Calc) de décider quelle valeur doit être laissée comme Memento. --Originator laisse les informations dont il pense avoir besoin comme Memento et restaure l'état de Memento

Résumé des modèles Memento

Modèle d'état

• Dans la conception orientée objet, les choses sont souvent représentées sous forme de classes.
• Un modèle qui exprime "l'état" en tant que classe, pas une chose

En fait utiliser

Matière

--Conversation au travail ――La façon dont vous attribuez les tâches change en fonction de l'humeur de votre patron (je déteste ce genre de lieu de travail ...) --Quand vous êtes de bonne humeur

Subordonnés: Bonjour
Patron: Bonjour
Subordonnés: je vais faire xxx aujourd'hui
Patron: Bonne chance

--Quand vous êtes de mauvaise humeur

Subordonnés: Bonjour
Patron: Oh
Subordonnés: je vais faire xxx aujourd'hui
Patron: Hey, tu m'as dit de faire ooo? L'AS-tu fait?
Subordonné: (je n'ai pas entendu ...) Je suis désolé, je le ferai bientôt! !! !! !! !! !! !! !!

--Code

# -*- coding:utf-8 -*-


class Boss:
    STATE_ORDINARY = 0  #Boss normal
    STATE_IN_BAD_MOOD = 1   #Patron de mauvaise humeur

    def __init__(self):
        self.state = -1  #Représente l'état du boss

    def change_state(self, state):
        """Changer le statut de votre patron"""
        self.state = state

    def morning_greet(self):
        """Retourner le salut du matin"""
        if self.state == Boss.STATE_ORDINARY:
            return "Bonjour"
        elif self.state == Boss.STATE_IN_BAD_MOOD:
            return "Oh"
        else:
            pass

    def assign_task(self):
        """Secouez la tâche"""
        if self.state == Boss.STATE_ORDINARY:
            return "Bon, bonne chance"
        elif self.state == Boss.STATE_IN_BAD_MOOD:
            return "Hé, tu as dit ooo? L'AS-tu fait?"
        else:
            pass

――Supposons que le patron de votre patron vous ait signalé et que vous ayez commencé à mieux gérer → Un nouveau modèle est né ――Ce n'est pas cool de modifier la branche if --Dans le modèle State, préparez une classe qui représente "l'état" et rendez cet "état" interchangeable.

• Dans le cas d'un exemple de cas, tout d'abord, «état diagonal de bonne humeur» et «état normal» sont nécessaires. --L'état peut être changé par n'importe quelle classe, mais dans ce cas, il sera changé de quelque part à l'intérieur.

# -*- coding:utf-8 -*-
from abc import ABCMeta, abstractmethod


class State(metaclass=ABCMeta):

    @staticmethod
    def morning_greet():
        """Salutation du matin"""
        pass

    @staticmethod
    def assign_task():
        """Secouez la tâche"""
        pass


class BadMoodState(State):

    @staticmethod
    def morning_greet():
        return "Oh"

    @staticmethod
    def assign_task():
        return "Hé, tu as dit ooo? L'AS-tu fait?"


class OrdinaryState(State):

    @staticmethod
    def morning_greet():
        return "Bonjour"

    @staticmethod
    def assign_task():
        return "Bon, bonne chance"


class StatePatternBoss:

    def __init__(self):
        self.state = None

    def change_state(self, state: State):
        self.state = state

    def morning_greet(self):
        return self.state.morning_greet()

    def assign_task(self):
        return self.state.assign_task()


if __name__ == '__main__':

    boss_state = StatePatternBoss()

    print("=====Jour 1: Bonne humeur=====")
    boss_state.change_state(OrdinaryState())
    print("Subordonnés: Bonjour")
    print(f"patron:{boss_state.morning_greet()}")
    print("Subordonnés: je vais faire xxx aujourd'hui")
    print(f"patron:{boss_state.assign_task()}")

    print("=====Jour 2: mauvaise humeur=====")
    boss_state.change_state(BadMoodState())
    print("Subordonnés: Bonjour")
    print(f"patron:{boss_state.morning_greet()}")
    print("Subordonnés: je vais faire xxx aujourd'hui")
    print(f"patron:{boss_state.assign_task()}")

=====Jour 1: Bonne humeur=====
Subordonnés: Bonjour
Patron: Bonjour
Subordonnés: je vais faire xxx aujourd'hui
Patron: Bonne chance
=====Jour 2: mauvaise humeur=====
Subordonnés: Bonjour
Patron: Oh
Subordonnés: je vais faire xxx aujourd'hui
Patron: Hey, tu m'as dit de faire ooo? L'AS-tu fait?

―― En faisant cela, il est facile de répondre même si le modèle d'humeur augmente

(Omission)
class GoodMoodState(State):

    @staticmethod
    def morning_greet():
        return "Bonjour! Faisons de notre mieux aujourd'hui!"

    @staticmethod
    def assign_task():
        return "Comme c'est gentil! L'autre ooo était aussi bien! Bonne chance avec cette condition!"
(Omis)
    print("=====Jour 3: Bonne humeur=====")
    boss_state.change_state(GoodMoodState())    #Changez juste ici
    print("Subordonnés: Bonjour")
    print(f"patron:{boss_state.morning_greet()}")
    print("Subordonnés: je vais faire xxx aujourd'hui")
    print(f"patron:{boss_state.assign_task()}")

=====Jour 3: Bonne humeur=====
Subordonnés: Bonjour
Patron: Bonjour! Faisons de notre mieux aujourd'hui!
Subordonnés: je vais faire xxx aujourd'hui
Patron: Bien! L'autre ooo était aussi bien! Bonne chance avec cette condition!

Résumé des modèles d'état

Modèle de poids mouche

--Flyweight: signifie "fly weight" en anglais

• Modèles axés sur le gaspillage de ressources en partageant des instances --Exemple: La petite image utilisée pour l'arrière-plan de la page d'accueil n'est pas échangée sur le réseau autant de fois qu'elle est affichée en arrière-plan, mais généralement l'image est acquise une fois et «l'image» est affichée côte à côte.
• Un modèle qui vise à alléger l'ensemble du programme en partageant la même instance afin de ne pas créer d'instances inutiles.

En fait utiliser

Matière

• Essayez de créer un message en utilisant des "caractères humains" ―― "Ai est meilleur que Ao" ――Faites en chaque personnage des "personnages humains", prenez une photo du toit et laissez-la dans l'image.
• Si la classe qui représente un seul caractère humain est la classe HumanLetter, la classe qui génère un message avec des caractères humains est la suivante.

# -*- coding:utf-8 -*-


class HumanLetter:

    def __init__(self, letter):
        self._letter = letter

    def get_letter(self):
        return self._letter


class Main:

    @staticmethod
    def take_a_photo(letter: HumanLetter):
        """Prendre une photo"""
        print(letter.get_letter())

    def main(self):
        """Créer une lettre"""
        a = HumanLetter("Ah")
        self.take_a_photo(a)

        i = HumanLetter("je")
        self.take_a_photo(i)

        ha = HumanLetter("Est")
        self.take_a_photo(ha)

        a2 = HumanLetter("Ah")
        self.take_a_photo(a2)

        o = HumanLetter("Oh")
        self.take_a_photo(o)

        yo = HumanLetter("Yo")
        self.take_a_photo(yo)

        ri = HumanLetter("Ri")
        self.take_a_photo(ri)

        mo = HumanLetter("Aussi")
        self.take_a_photo(mo)

        a3 = HumanLetter("Ah")
        self.take_a_photo(a3)

        o2 = HumanLetter("Oh")
        self.take_a_photo(o2)

        i2 = HumanLetter("je")
        self.take_a_photo(i2)


if __name__ == '__main__':
    h = Main()
    h.main()

―― Le même caractère apparaît plusieurs fois. ――Si vous venez de prendre une photo, vous pouvez la réutiliser ...

# -*- coding:utf-8 -*-


class HumanLetter:

    def __init__(self, letter):
        self._letter = letter

    def get_letter(self):
        return self._letter


class Main:

    @staticmethod
    def take_a_photo(letter: HumanLetter):
        """Prendre une photo"""
        print(letter.get_letter())

    def main(self):
        """Créer une lettre"""
        a = HumanLetter("Ah")
        self.take_a_photo(a)

        i = HumanLetter("je")
        self.take_a_photo(i)

        ha = HumanLetter("Est")
        self.take_a_photo(ha)

        self.take_a_photo(a)

        o = HumanLetter("Oh")
        self.take_a_photo(o)

        yo = HumanLetter("Yo")
        self.take_a_photo(yo)

        ri = HumanLetter("Ri")
        self.take_a_photo(ri)

        mo = HumanLetter("Aussi")
        self.take_a_photo(mo)

        self.take_a_photo(a)

        self.take_a_photo(o)

        self.take_a_photo(i)


if __name__ == '__main__':
    h = Main()
    h.main()

• J'ai pu réduire le nombre d'instanciations coûteuses (ici, un constructeur qui trie les personnes pour former des caractères. À l'origine, l'accès à la base de données, etc. peut être envisagé). Naturellement, le nombre d'instances diminue également.
• Réduction supplémentaire avec motif Flyweight --Créez une classe Factory qui crée et gère les instances qui doivent être allégées, et obtenez les instances qui doivent être allégées via cette classe Factory.

# -*- coding:utf-8 -*-


class HumanLetter:

    def __init__(self, letter):
        self._letter = letter

    def get_letter(self):
        return self._letter


class HumanLetterFactory:
    __singleton = None
    __human_letter = None

    def __new__(cls, *args, **kwargs):
        if cls.__singleton is None:
            cls.__singleton = super(HumanLetterFactory, cls).__new__(cls)
        return cls.__singleton

    def __init__(self):
        self.dic = {}

    def get_human_letter(self, letter: str):

        try:
            human_letter = self.dic[letter]
        except KeyError:
            human_letter = HumanLetter(letter)
            self.dic[letter] = human_letter

        return human_letter



class Main:

    @staticmethod
    def take_a_photo(letter: HumanLetter):
        """Prendre une photo"""
        print(letter.get_letter())

    def main(self):
        """Créer une lettre"""

        #Créer un singleton
        hlf = HumanLetterFactory()

        a = hlf.get_human_letter("Ah")
        self.take_a_photo(a)
        print(a)

        i = hlf.get_human_letter("je")
        self.take_a_photo(i)
        print(i)

        ha = hlf.get_human_letter("Est")
        self.take_a_photo(ha)

        a2 = hlf.get_human_letter("Ah")
        self.take_a_photo(a2)
        print(a2)

        o = hlf.get_human_letter("Oh")
        self.take_a_photo(o)
        print(o)

        yo = hlf.get_human_letter("Yo")
        self.take_a_photo(yo)

        ri = hlf.get_human_letter("Ri")
        self.take_a_photo(ri)

        mo = hlf.get_human_letter("Aussi")
        self.take_a_photo(mo)

        a3 = hlf.get_human_letter("Ah")
        self.take_a_photo(a3)
        print(a3)

        o2 = hlf.get_human_letter("Oh")
        self.take_a_photo(o2)
        print(o2)

        i2 = hlf.get_human_letter("je")
        self.take_a_photo(i2)
        print(i2)


if __name__ == '__main__':
    h = Main()
    h.main()

Ah
<__main__.HumanLetter object at 0x1039c4da0> #C'est une instance courante dans "A"
je
<__main__.HumanLetter object at 0x1039c4dd8>
Est
Ah
<__main__.HumanLetter object at 0x1039c4da0>  #C'est une instance courante dans "A"
Oh
<__main__.HumanLetter object at 0x1039c4e48>
Yo
Ri
Aussi
Ah
<__main__.HumanLetter object at 0x1039c4da0> #C'est une instance courante dans "A"
Oh
<__main__.HumanLetter object at 0x1039c4e48>
je
<__main__.HumanLetter object at 0x1039c4dd8>

• En créant la classe Factory Singleton, vous pouvez empêcher la génération de plusieurs classes Factory.
  • Singleton
• La méthode get_human_letter de la classe HumanLetterFactory interroge le dict géré, et si vous avez besoin d'une instance qui représente un caractère que vous avez déjà, vous ne vous souciez pas de le recréer. --Si on vous demande un caractère que vous n'avez pas, instanciez-le, enregistrez-le dans la carte et renvoyez l'instance générée.
• En utilisant le modèle Flyweight, il n'est pas nécessaire que l'utilisateur (appelant comme la classe Main) sache quelle instance il possède. De plus, il est possible de répondre sans gaspillage aux demandes d'une pluralité d'appels.
• Mise en garde
• Le modèle Flyweight partagera une instance partout, il ne doit donc être utilisé que si l'instance partagée ne contient que des informations intrinsèques. --Connexion DB
• Les informations extrinsèques sont quelque chose que quelqu'un peut changer, et si quelqu'un change lui-même l'instance partagée, cela peut l'affecter ici et là. ..

Résumé du modèle de poids mouche