Herencia y Polimorfismo en Python (Ejemplo Simple)

La herencia en Python nos permite a los programadores crear una clase general primero y luego más tarde crear clases más especializadas que re utilicen código de la clase general. La herencia también nos permite escribir un código más limpio y legible.

Herencia en Python

La herencia es utilizada (como su nombre lo indica) para heredar: campos de datos, métodos de acceso de otra clase, ademas de poder añadir nuestros propios métodos y campos. Por lo tanto la herencia nos proporciona una manera de organizar el código para no tener que volver a repetir código.

En la terminología orientada a objetos, cuando la clase "X" es heredada por la clase "Y", "X" es llamada Super Clase o Clase Base e "Y" es llamada Subclase o Clase Derivada. Un dato más a tener en cuenta es que solo los campos y métodos que no son privados son accesibles por la Clase Derivada. Los campos y métodos privados solo son accesibles por la propia clase.

Si eres nuevo en la Programación Orientada a Objetos, puedes pasarte por la entrada que escribí ya hace algún tiempo: Clases y Objetos en Python

Los ejemplos que dejo más abajo fueron realizados con Python 3. Si trabajas con Python 2.7 y te da pereza instalar la versión 3 para hacer pruebas y modificaciones a los ejemplos dados, puedes probar en línea en el siguiente link: https://repl.it/languages/python3

Pega los ejemplos y mete mano!!!


Ejemplo de herencia

class Vehiculo:
 
    def __init__(self, nombre, color):
        self.__nombre = nombre      # __name es privado
        self.__color = color
 
    def getColor(self):         # getColor() funcion accesible a la clase Auto
        return self.__color
 
    def setColor(self, color):  # setColor es accesible fuera de la clase
        self.__color = color
 
    def getNombre(self):          # getNombre() es accesible fuera de la clase
        return self.__nombre
 
class Auto(Vehiculo):
 
    def __init__(self, nombre, color, modelo):
        # Llamada al constructor para establecer nombre y color  
        super().__init__(nombre, color)       
        self.__modelo = modelo
 
    def getDescripcion(self):
        return self.getNombre() + self.__modelo + " de color " + self.getColor() 

# En el método getDescripcion podemos llamar a getNombre() y getColor porque
# son accesibles al pasar la herencia a la clase Derivada (Auto)

c = Auto("Ford Mustang", "rojo", "GT350")
print(c.getDescripcion())
print(c.getNombre()) # La clase auto no tiene un método getNombre() pero es accesible de la clase heredada Vehiculo

El resultado sería:


Ford MustangGT350 de color rojo
Ford Mustang

En el ejemplo anterior creamos la Clase Base Vehiculo y la Clase Derivada Auto. Tengamos en cuenta que no hemos definido el método getNombre() en la clase Auto, pero somos capaces de acceder a dicho método porque la clase Auto hereda de la clase Vehiculo. En el código anterior, el método super() se utiliza para llamar al método de la clase base.

Así es como trabaja el método super(): Supongamos que necesitamos llamar al método get_informacion() que está en la Clase Base desde la Clase Derivada, esto podemos hacerlo utilizando el siguiente código:

super().get_informacion()

De la misma manera podemos llamar el constructor de la Clase Base desde la Clase Derivada:

super().__init__()

Herencia Múltiple

A diferencia de lenguajes como Java y C#, Python permite la herencia múltiple, es decir, se puede heredar de múltiples clases.

Ejemplo sencillo de herencia múltiple

class MiSuperClase1():
 
    def metodo_1(self):
        print("metodo_1 metodo llamado")
 
class MiSuperClase2():
 
    def metodo_2(self):
        print("metodo_2 metodo llamado")

# Clase que hereda las 2 clases anteriormente definidas
class MiClase(MiSuperClase1, MiSuperClase2):
 
    def metodo_3(self):
        print("metodo_3 metodo llamado")

# Se crea el objeto "c" y luego se llama al metodo_1 y metodo_2 heredados de las 2 primeras clases
c = MiClase()
c.metodo_1()
c.metodo_2()

El resultado sería: 

metodo_1 metodo llamado
metodo_2 metodo llamado

Como se puede ver en código anterior, la clase MiClase hereda (MiSuperClase1 y MiSuperClase2), por lo tanto es capaz de acceder a los métodos (metodo_1 y metodo_2).

Métodos Overriding

Para sustituir un método proveniente de la Clase Base, en la Clase Derivada debemos definir un método con la misma firma (es decir, mismo nombre de método y mismo número de parámetros que como está definido en la Clase Base).

Ejemplo:

class A():
 
    def __init__(self):
        self.__x = 1
 
    def m1(self):
        print("m1 de A")
 
 
class B(A):
 
    def __init__(self):
        self.__y = 1
 
    def m1(self):
        print("m1 de B")
 
c = B()
c.m1()

El resultado sería:

m1 de B

Lo que se logra definiendo el método m1() en la Clase Derivada (B) se conoce como Método Overriding (cuando se cree el objeto (en este caso "c" y se llame al método m1(), este será tomado de la propia clase y no de la Clase Base). Si comentamos o borramos el método m1() de la clase B (Clase Derivada) y corremos nuevamente el código, el método llamado será el m1() de la Clase Base.

La función isinstance()

La función isinstrance() es usada para determinar si el objeto es una instancia de clase o no:

Sintaxis: isinstance(Object, class_type)

>>> isinstance(1, int)
True

>>> isinstance(1.2, int)
False

>>> isinstance([1,2,3,4], list)
True

Esto es todo amigos!!! Espero esta entrada sea de utilidad para esclarecer algunos conceptos cuando comenzamos a incursionar en la Programación Orientada a Objetos.

Cualquier consulta, duda o sugerencia estaré encantado de recibirla.

Saludos, Diego!!!

Fuente: http://thepythonguru.com/python-inheritance-and-polymorphism/