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

En fait utiliser

Matière

# -*- 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

Proxy.png

Modèle de commande

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

  1. Mettez 100g d'eau dans le bécher
  2. Mettez 1g de sel dans le bécher
  3. Remuer
  4. Si complètement fondu, revenir à 2
  5. 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

  1. Mettez 10g de sel dans le bécher
  2. Mettez 10g d'eau dans le bécher
  3. Remuer
  4. S'il ne fond pas complètement, revenez à 2.
  5. 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()

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()
  # ...

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

Résumé des modèles de commande

Command.png

Modèle d'interprète

--Interprète: Interprète / Explicateur

En fait utiliser

Matière

―― Réfléchissez à la façon de préparer des ramen

  1. Mettez la "soupe en poudre" dans la tasse de nouilles
  2. Versez de l'eau chaude
  3. Attendez 3 minutes
  4. Ajouter la soupe liquide
# -*- 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

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()

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!

Résumé des modèles d'interprétation

Interpreter.png

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.

Recommended Posts

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)
J'ai étudié les modèles de conception (mémo personnel) Partie 3 (modèle de prototype, modèle de constructeur)
J'ai étudié les modèles de conception (mémo personnel) Partie 5 (modèle composite, modèle décorateur, modèle visiteur)
J'ai étudié les modèles de conception (mémo personnel) Partie 4 (modèle AbstractFactory, modèle de pont, modèle de stratégie)
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)
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)
Modèle de conception #Proxy
J'ai bien étudié Systemd