Apprenez le modèle de conception "Méthode de modèle" en Python

En tant que matériel d'apprentissage des modèles de conception du GoF, le livre «Introduction aux modèles de conception appris dans le langage Java augmenté et révisé» semble être utile. Cependant, comme les exemples repris sont basés sur JAVA, j'ai essayé la même pratique avec Python pour approfondir ma compréhension.

■ Méthode de modèle (modèle de méthode de modèle)

Le modèle de méthode de modèle est l'un des modèles de conception définis par le GoF (Gang of Four; 4 gangs). Il appartient aux "Patterns liés au comportement". Le but du modèle de méthode de modèle est de prédéterminer un algorithme approximatif pour un processus et de laisser la conception spécifique de cet algorithme à une sous-classe. Par conséquent, il est souvent utilisé comme un moyen de construire un cadre système.

UML class diagram (Ce qui précède est cité sur Wikipedia)

■ Exemple de programme "Méthode modèle"

Je voudrais exécuter un exemple de programme qui utilise le modèle de méthode modèle et vérifier le comportement suivant.

--Affichez la lettre «H» cinq fois de suite. De plus, avant et après, il est affiché entouré de "** << " et " >> **". --Affichez la chaîne de caractères "Hello, World!" 5 fois de suite. De plus, il est affiché entouré d'un cadre.

$ python Main.py 
<<HHHHH>>

+-------------+
|Hello, World!|
|Hello, World!|
|Hello, World!|
|Hello, World!|
|Hello, World!|
+-------------+

■ Détails de l'exemple de programme

Un code similaire a été téléchargé dans le référentiel Git. https://github.com/ttsubo/study_of_design_pattern/tree/master/TemplateMethod

• Structure du répertoire

.
├── Main.py
└── templatemethod
    ├── __init__.py
    └── display.py

(1) Le rôle de AbstractClass

Le rôle ʻAbstractClassimplémente la méthode de modèle. Déclarez également la méthode abstraite utilisée dans la méthode modèle. Cette méthode abstraite est implémentée par le rôle de la sous-classeConcreteClass. Dans l'exemple de programme, la classe ʻAbstractDisplay remplit ce rôle.

templatemethod/display.py

from abc import ABCMeta, abstractmethod

class AbstractDisplay(metaclass=ABCMeta):
    @abstractmethod
    def print(self):
        pass

    @abstractmethod
    def open(self):
        pass

    @abstractmethod
    def close(self):
        pass

    def display(self):
        self.open()
        for _ in range(5):
            self.print()
        self.close()

(2) Le rôle de ConcreteClass

Implémentez concrètement la classe abstraite définie par le rôle de ʻAbstractClass. La méthode implémentée ici est appelée à partir de la méthode template qui joue le rôle de ʻAbstractClass. Dans l'exemple de programme, les classes CharDisplay et StringDisplay remplissent ce rôle.

templatemethod/display.py

class CharDisplay(AbstractDisplay):
    def __init__(self, ch):
        self.__ch = ch

    def open(self):
        print('<<', end='')

    def print(self):
        print(self.__ch, end='')

    def close(self):
        print('>>')

class StringDisplay(AbstractDisplay):
    def __init__(self, string):
        self.__string = string
        self.__width = len(string)

    def open(self):
        self.__printLine()

    def print(self):
        print("|{0}|".format(self.__string))

    def close(self):
        self.__printLine()

    def __printLine(self):
        print('+', end='')
        for _ in range(self.__width):
            print('-', end='')
        print('+')

(3) Le rôle du client (utilisateur)

Dans l'exemple de programme, la méthode startMain remplit ce rôle.

Main.py

from templatemethod.display import CharDisplay, StringDisplay

def startMain():
    d1 = CharDisplay('H')
    d2 = StringDisplay("Hello, World!")
    d1.display()
    print("")
    d2.display()

if __name__ == '__main__':
    startMain()

■ URL de référence

• Finition "Introduction aux modèles de conception appris en langage Java" (non) Introduction aux modèles de conception appris dans Language-Finishing-No-2cc9b34a30b2)