[PYTHON] Ich habe über Designmuster (persönliches Memo) Teil 3 (Prototypmuster, Builder-Muster) studiert.

Einführung

Dieser Artikel ist ein persönliches Studienmemo. Ich schreibe einen Artikel, der von der Besessenheit getrieben ist, dass das, was ich eingebe, ausgegeben werden muss. Ich schreibe diesen Artikel über Qiita in der Hoffnung, dass jemand, der damit vertraut ist, auf Fehler hinweisen und Ratschläge geben kann.

Ich lebe ein Berufsleben als Ingenieur, aber ich habe nicht richtig über Entwurfsmuster gelernt, also habe ich versucht zu studieren.

Was ist hier beschrieben https://github.com/ck-fm0211/notes_desigh_pattern Ich lade auf.

Vergangenes Protokoll

Ich habe über Entwurfsmuster (persönliches Memo) Teil 1 studiert Ich habe über Entwurfsmuster (persönliches Memo) Teil 2 studiert

Prototypmuster

• Muster zum Erstellen einer Instanz aus dem zuvor vorbereiteten "Prototyp" --Beispiel:
• Betrachten Sie einen Grafikeditor, der nur die Funktion "Gerade zeichnen" hat. ――Wenn Sie mit diesem Figureneditor eine Sternform zeichnen möchten, können Sie eine Sternform erstellen, indem Sie gerade Linien kombinieren. ――Wenn Sie viele Sterne möchten, müssen Sie den Vorgang des Zeichnens eines Sterns wiederholen, indem Sie gerade Linien kombinieren.
• In einem solchen Fall kann die Arbeit vereinfacht werden, wenn Sie eine Sternform erstellen können, indem Sie die zuerst erstellte Sternform (Sammlung gerader Linien) als "Prototyp" registrieren und kopieren.

Eigentlich verwenden

Gegenstand

• Ich möchte den gesamten Inhalt der Instanz kopieren

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

• Im Fall von Python können Sie den gesamten Inhalt der Instanz mit copy.deepcopy kopieren.
• Versuchen Sie bei einer weiteren Erweiterung, ein Programm zu schreiben, das eine Zeichenfolge enthält

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

--Ergebnis

"Hello, world."
 .............
*****************
* Hello, world. *
*****************
/////////////////
/ Hello, world. /
/////////////////
+++++++++++++++++
+ Hello, world. +
+++++++++++++++++
"Hello, world."
 =============

Zusammenfassung der Prototypmuster

Builder-Muster

--Muster zum Abrufen von Ergebnissen in verschiedenen Ausdrücken im selben Erstellungsprozess --Beispiel:

• Denken Sie daran, ein Haus zu bauen ――Um ein Haus zu bauen, benötigen Sie "was zu verwenden ist (= Material)" und "wie zu bauen ist (= Prozess)".
• Es gibt verschiedene Materialien wie Holz, Beton, Fliesen usw. ――Es gibt verschiedene Prozesse wie einstöckiges, zweistöckiges, ungewöhnliches Haus usw. ――Bei der Vorbereitung dieser Muster im Voraus können Sie flexibel auf die Anfrage reagieren: "Bitte bauen Sie ein Haus mit eisernen Säulen und Betonwänden und -dächern, während Sie ein etwas ungewöhnliches einstöckiges Haus bauen."
• Das Builder-Muster macht die Erstellung eines Objekts flexibler, indem so etwas wie Director, das den "Erstellungsprozess" bestimmt, und Builder, das die "Ausdrucksform" bestimmt, und der "Builder" des Objekts kombiniert werden. Muster, um den "Erstellungsprozess" steuern zu können

Eigentlich verwenden

Gegenstand

• Denken Sie daran, in einem wissenschaftlichen Experiment Salzwasser und Zuckerwasser herzustellen
• Die Klasse, die Salzwasser darstellt, ist im folgenden Quellcode anzugeben (das gleiche gilt für die Klasse, die Zuckerwasser darstellt).

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


class SaltWater:

    salt = None
    water = None

    @staticmethod
    def salt_water(water, salt):
        SaltWater.salt = salt
        SaltWater.water = water

――Verschiedene Anforderungen können berücksichtigt werden. Mit dem Builder-Muster können jedoch die folgenden Anforderungen erfüllt werden. ――Ich möchte die im selben Prozess erhaltene Lösung viele Male verwenden. ――Ich möchte Zuckerwasser auf die gleiche Weise herstellen.

• Um diesen Anforderungen gerecht zu werden, erstellt das Builder-Muster Klassen, die Director und Builder sind.

• Die Rolle des Direktors besteht darin, den "Erstellungsprozess" zu bestimmen, und die Rolle des Builders besteht darin, die "Ausdrucksform" zu bestimmen.

• Im Beispielfall hat der Direktor die Aufgabe zu bestimmen, dass "40 g gelöster Stoff in 100 g Lösungsmittel gelöst sind, von denen 70 g verworfen werden, dann 100 g Lösungsmittel hinzugefügt werden und schließlich 15 g gelöster Stoff hinzugefügt werden." ――Die Rolle des Builders besteht darin, "Wasser als Lösungsmittel und Salz als gelösten Stoff" zu verwenden.

• Die Builder-Oberfläche sieht folgendermaßen aus:

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

• Die Builder-Schnittstelle definiert eine addSolute-Methode zum Hinzufügen von gelösten Stoffen, eine addSolvent-Methode zum Hinzufügen von Lösungsmitteln, eine verlassenSolution-Methode zum Verwerfen von Lösungen und eine getResult-Methode zum Erhalten von Produkten.
• Die Director-Klasse verwendet die Builder-Schnittstelle, um Instanzen gemäß dem "Erstellungsprozess" zusammenzustellen.

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)

• Die Director-Klasse weiß nur, dass sie etwas erhält, das die Builder-Schnittstelle implementiert. Sie muss nicht wirklich wissen, welche Builder-Implementierungsklasse übergeben wird. Dies erleichtert das Ersetzen des Builders.
• Die SaltWaterBuilder-Klasse, bei der es sich um eine Builder-Implementierungsklasse handelt, lautet wie folgt.

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

――Durch diese Gestaltung können Sie Director und Builder frei kombinieren und Instanzen flexibler erstellen.

• Wenn Sie beispielsweise einen Director vorbereiten, der die Vorgehensweise zum Erstellen eines Dokuments kennt, HTMLBuilder für die Ausgabe für HTML, PlainTextBuilder für die Ausgabe von Klartext usw., kann dasselbe Dokument je nach Anforderung in verschiedenen Ausdrucksformaten ausgegeben werden. in der Lage werden.

Zusammenfassung der Builder-Muster