En Python, cuando una subclase define una función que ya existe en su superclase para agregar alguna otra funcionalidad a su manera, se dice que la función en la subclase es un método extendido y el mecanismo se conoce como extender. Es una forma en la que Python muestra polimorfismo . Esto es similar a anular en Java y métodos virtuales en C++. Una llamada desde la instancia de la subclase ejecuta la versión de la función de la subclase. Para llamar a la superclase super()se utiliza el método version.
¿Por qué extender una función?
El objetivo de extender un método de clase en Python se puede lograr mediante Herencia . Una de las principales ventajas que ofrece la extensión de un método es que hace que el código sea reutilizable. Además, varias subclases pueden compartir el mismo código e incluso se les permite actualizarlo según el requisito.
Trataremos ambos casos aquí.
CASO 1: sin extender un método de clase
# definition of superclass "Triangles"
class Triangles(object):
count = 0
# Calling Constructor
def __init__(self, name, s1, s2, s3):
self.name = name
self.s1 = s1
self.s2 = s2
self.s3 = s3
Triangles.count+= 1
def setName(self, name):
self.name = name
def setdim(self, s1, s2, s3):
self.s1 = s1
self.s2 = s2
self.s3 = s3
def getcount(self):
return Triangles.count
def __str__(self):
return 'Name: '+self.name+'\nDimensions: '+str(self.s1)+','+str(self.s2)+','+str(self.s3)
# describing a subclass
# inherits from Triangles
class Peri(Triangles):
# function to calculate the area
def calculate(self):
self.pm = 0
self.pm = self.s1 + self.s2 + self.s3
# function to display just the area
# because it is not extended
def display(self):
return self.pm
def main():
# instance of the subclass
p = Peri('PQR', 2, 3, 4)
# call to calculate()
p.calculate()
# explicit call to __str__()
print(p.__str__())
# call to display()
print(p.display())
main()
Producción:
Name: PQR Dimensions: 2, 3, 4 9
CASO 2: extender un método de clase
# definition of superclass "Triangles"
class Triangles(object):
count = 0
def __init__(self, name, s1, s2, s3):
self.name = name
self.s1 = s1
self.s2 = s2
self.s3 = s3
Triangles.count+= 1
def setName(self, name):
self.name = name
def setdim(self, s1, s2, s3):
self.s1 = s1
self.s2 = s2
self.s3 = s3
def getcount(self):
return Triangles.count
# superclass's version of display()
def display(self):
return 'Name: '+self.name+'\nDimensions: '+str(self.s1)+', '+str(self.s2)+', '+str(self.s3)
# definition of the subclass
# inherits from "Triangles"
class Peri(Triangles):
def calculate(self):
self.pm = 0
self.pm = self.s1 + self.s2 + self.s3
# extended method
def display(self):
# calls display() of superclass
print (super(Peri, self).display())
# adding its own properties
return self.pm
def main():
# instance of the subclass
p = Peri('PQR', 2, 3, 4)
# call to calculate
p.calculate()
# one call is enough
print(p.display())
main()
Producción:
Name: PQR Dimensions: 2, 3, 4 9
El resultado producido en ambos casos es el mismo, la única diferencia es que el segundo caso facilita que otras subclases hereden los métodos y los «extiendan» según sea necesario, lo que, como se mencionó, aumenta la reutilización del código.
Publicación traducida automáticamente
Artículo escrito por vanshikagoyal43 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA