Apprenez le modèle de conception "État" en Python

J'aimerais apprendre les modèles de conception GoF en Python.

■ État (modèle d'état)

Le modèle d'état est un type de modèle de conception comportementale utilisé dans la programmation. Ce modèle est utilisé pour représenter l'état d'un objet. C'est une manière propre de travailler avec des objets qui changent partiellement de type au moment de l'exécution.

UML class and sequence diagram W3sDesign_State_Design_Pattern_UML.jpg UML class diagram state.png (Ce qui précède est cité sur Wikipedia)

□ Mémorandum

Dans le modèle «État», il semble que la chose appelée «état» soit exprimée par une classe. Il est possible de partager ici le comportement dépendant de l'état avec le rôle ConcreteState. Cependant, lorsque vous utilisez le modèle State, il est important de noter que ** qui doit gérer la transition d'état **. (Laisser la transition de l'état au rôle de ConcreteState approfondit la dépendance entre les classes.)

■ Exemple de programme "State"

En fait, je voudrais exécuter un exemple de programme qui utilise le modèle State et vérifier le comportement suivant. Ici, imaginez "Visualisation de l'état de démarrage en utilisant un ordinateur" </ font>.

--Lorsque vous démarrez votre ordinateur, l'état de fonctionnement sera "en cours d'exécution". --Lorsque vous arrêtez l'ordinateur, l'état de fonctionnement devient "shutdown". --Lorsque vous redémarrez votre ordinateur, l'état de fonctionnement passe à "en cours d'exécution".

Dans l'exemple de programme, spécifiez ** premier argument: première opération d'ordinateur **, ** deuxième argument: deuxième opération d'ordinateur **.

(Cas 1) Démarrez et arrêtez l'ordinateur

L'état de fonctionnement est d'abord «en cours d'exécution» en démarrant sur l'ordinateur, puis «en arrêt» en arrêtant l'ordinateur.

$ python Main.py start stop
###PC,[start]Faire
***L'ordinateur fonctionne
###L'ordinateur personnel[running]Est maintenant en service

... sleep 5 second

###PC,[stop]Faire
***L'ordinateur est arrêté
###L'état de fonctionnement de l'ordinateur personnel[shutdown]devenu

(Cas 2) Démarrez l'ordinateur et redémarrez-le

L'état de fonctionnement devient d'abord «en cours d'exécution» lorsque l'ordinateur est démarré, puis il redevient «en cours d'exécution» lorsque l'ordinateur est redémarré.

$ python Main.py start restart
###PC,[start]Faire
***L'ordinateur fonctionne
###L'ordinateur personnel[running]Est maintenant en service

... sleep 5 second

###PC,[restart]Faire
***L'ordinateur commencera à redémarrer
***L'ordinateur fonctionne
###L'état de fonctionnement de l'ordinateur personnel[running]devenu

L'exemple de programme a fonctionné comme prévu.

■ 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/State

  • Structure du répertoire
.
├── Main.py
└── state
    ├── __init__.py
    ├── context.py
    └── state.py

(1) Le rôle de l'État

Le rôle «État» est de représenter un état. Définit une interface qui se comporte différemment pour chaque état. Dans l'exemple de programme, la classe State remplit ce rôle.

state/state.py


from abc import ABCMeta, abstractmethod

class State(metaclass=ABCMeta):
    @abstractmethod
    def handle(self):
        pass

(2) Le rôle de ConcreteState

Le rôle ConcreteState représente un état individuel spécifique. Implémentez concrètement l'interface définie par le rôle State. Dans l'exemple de programme

  • ClasseConcreteStateBooting
  • ClasseConcreteStateRun
  • ClasseConcreteStateShutDown
  • ClasseConcreteStateRestart

Cependant, je vais essayer ce rôle.

state/state.py


class ConcreteState(State):
    def __init__(self, state):
        self.state = state
    
    def getConcreateState(self):
        return self.state


class ConcreteStateBooting(ConcreteState):
    def __init__(self, state):
        super(ConcreteStateBooting, self).__init__(state)

    def handle(self, context):
        print("***L'ordinateur fonctionne")
        context.setState(ConcreteStateRun("running"))


class ConcreteStateRun(ConcreteState):
    def __init__(self, state):
        super(ConcreteStateRun, self).__init__(state)

    def handle(self, context):
        print("***L'ordinateur fonctionne")


class ConcreteStateShutDown(ConcreteState):
    def __init__(self, state):
        super(ConcreteStateShutDown, self).__init__(state)

    def handle(self, context):
        print("***L'ordinateur est arrêté")


class ConcreteStateRestart(ConcreteState):
    def __init__(self, state):
        super(ConcreteStateRestart, self).__init__(state)

    def handle(self, context):
        print("***L'ordinateur commencera à redémarrer")
        context.setState(ConcreteStateBooting("booting"))
        context.handle()

(3) Rôle du contexte (état, contexte, contexte)

Le rôle Context contient un objet du rôle ConcreteState qui représente l'état actuel. Dans l'exemple de programme, la classe Context remplit ce rôle.

state/context.py


class Context(object):
    def __init__(self, stateObj):
        self.state = stateObj

    def setState(self, obj):
        self.state = obj
    
    def handle(self):
        self.state.handle(self)

    def getState(self):
        return self.state.getConcreateState()

(4) Le rôle du client

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

Main.py


import sys
import time
from state.context import Context
from state.state import ConcreteStateBooting, ConcreteStateRun, ConcreteStateShutDown, ConcreteStateRestart


def setConcreteState(operation):
    if operation == "start":
        return ConcreteStateBooting("booting")
    elif operation == "stop":
        return ConcreteStateShutDown("shutdown")
    elif operation == "restart":
        return ConcreteStateRestart("restart")

def startMain(initial_operation, change_operation):
    obj = Context(setConcreteState(initial_operation))
    print("###PC,[{0}]Faire".format(initial_operation))
    obj.handle()
    print("###L'ordinateur personnel[{0}]Est maintenant en service".format(obj.getState()))
    print("")

    print("... sleep 5 second")
    print("")
    time.sleep(5)

    obj.setState(setConcreteState(change_operation))
    print("###PC,[{0}]Faire".format(change_operation))
    obj.handle()
    print("###L'état de fonctionnement de l'ordinateur personnel[{0}]devenu".format(obj.getState()))


if __name__ == "__main__":
    startMain(sys.argv[1], sys.argv[2])

■ URL de référence

Recommended Posts

Apprenez le modèle de conception "État" en Python
Apprenez le modèle de conception "Prototype" avec Python
Apprenez le modèle de conception "Builder" avec Python
Apprenez le modèle de conception "Flyweight" en Python
Apprenez le modèle de conception "Observer" en Python
Apprenez le modèle de conception "Memento" avec Python
Apprenez le modèle de conception "Proxy" en Python
Apprenez le modèle de conception "Commande" en Python
Apprenez le modèle de conception "Visiteur" avec Python
Apprenez le modèle de conception "Bridge" avec Python
Apprenez le modèle de conception "Mediator" avec Python
Apprenez le modèle de conception "Décorateur" avec Python
Apprenez le modèle de conception "Iterator" avec Python
Apprenez le modèle de conception «Stratégie» avec Python
Apprenez le modèle de conception "Composite" avec Python
Apprenez le modèle de conception "Adapter" avec Python
Apprenez le modèle de conception "Abstract Factory" avec Python
Apprenez le modèle de conception "Méthode de modèle" en Python
Apprenez le modèle de conception "Méthode d'usine" en Python
Apprenez le modèle de conception «Chaîne de responsabilité» en Python
Apprenez le modèle de conception "Singleton" avec Python
Apprenez le modèle de conception "Façade" avec Python
Implémenter le modèle Singleton en Python
Modèle de visiteur en Python
Monade d'État en Python
Trouver des erreurs en Python
Modèles de conception en Python: introduction
Python Design Pattern - Méthode de modèle
Obtenir l'API arXiv en Python
Python dans le navigateur: la recommandation de Brython
Enregistrez le fichier binaire en Python
Frappez l'API Sesami en Python
Obtenez le chemin du bureau en Python
Obtenez le chemin du script en Python
Dans la commande python, python pointe vers python3.8
Accédez à l'API Web en Python
J'ai écrit la file d'attente en Python
Calculer le mois précédent en Python
Examiner la classe d'un objet avec python
Obtenez le chemin du bureau en Python
Obtenez le nom d'hôte en Python
Accéder à l'API Twitter avec Python
La première étape de Python Matplotlib
J'ai écrit la pile en Python
Modèle d'espace d'états personnalisé en Python
Maîtriser le module lowref en Python
Apprenez les bases de Python ① Débutants élémentaires
Charger le SDK Python distant avec IntelliJ
Essayez d'utiliser l'API Wunderlist en Python
Vérifiez le comportement du destroyer en Python
[Python Kivy] À propos de la modification du thème de conception
Essayez d'utiliser l'API Kraken avec Python
Apprenez les bases en touchant les variables python
Ecrire le test dans la docstring python
Prenez la somme logique de List en Python (fonction zip)
Modèle de conception du GoF à partir du problème 2. Structure
Afficher Python 3 dans le navigateur avec MAMP
Tweet à l'aide de l'API Twitter en Python
Vérifiez si l'URL existe en Python