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:

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

class_image

Modèle de constructeur

--Modèles pour obtenir des résultats dans différentes expressions dans le même processus de création --Exemple:

En fait utiliser

Matière

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

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
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)
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. class_image1

Résumé des modèles Builder

class_image2

Recommended Posts

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 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 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 #Builder
J'ai écrit un modèle de conception dans l'édition Kotlin Prototype
J'ai bien étudié Systemd