Introducción

¡Hola a todos! Soy Yuscu Mejía y en esta lección vamos a explorar el concepto de delegación en Python. La delegación es una técnica de diseño de software que permite a un objeto pasar una tarea a otro objeto, aprovechando así la funcionalidad de este último.

Características

La delegación en Python tiene las siguientes características:

• Permite a un objeto delegar parte de su funcionalidad a otro objeto.
• Facilita la composición sobre la herencia, permitiendo construir clases complejas a partir de clases más simples.
• Promueve la reutilización del código y la separación de responsabilidades.
• Es útil en la implementación de patrones de diseño como el patrón delegado.

Ejemplos

A continuación, algunos ejemplos de cómo utilizar la delegación en Python, presentados por Yuscu Mejía:

• Definición de una clase que delega una tarea a otra clase:

# Definir una clase llamada 'Motor'
class Motor:
    def encender(self):
        return "El motor está encendido"

    def apagar(self):
        return "El motor está apagado"

# Definir una clase llamada 'Coche' que delega tareas al 'Motor'
class Coche:
    def __init__(self):
        self.motor = Motor()  # Delegación

    def arrancar(self):
        return self.motor.encender()

    def detener(self):
        return self.motor.apagar()

# Crear una instancia de la clase 'Coche'
mi_coche = Coche()
print(mi_coche.arrancar())  # Imprime: El motor está encendido
print(mi_coche.detener())   # Imprime: El motor está apagado

Práctica

Para practicar, les invito a ver nuestro tutorial en video sobre delegación en Python, presentado por Yuscu Mejía:

Recorda si te gusta los videos, te agradeceria si le pones un comentario o un like para saber si subir mas videos! 😮
Si no sabes que comentar, comenta con: estoy avanzando rapido con el curso de Programacion python 🙂 asi te detectaremos que viniste de aca, para una estadistica si conviene o no subir videos

Ejercicio

Ahora les propongo un ejercicio para aplicar lo que hemos aprendido sobre delegación en Python, con la guía de Yuscu Mejía:

Ejercicio 1

Tenemos la clase Persona

class Persona:
    """"Representación de una persona, sus atributos son edad y altura."""
    def __init__(self, edad=12, altura=15):
        """Constructor de Persona. Altura y edad deben ser numéricos y se inicializan por defecto en 15 y 12 respectivamente."""
        self.edad = edad
        self.altura = altura

    def envejecer(self, anios=5):  # self es yo mismo, o sea mi instancia
        """Envejece según los años ingresados."""
        self.edad = self.edad + anios
    

a) Crear una clase llamada Arma que tenga como atributos precio, y como método disparar el cual retorna un string “mi arma es letal”.

b) Quiero que la persona contenga un arma. ¿Qué utilizaría, herencia, polimorfismo o delegación? ¿Por qué?

c) Una vez elegido el formato, incorporarlo y además crear un objeto persona que muestre el precio de su arma, y cómo dispara.

d) Pregunta teórica: ¿Y si quisiera tener más tipos de arma, ejemplo pistola, escopeta? ¿Qué agregarías a lo anterior que hiciste?

Ejercicio 2:

Vamos a crear una clase llamada ControlRemoto que delegue la funcionalidad de encender y apagar un televisor a una clase llamada Televisor:

Ejercicio Resuelto

#a) 
class Arma:
    def __init__(self, precio):
        self.precio = precio

    def disparar(self):
        return "mi arma es letal"

#b) 
# No se utiliza herencia porque un arma no es una persona, y tampoco polimorfismo porque no vamos a redefinir el comportamiento de su clase madre. 
# En cambio, una persona contiene un arma, entonces usamos delegación.

#c) 
class Persona:
    """"Representación de una persona, sus atributos son edad, altura y arma."""
    def __init__(self, edad, altura, arma):
        """Constructor de Persona. Altura y edad deben ser numéricos y se inicializan por defecto en 15 y 12 respectivamente."""
        self.edad = edad
        self.altura = altura
        self.arma = arma

    def envejecer(self, anios=5):
        """Envejece según los años ingresados."""
        self.edad = self.edad + anios

    def atacar(self):
        return "puedo atacarte con mi arma que vale {} y además es {}".format(self.arma.precio, self.arma.disparar())

# Crear un objeto Persona que contenga un Arma
unArma = Arma(20)
unaPersona = Persona(15, 10, unArma)
print(unaPersona.atacar())

#d) 
# Tendría a la clase Arma como clase madre, y sus clases hijas serían Pistola y Escopeta.
class Pistola(Arma):
    def disparar(self):
        return "mi pistola es letal"

class Escopeta(Arma):
    def disparar(self):
        return "mi escopeta es letal"
        

# Definir una clase llamada 'Televisor'
class Televisor:
    def encender(self):
        return "El televisor está encendido"

    def apagar(self):
        return "El televisor está apagado"

# Definir una clase llamada 'ControlRemoto' que delega tareas al 'Televisor'
class ControlRemoto:
    def __init__(self):
        self.televisor = Televisor()  # Delegación

    def encender_televisor(self):
        return self.televisor.encender()

    def apagar_televisor(self):
        return self.televisor.apagar()

# Crear una instancia de la clase 'ControlRemoto'
mi_control = ControlRemoto()
print(mi_control.encender_televisor())  # Imprime: El televisor está encendido
print(mi_control.apagar_televisor())    # Imprime: El televisor está apagado