Método de estado: patrones de diseño de Python

El método de estado es un patrón de diseño de comportamiento que permite que un objeto cambie su comportamiento cuando ocurre un cambio en su estado interno. Ayuda a implementar el estado como una clase derivada de la interfaz de patrón de estado. Si tenemos que cambiar el comportamiento de un objeto en función de su estado, podemos tener una variable de estado en el Objeto y usar el bloque de condición if-else para realizar diferentes acciones en función del estado. Puede denominarse máquina de estado orientada a objetos. Implementa las transiciones de estado invocando métodos de la superclase del patrón.

Problema sin usar el método de estado

El patrón del método State representa la máquina de estados finitos .

Diagrama de máquina de estados finitos

En cualquier momento, puede haber un no finito. de estados que pueden estar presentes en el programa. Cada estado es único en su tipo de comportamiento y otras cosas. Incluso el programa puede cambiar de un estado a otro en cualquier momento. Un programa puede pasar de un estado a otro si y solo si la transición requerida está disponible en las reglas. Ciertamente será difícil cuando agreguemos una gran cantidad de estados. Se volverá difícil manejar el código ya que cualquier pequeño cambio en la lógica de transición puede conducir a un cambio en los condicionales de estado en cada método. =

Solución utilizando el método de estado

Echemos un vistazo a la solución al problema descrito anteriormente considerando el ejemplo de Radio . Aquí la radio tiene dos estados denominados Am State y FM State . Podemos usar el interruptor para alternar entre estos dos estados. El método State sugiere que deberíamos crear una nueva clase para todos los estados posibles de un objeto y extraer todos los comportamientos específicos del estado en estas clases. En lugar de implementar todos los comportamientos por sí solo, el objeto original llamado contexto almacena una referencia a uno de los objetos de estado que representa su estado actual y representa todo el trabajo relacionado con el estado de ese objeto.

Problema-sin-Estado-Método

"""State class: Base State class"""
class State:
 
    """Base state. This is to share functionality"""
 
    def scan(self):
         
        """Scan the dial to the next station"""
        self.pos += 1
 
        """check for the last station"""
        if self.pos == len(self.stations):
            self.pos = 0
        print("Visiting... Station is {} {}".format(self.stations[self.pos], self.name))
 
"""Separate Class for AM state of the radio"""
class AmState(State):
 
    """constructor for AM state class"""
    def __init__(self, radio):
         
        self.radio = radio
        self.stations = ["1250", "1380", "1510"]
        self.pos = 0
        self.name = "AM"
 
    """method for toggling the state"""
    def toggle_amfm(self):
        print("Switching to FM")
        self.radio.state = self.radio.fmstate
 
"""Separate class for FM state"""
class FmState(State):
 
    """Constriuctor for FM state"""
    def __init__(self, radio):
        self.radio = radio
        self.stations = ["81.3", "89.1", "103.9"]
        self.pos = 0
        self.name = "FM"
 
    """method for toggling the state"""
    def toggle_amfm(self):
        print("Switching to AM")
        self.radio.state = self.radio.amstate
 
"""Dedicated class Radio"""
class Radio:
 
    """A radio. It has a scan button, and an AM / FM toggle switch."""
 
    def __init__(self):
         
        """We have an AM state and an FM state"""
        self.fmstate = FmState(self)
        self.amstate = AmState(self)
        self.state = self.fmstate
 
    """method to toggle the switch"""
    def toggle_amfm(self):
        self.state.toggle_amfm()
 
    """method to scan """
    def scan(self):
        self.state.scan()
 
""" main method """
if __name__ == "__main__":
 
    """ create radio object"""
    radio = Radio()
    actions = [radio.scan] * 3 + [radio.toggle_amfm] + [radio.scan] * 3
    actions *= 2
 
    for action in actions:
        action()

Producción

Visiting... Station is 89.1 FM
Visiting... Station is 103.9 FM
Visiting... Station is 81.3 FM
Switching to AM
Visiting... Station is 1380 AM
Visiting... Station is 1510 AM
Visiting... Station is 1250 AM
Visiting... Station is 1380 AM
Visiting... Station is 1510 AM
Visiting... Station is 1250 AM
Switching to FM
Visiting... Station is 89.1 FM
Visiting... Station is 103.9 FM
Visiting... Station is 81.3 FM

Diagrama UML

El siguiente es el diagrama UML para el método de estado

UML-diagrama-estado-método

Ventajas

• Principio abierto/cerrado: podemos introducir fácilmente los nuevos estados sin cambiar el contenido de los estados existentes del código del cliente.
• Principio de responsabilidad única: ayuda a organizar el código de estados particulares en clases separadas, lo que también ayuda a que el código sea factible para los otros desarrolladores.
• Mejora la cohesión: también mejora la cohesión, ya que los comportamientos específicos del estado se agregan a las clases ConcreteState, que se colocan en una ubicación en el código.

Desventajas

• Hacer que el sistema sea complejo: si un sistema tiene solo unos pocos estados, entonces no es una buena opción usar el método de estado, ya que terminará agregando código innecesario.
• Cambio de estado en tiempo de ejecución: el método de estado se usa cuando necesitamos cambiar el estado en tiempo de ejecución ingresando diferentes subclases, esto también se considerará una desventaja porque tenemos clases de estado claras y separadas con algo de lógica. y por otro lado crece el número de clases.
• Dependencias de subclases: aquí cada clase derivada de estado se acopla a su hermano, lo que directa o indirectamente introduce las dependencias entre subclases.

Lectura adicional: método de estado en Java