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

El método Flyweight es un patrón de diseño estructural que se enfoca en minimizar la cantidad de objetos que requiere el programa en tiempo de ejecución. Básicamente, crea un objeto Flyweight que es compartido por múltiples contextos. Está creado de tal manera que no se puede distinguir entre un objeto y un Objeto Flyweight. Una característica importante de los objetos de peso mosca es que son inmutables . Esto significa que no se pueden modificar una vez construidos.
Para implementar el método Flyweight en Python , usamos Dictionary que almacena la referencia al objeto que ya se ha creado, cada objeto está asociado con una clave.
 

¿Por qué nos importa la cantidad de objetos en nuestro programa?

• Menos cantidad de objetos reduce el uso de memoria y logra mantenernos alejados de errores relacionados con la memoria.
• Aunque crear un objeto en Python es realmente rápido, aún podemos reducir el tiempo de ejecución de nuestro programa compartiendo objetos.

Problema sin usar el Método Flyweight

Imagina que eres un desarrollador de juegos al que le gustan mucho los juegos de carreras y también quiere desarrollar un juego de carreras para ti y tu amigo. Como eres un desarrollador de juegos impecable, creaste uno y comenzaste a disfrutar del juego. Luego le enviaste el juego a tu amigo también, pero él no disfrutó demasiado el juego porque el juego se bloqueaba cada pocos minutos. 
¿Pero por qué? (Adivina la razón si crees que eres un desarrollador de juegos profesional) . Después de depurar durante varias horas, descubriste que el problema es la falta de RAM en el sistema de tu amigo. Su sistema es mucho más potente en comparación con el sistema de su amigo, por eso el juego funcionaba sin problemas en su sistema, pero no en el de su amigo.
 

Flyweight-problema-Diagrama

Solución usando el método Flyweight

Entonces, ¿qué harás como desarrollador para mejorar el rendimiento? (¡Por supuesto! No voy a actualizar la RAM) . El problema real está relacionado con los objetos del automóvil porque cada automóvil está representado por objetos separados que contienen muchos datos relacionados con su color, tamaño, asientos, velocidad máxima, etc. lleno y no puede agregar más objetos nuevos que se requieren actualmente, su juego se bloquea. Para evitar este tipo de situaciones en las aplicaciones, es deber previo del desarrollador utilizar el método Flyweight , que le permite incluir más objetos en la cantidad de RAM disponible al compartir partes comunes de los objetos.
 

El siguiente código está escrito usando el método Flyweight
 

class ComplexCars(object):
 
    """Separate class for Complex Cars"""
 
    def __init__(self):
 
        pass
 
    def cars(self, car_name):
 
        return "ComplexPattern[% s]" % (car_name)
 
 
class CarFamilies(object):
 
    """dictionary to store ids of the car"""
 
    car_family = {}
 
    def __new__(cls, name, car_family_id):
        try:
            id = cls.car_family[car_family_id]
        except KeyError:
            id = object.__new__(cls)
            cls.car_family[car_family_id] = id
        return id
 
    def set_car_info(self, car_info):
 
        """set the car information"""
 
        cg = ComplexCars()
        self.car_info = cg.cars(car_info)
 
    def get_car_info(self):
 
        """return the car information"""
 
        return (self.car_info)
 
 
 
if __name__ == '__main__':
    car_data = (('a', 1, 'Audi'), ('a', 2, 'Ferrari'), ('b', 1, 'Audi'))
    car_family_objects = []
    for i in car_data:
        obj = CarFamilies(i[0], i[1])
        obj.set_car_info(i[2])
        car_family_objects.append(obj)
 
    """similar id's says that they are same objects """
 
    for i in car_family_objects:
        print("id = " + str(id(i)))
        print(i.get_car_info())

Producción

id = 58598800
ComplexPattern[Audi]
id = 58598832
ComplexPattern[Ferrari]
id = 58598800
ComplexPattern[Audi]

Diagrama de clase

El siguiente es el diagrama de clases para el método Flyweight
 

Diagrama de clase de peso mosca

Ventajas

• Uso reducido de RAM: cuando tenemos muchos objetos similares presentes en nuestra aplicación, siempre es mejor usar el método Flyweight para ahorrar mucho espacio en RAM
• Almacenamiento en caché de datos mejorado: cuando la necesidad del cliente o usuario es un tiempo de respuesta alto, siempre se prefiere usar el método Flyweight porque ayuda a mejorar el almacenamiento en caché de datos.
• Rendimiento mejorado: en última instancia, conduce a mejorar el rendimiento porque estamos utilizando menos objetos pesados.

Desventajas

• Romper la encapsulación: cada vez que intentamos mover el estado fuera del objeto, rompemos la encapsulación y podemos volvernos menos eficientes que mantener el estado dentro del objeto.
• Difícil de manejar: el uso del método Flyweight depende del lenguaje que usemos, fácil de usar en lenguaje como Python, Java, donde todas las variables de objeto son referencias, pero típico de usar en lenguaje como C, C++, donde los objetos se pueden asignar como variables locales en el pila y destruido como resultado de la acción del programador.
• Código complicado: el uso del método Flyweight siempre aumenta la complejidad del código para que lo entiendan los nuevos desarrolladores.

Aplicabilidad

• Para reducir la cantidad de objetos: generalmente, el método Flyweight se usa cuando nuestra aplicación tiene muchos objetos pesados, para resolver este problema usamos el método Flyweight para eliminar el consumo de memoria innecesario.
• Aplicaciones independientes del objeto: cuando nuestra aplicación es independiente del objeto creado, entonces podemos hacer uso de este método para ahorrar mucho espacio en la máquina.
• Reducción de Costos del Proyecto: Cuando se requiere reducir el costo del proyecto en términos de complejidad espacial y temporal, siempre se prefiere utilizar el método Flyweight.

Lectura adicional: Método Flyweight en Java