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

El método Plantilla es un patrón de diseño de comportamiento que define el esqueleto de la operación y deja que la clase secundaria implemente los detalles. Sus subclases pueden anular las implementaciones del método según sea necesario, pero la invocación debe ser de la misma manera definida por una clase abstracta. Es uno de los patrones de diseño de comportamiento más fáciles de entender e implementar. Dichos métodos son muy utilizados en el desarrollo de marcos, ya que nos permiten reutilizar una sola pieza de código en diferentes lugares al realizar ciertos cambios. Esto conduce a evitar también la duplicación de código.
 

Problema sin usar el método de plantilla

Imagine que está trabajando en una aplicación Chatbot como desarrollador de software que utiliza técnicas de minería de datos para analizar los datos de los documentos corporativos. Inicialmente, sus aplicaciones estaban bien solo con la versión en pdf de los datos, pero luego sus aplicaciones también requieren recopilar y convertir datos de otros formatos, como XML , CSV y otros. Después de implementar todo el escenario para los otros formatos también, notó que todas las clases tienen mucho código similar. Parte del código, como el análisis y el procesamiento, era idéntico en casi todas las clases, mientras que difieren en el tratamiento de los datos.
 

Problema-plantilla-método

Solución utilizando el método de plantilla

Analicemos la solución al problema descrito anteriormente utilizando el método de plantilla. Sugiere dividir el código en una serie de pasos y convertir estos pasos en métodos y poner la llamada en serie dentro de template_function. Por lo tanto, creamos template_function por separado y creamos métodos como get_xml , get_pdf y get_csv para tratar el código por separado.
 

""" method to get the text of file"""
def get_text():
     
    return "plain_text"
 
""" method to get the xml version of file"""
def get_xml():
     
    return "xml"
 
""" method to get the pdf version of file"""
def get_pdf():
     
    return "pdf"
 
"""method to get the csv version of file"""
def get_csv():
     
    return "csv"
 
"""method used to convert the data into text format"""
def convert_to_text(data):
     
    print("[CONVERT]")
    return "{} as text".format(data)
 
"""method used to save the data"""
def saver():
     
    print("[SAVE]")
 
"""helper function named as template_function"""
def template_function(getter, converter = False, to_save = False):
 
    """input data from getter"""
    data = getter()
    print("Got `{}`".format(data))
 
    if len(data) <= 3 and converter:
        data = converter(data)
    else:
        print("Skip conversion")
     
    """saves the data only if user want to save it"""
    if to_save:
        saver()
 
    print("`{}` was processed".format(data))
 
 
"""main method"""
if __name__ == "__main__":
 
    template_function(get_text, to_save = True)
 
    template_function(get_pdf, converter = convert_to_text)
 
    template_function(get_csv, to_save = True)
 
    template_function(get_xml, to_save = True)

Producción

Got `plain_text`
Skip conversion
[SAVE]
`plain_text` was processed
Got `pdf`
[CONVERT]
`pdf as text` was processed
Got `csv`
Skip conversion
[SAVE]
`csv` was processed

Diagrama de clase

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

Clase-diagrama-plantilla-método

Ventajas

• Contenido equivalente: es fácil considerar el código duplicado en la superclase arrastrándolo allí donde desea usarlo.
• Flexibilidad: proporciona una gran flexibilidad, de modo que las subclases pueden decidir cómo implementar los pasos de los algoritmos.
• Posibilidad de herencia: podemos reutilizar nuestro código ya que el método de plantilla utiliza la herencia, lo que proporciona la capacidad de reutilización del código.

Desventajas

• Código complejo: el código puede volverse lo suficientemente complejo a veces al usar el método de plantilla, de modo que se vuelve demasiado difícil de entender el código incluso para los desarrolladores que lo escriben.
• Limitación: los clientes pueden solicitar la versión extendida porque a veces sienten que faltan algoritmos en el esqueleto proporcionado.
• Violación: es posible que al usar el método de plantilla, termine violando el principio de sustitución de Liskov , que definitivamente no es lo bueno a seguir.

Aplicabilidad

• Extensión por parte de los clientes: siempre se prefiere usar este método cuando desea permitir que los clientes amplíen el algoritmo utilizando pasos particulares pero no con toda la estructura del algoritmo.
• Algoritmos similares: cuando tiene muchos algoritmos similares con cambios menores, siempre es mejor usar el patrón de diseño de plantilla porque si ocurren algunos cambios en el algoritmo, entonces no tiene que hacer cambios en cada algoritmo.
• Desarrollo de Frameworks: Es muy recomendable usar el patrón de diseño de plantilla mientras desarrollamos un framework porque nos ayudará a evitar el código duplicado así como a reutilizar la pieza de código una y otra vez haciendo ciertos cambios.

Lectura adicional: método de plantilla en Java