[PYTHON] Ich habe über Designmuster (persönliches Memo) Teil 7 (Beobachtermuster, Erinnerungsmuster, Zustandsmuster, Fliegengewichtsmuster) 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 Ich habe über Entwurfsmuster (persönliches Memo) Teil 3 studiert Ich habe über Entwurfsmuster (persönliches Memo) Teil 4 studiert Ich habe über Entwurfsmuster (persönliches Memo) Teil 5 studiert Ich habe über Entwurfsmuster (persönliches Memo) Teil 6 studiert

Beobachtermuster

――Der Zweck besteht darin, Änderungen im Zustand zu beobachten, sondern der Schwerpunkt liegt eher auf "Benachrichtigung" als auf "Beobachtung".

• Wenn sich der Status einer Instanz ändert, "benachrichtigt" die Instanz selbst die Statusänderung an den "Beobachter". --Beispiel
• Denken Sie an die Bordkarte für ein Flugzeug.
• Wenn die Person, die die Bordkarte für das Flugzeug gekauft hat, zum Stornieren gezwungen wird, wenden Sie sich an die Fluggesellschaft und fordern Sie sie auf, zu stornieren.
• Jeder Passagier wird von der "Flugzeugfirma" verwaltet, und die Stornierung wird vom "Passagier" mitgeteilt. —— Der „Passagier“ wird den „Flughafen“ kontaktieren, wenn er das Ticket möchte oder nicht mehr benötigt.
• Durch diesen Mechanismus müssen Fluggesellschaften nicht mehr ständig alle Benutzer beobachten.

Eigentlich verwenden

Gegenstand

--Boss und Untergebene

• Fordern Sie mehrere Untergebene an, um Ergebnisse zu erstellen
• Sagen Sie Ihrem Chef den Abschlussbericht

• Der Ort zur Vorbereitung der Observer-Schnittstelle ist der Schlüssel
• Definieren Sie in der Observer-Oberfläche eine Aktualisierungsmethode, die als Kontaktpunkt für den Empfang von Benachrichtigungen vom Beobachtungsziel dient, wenn sich das Beobachtungsziel ändert. --Erstellen Sie eine zu beobachtende abstrakte Subject-Klasse
• Implementieren Sie eine add_observer-Methode, um Observer-Instanzen frei hinzuzufügen, und eine notify_observers-Methode, um alle eigenen Observer-Instanzen über Änderungen zu benachrichtigen.

Zusammenfassung der Beobachtermuster

Erinnerungsmuster

• Andenken: Souvenir, Andenken
• Durch Speichern des Status der Instanz als Snapshot ist es möglich, den Status der Instanz zu diesem Zeitpunkt wiederherzustellen.
• Es ist möglich, dass sich der Status der Instanz während der Programmausführung stetig ändert.
• Eine Anforderung wie "Ich möchte zum vorherigen Status zurückkehren" oder "Ich möchte zu einem bestimmten Zeitpunkt zum Status zurückkehren" kann für eine Instanz auftreten, die sich einmal geändert hat.
• Mit dem Memento-Muster können Sie den Status einer Instanz zu einem bestimmten Zeitpunkt einfach als Schnappschuss erfassen und von dort aus sogar wiederherstellen.
• Obwohl Klone erstellt werden können, um den Status aller Instanzen zu speichern, berücksichtigt das Memento-Muster, dass nur die benötigten Informationen beibehalten und nur die benötigten Daten wiederhergestellt werden.

Eigentlich verwenden

Gegenstand

--Zusatz ――Adding 1 bis 5 ...

• 1+2+3+4+5=15 ――Nächste, wenn Sie 1 bis 10 hinzufügen ...?
• Muster 1: `` `1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = 55```
• Muster 2: `` `15 + 6 + 7 + 8 + 9 + 10 = 55``` --Pattern 2 ist das Memento-Muster
• Machen Sie diesen Code

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


class Memento:
    """Erinnerungsklasse, die den Überblick behält"""
    result = -1 #Stellt den Fortschritt der Berechnung dar

    def __init__(self, temp):
        """Konstruktor, der den Berechnungsfortschritt als Argument erhält"""
        Memento.result = temp


class Calc:
    """Eine Klasse, die eine einzelne Berechnung darstellt."""
    temp = 0

    @staticmethod
    def plus(plus):
        """Methode zur Durchführung der Addition"""
        Calc.temp += plus

    @staticmethod
    def create_memento():
        """Eine Methode, um den Fortschritt als Memento zu erhalten"""
        return Memento(Calc.temp)

    @staticmethod
    def set_memento(memento: Memento):
        """Holen Sie sich den Berechnungsfortschritt von Memento und stellen Sie ihn auf temp"""
        Calc.temp = memento.result

    @staticmethod
    def get_temp():
        """Methode, um das Berechnungsergebnis zu erhalten"""
        return Calc.temp


class Calculator:

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

    def run(self):
        c = Calc()

        #Erste Berechnung
        for i in range(1, 6):
            c.plus(i)

        print(f"Zugabe bis zu 5: {c.get_temp()}")
        self.result_dict["Zugabe bis zu 5"] = c.create_memento()

        #Zweite Berechnung
        c2 = Calc()
        c2.set_memento(self.result_dict["Zugabe bis zu 5"])

        #Erste Berechnung
        for i in range(6, 11):
            c2.plus(i)

        print(f"Zugabe bis zu 10: {c2.get_temp()}")
        self.result_dict["Zugabe bis zu 10"] = c2.get_temp()


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

――Wenn Sie eine bestimmte Phase als "Schnappschuss" verlassen, können Sie schnell zu diesem Status zurückkehren.

• Im Memento-Muster muss Originator (hier Calc) entscheiden, welcher Wert als Memento belassen werden soll. --Originator hinterlässt die Informationen, die er für erforderlich hält, als Memento und stellt den Status von Memento wieder her

Zusammenfassung der Erinnerungsmuster

Zustandsmuster

• Im objektorientierten Design werden Dinge oft als Klassen dargestellt.
• Ein Muster, das "Zustand" als Klasse ausdrückt, nicht als Sache

Eigentlich verwenden

Gegenstand

• Gespräch bei der Arbeit ――Die Art und Weise, wie Sie Aufgaben zuweisen, hängt von der Stimmung Ihres Chefs ab (ich hasse diese Art von Arbeitsplatz ...)
• Wenn Sie gute Laune haben

Untergebene: Guten Morgen
Boss: Guten Morgen
Untergebene: Ich mache heute xxx
Boss: Viel Glück

• Wenn Sie schlechte Laune haben

Untergebene: Guten Morgen
Boss: Oh
Untergebene: Ich mache heute xxx
Boss: Hey, hast du mir gesagt, ich soll ooo machen? Hast du es getan?
Untergebene: (habe ich nicht gehört ...) Es tut mir leid, ich werde es bald tun! !! !! !! !! !! !! !!

--Code

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


class Boss:
    STATE_ORDINARY = 0  #Normaler Chef
    STATE_IN_BAD_MOOD = 1   #Chef schlecht gelaunt

    def __init__(self):
        self.state = -1  #Repräsentiert den Status des Chefs

    def change_state(self, state):
        """Ändern Sie den Status Ihres Chefs"""
        self.state = state

    def morning_greet(self):
        """Geben Sie den Morgengruß zurück"""
        if self.state == Boss.STATE_ORDINARY:
            return "Guten Morgen"
        elif self.state == Boss.STATE_IN_BAD_MOOD:
            return "Oh"
        else:
            pass

    def assign_task(self):
        """Schütteln Sie die Aufgabe"""
        if self.state == Boss.STATE_ORDINARY:
            return "Viel Glück"
        elif self.state == Boss.STATE_IN_BAD_MOOD:
            return "Hey, hast du ooo gesagt? Hast du es getan?"
        else:
            pass

――Angenommen, der Chef Ihres Chefs hat darauf hingewiesen und Sie haben begonnen, besser damit umzugehen → Ein neues Muster wurde geboren ――Es ist nicht cool, den if-Zweig zu ändern

• Bereiten Sie im Statusmuster eine Klasse vor, die den "Status" darstellt, und machen Sie diesen "Status" austauschbar.
• Im Fall eines Beispielfalls sind zunächst "diagonaler Zustand guter Laune" und "normaler Zustand" erforderlich.
• Der Status kann von jeder Klasse geändert werden, aber in diesem Fall wird er von irgendwo im Inneren geändert.

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


class State(metaclass=ABCMeta):

    @staticmethod
    def morning_greet():
        """Morgengruß"""
        pass

    @staticmethod
    def assign_task():
        """Schütteln Sie die Aufgabe"""
        pass


class BadMoodState(State):

    @staticmethod
    def morning_greet():
        return "Oh"

    @staticmethod
    def assign_task():
        return "Hey, hast du ooo gesagt? Hast du es getan?"


class OrdinaryState(State):

    @staticmethod
    def morning_greet():
        return "Guten Morgen"

    @staticmethod
    def assign_task():
        return "Viel Glück"


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("=====Tag 1: Gute Laune=====")
    boss_state.change_state(OrdinaryState())
    print("Untergebene: Guten Morgen")
    print(f"Boss:{boss_state.morning_greet()}")
    print("Untergebene: Ich mache heute xxx")
    print(f"Boss:{boss_state.assign_task()}")

    print("=====Tag 2: schlechte Laune=====")
    boss_state.change_state(BadMoodState())
    print("Untergebene: Guten Morgen")
    print(f"Boss:{boss_state.morning_greet()}")
    print("Untergebene: Ich mache heute xxx")
    print(f"Boss:{boss_state.assign_task()}")

=====Tag 1: Gute Laune=====
Untergebene: Guten Morgen
Boss: Guten Morgen
Untergebene: Ich mache heute xxx
Boss: Viel Glück
=====Tag 2: schlechte Laune=====
Untergebene: Guten Morgen
Boss: Oh
Untergebene: Ich mache heute xxx
Boss: Hey, hast du mir gesagt, ich soll ooo machen? Hast du es getan?

Auf diese Weise ist es einfach zu reagieren, selbst wenn das Stimmungsmuster zunimmt

(Unterlassung)
class GoodMoodState(State):

    @staticmethod
    def morning_greet():
        return "Guten Morgen! Lassen Sie uns heute unser Bestes geben!"

    @staticmethod
    def assign_task():
        return "Wie schön! Das andere ooo war auch nett! Viel Glück mit dieser Bedingung!"
(Weggelassen)
    print("=====Tag 3: Gute Laune=====")
    boss_state.change_state(GoodMoodState())    #Ändern Sie einfach hier
    print("Untergebene: Guten Morgen")
    print(f"Boss:{boss_state.morning_greet()}")
    print("Untergebene: Ich mache heute xxx")
    print(f"Boss:{boss_state.assign_task()}")

=====Tag 3: Gute Laune=====
Untergebene: Guten Morgen
Boss: Guten Morgen! Lassen Sie uns heute unser Bestes geben!
Untergebene: Ich mache heute xxx
Boss: Gut! Das andere ooo war auch nett! Viel Glück mit dieser Bedingung!

Zusammenfassung der Zustandsmuster

Fliegengewichtsmuster

--Flyweight: bedeutet auf Englisch "Fliegengewicht" --Muster konzentrierten sich auf die Verschwendung von Ressourcen durch gemeinsame Nutzung von Instanzen --Beispiel: Das kleine Bild, das für den Hintergrund der Homepage verwendet wird, wird nicht so oft über das Netzwerk ausgetauscht, wie es im Hintergrund angezeigt wird. In der Regel wird das Bild jedoch einmal erfasst und "das Bild" nebeneinander angezeigt.

• Ein Muster, das darauf abzielt, das gesamte Programm zu vereinfachen, indem dieselbe Instanz gemeinsam genutzt wird, um keine nutzlosen Instanzen zu erstellen.

Eigentlich verwenden

Gegenstand

--Versuchen Sie, eine Nachricht mit "menschlichen Zeichen" zu erstellen. ―― "Ai ist besser als Ao" ――Machen Sie jedes Zeichen mit "menschlichen Zeichen", machen Sie ein Bild vom Dach und lassen Sie es im Bild. --Wenn die Klasse, die ein einzelnes menschliches Zeichen darstellt, die HumanLetter-Klasse ist, lautet die Klasse, die eine Nachricht mit menschlichen Zeichen generiert, wie folgt.

# -*- 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):
        """Mach ein Foto"""
        print(letter.get_letter())

    def main(self):
        """Erstellen Sie einen Brief"""
        a = HumanLetter("Ah")
        self.take_a_photo(a)

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

        ha = HumanLetter("Ist")
        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("Ebenfalls")
        self.take_a_photo(mo)

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

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

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


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

――Das gleiche Zeichen wird häufig angezeigt. ――Wenn Sie nur ein Bild aufnehmen, können Sie es wiederverwenden ...

# -*- 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):
        """Mach ein Foto"""
        print(letter.get_letter())

    def main(self):
        """Erstellen Sie einen Brief"""
        a = HumanLetter("Ah")
        self.take_a_photo(a)

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

        ha = HumanLetter("Ist")
        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("Ebenfalls")
        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()

――Wir konnten die Anzahl kostspieliger Instanziierungen reduzieren (hier ein Konstruktor, der Personen neu anordnet, um Zeichen zu bilden. Ursprünglich kann der DB-Zugriff usw. in Betracht gezogen werden). Natürlich nimmt auch die Anzahl der Instanzen ab.

• Weitere Reduzierung mit Fliegengewichtsmuster --Erstellen Sie eine Factory-Klasse, die Instanzen erstellt und verwaltet, die beleuchtet werden sollen, und rufen Sie Instanzen ab, die durch diese Factory-Klasse beleuchtet werden sollen.

# -*- 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):
        """Mach ein Foto"""
        print(letter.get_letter())

    def main(self):
        """Erstellen Sie einen Brief"""

        #Singleton erstellen
        hlf = HumanLetterFactory()

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

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

        ha = hlf.get_human_letter("Ist")
        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("Ebenfalls")
        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("ich")
        self.take_a_photo(i2)
        print(i2)


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

Ah
<__main__.HumanLetter object at 0x1039c4da0> #Es ist eine häufige Instanz in "A"
ich
<__main__.HumanLetter object at 0x1039c4dd8>
Ist
Ah
<__main__.HumanLetter object at 0x1039c4da0>  #Es ist eine häufige Instanz in "A"
Oh
<__main__.HumanLetter object at 0x1039c4e48>
Yo
Ri
Ebenfalls
Ah
<__main__.HumanLetter object at 0x1039c4da0> #Es ist eine häufige Instanz in "A"
Oh
<__main__.HumanLetter object at 0x1039c4e48>
ich
<__main__.HumanLetter object at 0x1039c4dd8>

• Indem Sie die Factory-Klasse Singleton erstellen, können Sie verhindern, dass mehrere Factory-Klassen generiert werden.
  • Singleton
• Die Methode get_human_letter der HumanLetterFactory-Klasse fragt das verwaltete Diktat ab. Wenn Sie eine Instanz benötigen, die ein bereits vorhandenes Zeichen darstellt, müssen Sie es nicht neu erstellen.
• Wenn Sie nach einem Zeichen gefragt werden, das Sie nicht haben, instanziieren Sie es, registrieren Sie es in der Karte und geben Sie die generierte Instanz zurück.
• Durch die Verwendung des Flyweight-Musters muss der Benutzer (Aufrufer wie die Hauptklasse) nicht wissen, über welche Instanz er verfügt. Darüber hinaus ist es möglich, Anfragen von mehreren Callees ohne Abfall zu beantworten.
• Hinweis
• Das Flyweight-Muster teilt überall eine Instanz, daher sollte es nur verwendet werden, wenn die gemeinsam genutzte Instanz nur intrinsische Informationen enthält.
• DB-Verbindung
• Extrinsische Informationen können von jemandem geändert werden. Wenn jemand die freigegebene Instanz selbst ändert, kann dies hier und da Auswirkungen haben. ..

Zusammenfassung des Fliegengewichtsmusters