[PYTHON] Design Pattern #Template, méthode

J'ai pratiqué les modèles de conception afin de pouvoir écrire du code conscient du design. D'autres modèles de conception seront publiés fréquemment.

Préface

• Introduction aux modèles de conception appris en langage Java est passé de Java à Python. (Python est 3.4.2)
• Le code est sur github (certains d'entre eux ne fonctionnent toujours pas)

L'objectif principal est de comprendre quand, quoi et comment utiliser les modèles de conception. (Je suis nouveau en Java ou dans un langage à typage statique, et je n'ai pas une longue histoire de python, donc je pense qu'il y a des choses qui ne ressemblent pas à Pythonista. Si vous avez des suggestions, apprenez-moi.)

Cette fois, la méthode modèle du modèle était liée au comportement.

Qu'est-ce que la méthode de modèle?

Un modèle de conception dans lequel la superclasse définit le cadre de traitement et la sous-classe définit le contenu spécifique. C'est ça? En d'autres termes, puisque l'algorithme est décrit par la méthode de modèle de la super classe, il n'est pas nécessaire de décrire l'algorithme un par un du côté de la sous-classe. Ensuite, si la programmation est effectuée à l'aide du modèle de méthode modèle, même si une erreur est trouvée dans la méthode modèle, il est possible de réduire le problème de la correction ultérieure dans laquelle seule la méthode modèle doit être corrigée.

En d'autres termes, l'algorithme approximatif doit être décidé à l'avance par la superclasse, et la conception et le traitement concrets de l'algorithme doivent être effectués par la sous-classe.

Aperçu

L'exemple de programme créé ici affiche «des caractères et des chaînes de caractères répétés 5 fois». Ici, il se compose de trois classes, AbstractDisplay, CharDisplay et StringDisplay, et Main (fichier d'exécution). La méthode d'affichage est définie dans la classe AbstractDisplay. Et dans la méthode d'affichage, trois méthodes, ouverture, impression et fermeture, sont utilisées. Ces trois méthodes sont également déclarées dans la classe AbstractDisplay, mais ce sont des méthodes abstraites intangibles. Ici, la méthode d'affichage, qui utilise une méthode abstraite, est la méthode modèle. Les implémentations réelles des méthodes open, print et close sont les classes CharDisplay et StringDisplay, qui sont des sous-classes de la classe AbstractDisplay. Il y a une figure ci-dessous.

abstract_display.py

from abc import ABCMeta, abstractmethod

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

    @abstractmethod     
    def printing(self):
        pass
        
    @abstractmethod 
    def closing(self):
        pass
    
    def display(self):
        self.opening()
        for i in range(5):
            self.printing()
        self.closing()

char_display.py

import sys
from abstract_display import AbstractDisplay

class CharDisplay(AbstractDisply):
    def __init__(self, ch):
        self.__ch  = ch
    
    def opening(self):
        sys.stdout.write('<<') #Si vous utilisez l'impression, un caractère vide apparaîtra immédiatement après la sortie.
    def printing(self):
        sys.stdout.write(self.__ch)
    
    def closing(self):
        print('>>')   

char_display.py

import sys
from abstract_display import AbstractDisplay

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

    def printing(self):
        self.print('|' + self.__string + '|')
     
    def closing(self):
        self.__print_line() 

    def __print_line(self):
        sys.stdout.write(''.join(('+', '-' * self.__width, '+\n')))  #Si vous utilisez l'impression, un caractère vide apparaîtra immédiatement après la sortie.

main.py

from char_display import CharDisplay
from string_display import StringDisplay


def main():
    d1 = CharDisplay('H')
    d2 = StringDisplay('Hello, World')
    d3 = StringDisplay('Bonjour')
    
    d1.display()
    d2.display()
    d3.display()

if __name__ == '__main__':
    main()

python main.py

<<HHHHH>>
+------------+
|Hello, World|
|Hello, World|
|Hello, World|
|Hello, World|
|Hello, World|
+------------+
+-----+
|Bonjour|
|Bonjour|
|Bonjour|
|Bonjour|
|Bonjour|
+-----+

Quelle est la signification des classes abstraites?

Le contenu réel du traitement ne peut être compris que par des sous-classes, mais il semble important de façonner le flux de traitement au stade de la classe abstraite. S'il existe une classe abstraite, la sous-classe implémente les méthodes qui sont dans la classe abstraite. Rendez ensuite la sous-classe responsable de l'implémentation de la méthode.

Résumé

Les classes abstraites ne peuvent pas être instanciées. Je me demandais à quoi sert la classe, par exemple une classe qui ne peut pas créer d'instance, mais comme le corps de la méthode n'est pas écrit dans la méthode abstraite, je ne connais pas le contenu de traitement spécifique. Cependant, il est possible de décider du nom de la méthode et de décrire le processus par la méthode modèle qui utilise la méthode, et en standardisant le processus, la possibilité de correction ou de bogue peut être réduite.

Le modèle de conception est [Separation of Interest](http://ja.wikipedia.org/wiki/%E9%96%A2%E5%BF%83%E3%81%AE%E5%88%86%E9%9B% Je pense que A2) est la base.

référence

• Modèle de conception TECHSCORE
• Wikipedia Software design pattern
• Modèle de conception Wikipedia
• En apprenant avec Ruby 2.0.0, j'ai créé 14 modèles de conception [GoF] [Modèle de conception]
• 5 principes des modèles de conception par Ruby