Polimorfismo

8.1 Polimorfismo

El polimorfismo es uno de los conceptos principales de la programación orientada a objetos (OOP), que permite a objetos de diferentes clases utilizar la misma interfaz.

En Python, el polimorfismo se logra a través de la tipificación dinámica y la herencia. Un aspecto importante del polimorfismo es la sobrecarga de métodos y la sustitución de métodos de la clase base por métodos de la clase heredera.

Conceptos básicos del polimorfismo:

Interfaz única para diferentes objetos:

El polimorfismo permite utilizar una única interfaz para objetos de diferentes clases, que pueden tener diversas implementaciones de métodos.

Tipificación dinámica:

En Python, el tipo de variable se determina durante la ejecución, lo que permite que la función trabaje con objetos de cualquier clase, si estos soportan la interfaz requerida.

Herencia:

Permite crear jerarquías de clases donde las subclases heredan propiedades y métodos de la clase base, pero pueden redefinirlos para su funcionalidad específica.

Ejemplos de polimorfismo:

Un ejemplo simple de polimorfismo: las tres clases tienen un método llamado move(). Esto significa que podemos escribir código que funcione simultáneamente con estos objetos.

class Car:
    def move(self):
        pass
        
class Human:
    def move(self):
        pass
        
class Bird:
    def move(self):
        print("¡Pío!")
        
car = Car()
human = Human()
bird = Bird()
        
for it in [car, human, bird]:
    it.move()

En este caso, la "interfaz común" es el nombre del método, o su firma, si el método tiene parámetros.

8.2 Sobrescritura de métodos

El polimorfismo se utiliza a menudo junto con la herencia para crear jerarquías de clases donde la clase base define una interfaz común, y las subclases implementan detalles específicos.

class Employee:
    def get_salary(self):
        return 1000
        
class FullTimeEmployee(Employee):
    def get_salary(self):
        return 5000
        
class PartTimeEmployee(Employee):
    def get_salary(self):
        return 3000
        
class Intern(Employee):
    pass
        
def print_salary(employee):
    print(employee.get_salary())
        
employees = [FullTimeEmployee(), PartTimeEmployee(), Intern()]
        
for employee in employees:
    print_salary(employee)

Este ejemplo es similar al anterior, pero tiene una diferencia importante: nuestras clases no están obligadas a tener el método get_salary, ya que siempre está presente en la clase base. Ahora, la "interfaz común" de todas las clases no es simplemente el método get_salary(), sino precisamente la clase Employee con todos sus métodos y atributos.

8.3 Llamada a métodos de la clase heredera

Mira atentamente el siguiente código:

Llamamos al método print_salary(), que solo existe en la clase base Employee, y éste a su vez desde la clase base llama a otro método de la clase base — get_salary(). Entonces, ¿qué sueldos se mostrarán en la pantalla?

class Employee:
    def print_salary(self):
        salary = self.get_salary()
        print(salary)
        
    def get_salary(self):
        return 1000
        
class FullTimeEmployee(Employee):
    def get_salary(self):
        return 5000
        
class PartTimeEmployee(Employee):
    def get_salary(self):
        return 3000
        
class Intern(Employee):
    pass
        
employees = [FullTimeEmployee(), PartTimeEmployee(), Intern()]
        
for employee in employees:
    employee.print_salary()

¡Importante! Lee lo que está escrito abajo — es importante.

Si llamamos al método print_salary(), por ejemplo, de la clase FullTimeEmployee, se llamará al método de la clase base, ya que no se ha declarado dicho método en la clase misma.

Pero este método print_salary() llamará al método get_salary() en el objeto self, que tiene el tipo FullTimeEmployee, y no Employee. Por lo tanto, se llamará precisamente al método get_salary() de la clase FullTimeEmployee!

Además, la clase FullTimeEmployee puede llamar al método get_salary() de la clase base para sus propias necesidades. Por ejemplo, si queremos calcular el salario en porcentaje de la tarifa base:

class FullTimeEmployee(Employee):
    def get_salary(self):
        base_salary = super().get_salary()
        return base_salary * 5  
      
  
      
  
      
  

    # 500% 
  
        
class PartTimeEmployee(Employee):
    def get_salary(self):
        base_salary = super().get_salary()
        return base_salary * 3  # 300%        

8.4 Sobrecarga de métodos

La sobrecarga de métodos (method overloading) en Python es la capacidad de crear varios métodos con el mismo nombre, pero diferentes parámetros. Sin embargo, la sobrecarga de métodos no se soporta en Python de manera pura, como se hace en otros lenguajes (por ejemplo, C++ o Java).

En Python se puede imitar la sobrecarga de métodos mediante el uso de argumentos predeterminados, *args y **kwargs.

Ejemplos de sobrecarga de métodos

Podemos implementar una función que tenga un comportamiento diferente según la cantidad de argumentos pasados. Esto se puede hacer de varias maneras, por ejemplo, así:

class Example:
    def display(self, a=None, b=None):
        if a is not None and b is not None: print(a, b)
        elif a is not None: print(a)
        else: print("Sin argumentos")
        

obj = Example()
obj.display(1, 2)  # Salida: 1 2
obj.display(1)  # Salida: 1
obj.display()  # Salida: Sin argumentos

También se puede considerar el tipo de datos pasados — simplemente haciendo una verificación de tipo:

class Example:
    def mod(self, a, b):
        if type(a) == int and type(b) == int: print(a % b)
        elif type(a) == float or type(b) == float: print(round(a / b))
        else: print("Instrucción de ayuda: a y b deben ser int o float")
        

obj = Example()
obj.mod(5, 2)  # Salida: 1
obj.mod(5.0, 2)  # Salida: 2
obj.mod("5", 2)  # Salida: Instrucción de ayuda: a y b deben ser int o float

Si se pasan tipos de datos incorrectos, se puede mostrar una instrucción o incluso un enlace a la documentación en Internet — esta también es una solución muy popular.