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
UML class diagram
(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
- Classe
ConcreteStateBooting - Classe
ConcreteStateRun - Classe
ConcreteStateShutDown - Classe
ConcreteStateRestart
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