Herencia: super¶
Existen dos formas de heredar el constructor de la clase padre: usando super o no.
Lo aconsejable es usar super()
Ejemplo 1: Figura, Rectangulo¶
Usando super()¶
In [1]:
class Figura:
def __init__(self, nombre):
self.nombre = nombre
class Rectangulo(Figura):
def __init__(self, base, altura, nombre):
super().__init__(nombre)
self.base = base
self.altura = altura
def area(self):
return self.base * self.altura
In [2]:
rectangulo1 = Rectangulo(100, 300, "rectangulito")
rectangulo1.area()
Out[2]:
30000
Sin usar super()¶
In [3]:
class Figura:
def __init__(self, nombre):
self.nombre = nombre
class Rectangulo(Figura):
def __init__(self, base, altura, nombre):
Figura.__init__(self, nombre)
self.base = base
self.altura = altura
def area(self):
return self.base * self.altura
In [4]:
rectangulo1 = Rectangulo(100, 300, "rectangulito")
rectangulo1.area()
Out[4]:
30000
Ejemplo 2: Rectangulo, Cuadrado¶
Sin usar super()¶
Al usar @property evitamos tener que escribir los paréntesis en r.area()
In [5]:
class Rectangulo:
def __init__(self, base, altura):
self.base = base
self.altura = altura
self.nombre = 'rectángulo'
@property
def area(self):
return self.base * self.altura
r = Rectangulo(4,5)
print(r.nombre, r.area)
rectángulo 20
In [6]:
class Cuadrado(Rectangulo):
def __init__(self, lado):
Rectangulo.__init__(self, lado, lado)
self.nombre = 'cuadrado'
In [7]:
c = Cuadrado(4)
print(c.nombre, c.area)
cuadrado 16
Usando super()¶
In [8]:
class SuperCuadrado(Rectangulo):
def __init__(self, lado):
super().__init__(lado, lado)
self.nombre = 'cuadrado'
c2 = SuperCuadrado(5)
print(c2.nombre, c2.area)
cuadrado 25
Ejemplo 3: Person, Student¶
Sin usar super()¶
In [9]:
class Person(object):
def __init__(self,fname='', lname=''):
self.fname = fname
self.lname = lname
def __repr__(self): # permite representar un objeto para mostrarlo como mejor nos parezca
return f"Se trata de {self.fname} de la familia {self.lname}."
def __str__(self):
return f"Persona: {self.fname} {self.lname}."
class Student(Person):
def __init__(self, fname='', lname='', id=''):
Person.__init__(self, fname, lname)
self.id = id
def __repr__(self): # permite representar un objeto para mostrarlo como mejor nos parezca
return f"El id {self.id} corresponde al estudiente: {self.fname} {self.lname}."
def __str__(self):
return f"Estudiante: {self.fname} {self.lname} con id: {self.id}."
if __name__ == '__main__':
p = Person('Miguel', 'Ruiz')
print(p) # equivale a: print(str(p))
print(repr(p),"\n")
s= Student('Ana', 'Perez', 'A001')
print(s) # equivale a: print(str(s))
print(repr(s))
Persona: Miguel Ruiz. Se trata de Miguel de la familia Ruiz. Estudiante: Ana Perez con id: A001. El id A001 corresponde al estudiente: Ana Perez.
Usando super()¶
In [10]:
class Person(object):
def __init__(self,fname='', lname=''):
self.fname = fname
self.lname = lname
def __repr__(self): # permite representar un objeto para mostrarlo como mejor nos parezca
return f"Se trata de {self.fname} de la familia {self.lname}."
def __str__(self):
return f"Persona: {self.fname} {self.lname}."
class Student(Person):
def __init__(self, fname='', lname='', id=''):
super().__init__(fname, lname) # IMPORTANTE: no lleva self pero si lleva los demás argumentos
self.id = id
def __repr__(self): # permite representar un objeto para mostrarlo como mejor nos parezca
return f"El id {self.id} corresponde al estudiente: {self.fname} {self.lname}."
def __str__(self):
return f"Estudiante: {self.fname} {self.lname} con id: {self.id}."
if __name__ == '__main__':
p = Person('Miguel', 'Ruiz')
print(p) # equivale a: print(str(p))
print(repr(p),"\n")
s= Student('Ana', 'Perez', 'A001')
print(s) # equivale a: print(str(s))
print(repr(s))
Persona: Miguel Ruiz. Se trata de Miguel de la familia Ruiz. Estudiante: Ana Perez con id: A001. El id A001 corresponde al estudiente: Ana Perez.
Ejemplo 4 ¿Por qué se usa super()?¶
¿Hay alguna diferencia entre usar Base.__init__ y super().__init__?
In [11]:
class Base():
def __init__(self):
print("Base created")
class ChildA(Base):
def __init__(self):
Base.__init__(self)
class ChildB(Base):
def __init__(self):
super().__init__()
ChildA()
ChildB()
print()
Base created Base created
Sin super(), estaríamos limitados al usar toda la capacidad de la herencia múltiple porque estaríamos conectando rigidamente con la clase padre.
Consejo¶
Use siempre super para hacer referencia a la clase principal en lugar de codificarla.
Lo que pretende es hacer referencia a la clase principal que es la siguiente en la línea, no específicamente de la que ve que hereda el hijo.