Apuntes_Python/01_curso/Modulo_3/3-1c_buenas_practicas.py

"""
    ELimar un if, utilizando polimorfismo
   -en el POO todo deberian ser objetos que colaboran enviandose mensajes
   -el IF en Python, no es un mensaje qie se le manda un objeto, sino que es una sentencia del lenguaje

     ISOMORFISMO
   - Si aparece algo nuevo en el domino deber aparecer algo nuevo en el modelo (no modificarlo).
   - Si se modifica algo del dominio, solo se debe modificar su representacion en el modelo.


   En lenguajes de clasificación el "if" se implementa con polimorfismo.

   Usar un "if" no implica no estamos usadno polimorfismo.

   Esto implica que se tiene diseños menos mantenibles y ademas diseños NO orientados a objetos.
"""
#   ej.
llamada = ''

def calculadora_costo_de_llamada(llamada):
    costo = 0
    if llamada.es_local():
        costo = calcular_costo_local_de(llamada)
    elif llamada.es_nacional():
        costo = calcular_costo_internacional_de(llamada)
    elif llamada.es_internacional():
        costo = calcular_costo_internacional_de(llamada)
    return costo

"""
Como sacar el IF?

       1) Crear una jerarquia polimorfica con una abstraccdión por cada condición
       2) Usando el mismo nombre de mensaje repartir el cuerpo del if en cada abstraccion( polimorfismo )
       3) Nombrar el mensaje del paso anterior
       4) Nombrar las abstracciones
       5) Reemplazar if por envío de mensaje polimórfico
       6) Buscar objeto polimoefico si es necesario

Abstaccion
class CondicionSuperClase(object):
    def m(self):
        raise NotImplementedError("Responsabilida de subclase")

class CondicionLocal(CondicionSuperClase):
    def m(self):
        # código de calcular_costo_local_de

class CondicionNacional(CondicionSuperClase):
    def m(self):
        # código de calcular_costo_nacional_de

class CondicionInternacional(CondicionSuperClase):
    def m(self):
        # código de calcular_costo_internacional_de

#   Implementación 1° 2° 3° 4°
"""

class CalcularCostoLLamada(object):

    @classmethod
    def to_handle(clase, llamada):
        pass # Código q busca CalcularCostoLLamada correspondiente

    def calcular(self):
        raise NotImplementedError("Responsabilida de subclase")


class CalcularCostoLLamadaLocal(CalcularCostoLLamada):
    def calcular(self):
        pass # código de calcular_costo_local_de


class CalcularCostoLLamadaNacional(CalcularCostoLLamada):
    def calcular(self):
        pass # código de calcular_costo_nacional_de


class CalcularCostoLLamadaInternacional(CalcularCostoLLamada):
    def calcular(self):
        pass # código de calcular_costo_internacional_de

# 6to buscar obj polimorfico
# 5to reemplazo del if por envio de mensajes polimorficos
#calculadora_costo = CalcularCostoLLamada.to_handle(llamada)
#calculadora_costo.calcular()


#   ELIMINAR CODIGO REPETIDO
#
#   1) Copiar código repetido
#   2) Parametrizar lo que cambia
#   3) Poner nombre

def inicial_nombre_cliente(letra):
    "Selecion de clientes con nombres de inicial @letra"
    clientes_selec = []
    for cliente in clientes:
        if cliente.nombre.startswith(letra):
            clientes_selec.append(cliente)
    return clientes_selec


def sobrescribir_cuentas():
    "Selección de cuentas con giro descubierto"
    cuentas_selec = []
    for cuenta in cuentas:
        if cuenta.is_overdraw():
            cuentas_selec.append(cuenta)
    return cuentas_selec


# Una funcion que Reifica las anteriores sería
def selecionar(objetos, condicion):
    "Selecciona obejtos que cumplen una condición"
    selecion = []
    for objeto in objetos:
        if condicion(objeto):
            selecion.append(objeto)
    return selecion

# selecionar(clientes, lambda cliente: cliente.nombre.startswith(letra))
# selecionar(cuentas, lambda cuenta: cuenta.is_overdraw())