Polimorfismo en Python

En este tutorial, aprenderemos sobre el polimorfismo, el polimorfismo de diferentes tipos y cómo se pueden demostrar en Python con ejemplos.

¿Qué es el polimorfismo?

El significado literal del polimorfismo es la condición que se presenta en diferentes formas.

El polimorfismo es un concepto muy importante en la programación. Se refiere a usar una entidad de tipo único (método, operador o objeto) para representar diferentes escenarios en diferentes tipos.

Vamos a dar un ejemplo:

Example1：Polimorfismo del operador de adición

Sabemos + Los operadores se utilizan ampliamente en programas de Python. Pero no tienen un uso único.

Para el tipo de datos entero, se utiliza + operadores para realizar operaciones aritméticas.

num1　=　1
num2　=　2
print(num1+num2)

Por lo tanto, el programa anterior imprime 3

Del mismo modo, para el tipo de datos de cadena, se utiliza + operadores para la concatenación.

str1　= "Python"
str2　= "Programación"
print(str1+"　"+str2)

Como resultado, el programa anterior imprime : Programación Python

Aquí, podemos ver el uso del operador + Ejecuta diferentes operaciones para diferentes tipos de datos. Esto es uno de los fenómenos más simples de polimorfismo en Python.

Polimorfismo de las funciones en Python

En Python, hay algunas funciones que son compatibles con varios tipos de datos.

Una de estas funciones es la función len(). Puede ejecutarse con muchos tipos de datos en Python. Vamos a ver algunos ejemplos de uso de esta función.

Example2：Polimorfismo de la función len()

print(len("w3codebox"))
print(len(["Python", "Java", "C"]))
print(len({"Nombre": "John", "Dirección": "Nepal"}))

Output result

5
3
2

Aquí, podemos ver que muchos tipos de datos (por ejemplo, cadenas, listas, tuplas, conjuntos y diccionarios) pueden usar la función len(). Pero, podemos ver que devuelve información específica sobre tipos de datos específicos.

Polimorfismo de clase en Python

En la programación orientada a objetos, el polimorfismo es un concepto muy importante.

Para obtener más información sobre la POO en Python, visite:Programación orientada a objetos en Python

Al crear métodos de clase, podemos usar el concepto de polimorfismo, ya que Python permite que diferentes clases tengan métodos con el mismo nombre.

Luego, podemos generalizar la llamada a estos métodos más tarde, ignorando el objeto en uso. Veamos un ejemplo:

Example3Polimorfismo en métodos de clase

class Cat:
　　　　def __init__(self, name, age):
　　　　　　　　self.name = name
　　　　　　　　self.age = age
　　　　def info(self):
　　　　　　　　print(f"Soy un gato. Mi nombre es {self.name}. Soy {self.age} años.")
　　　　def make_sound(self):
　　　　　　　　print("Maullar")
class Dog:
　　　　def __init__(self, name, age):
　　　　　　　　self.name = name
　　　　　　　　self.age = age
　　　　def info(self):
　　　　　　　　print(f"Soy un perro. Mi nombre es {self.name}. Soy {self.age} años.")
　　　　def make_sound(self):
　　　　　　　　print("Ladrar")
cat1　= Cat("Kitty",　2.5)
dog1　= Dog("Fluffy",　4)
for animal in (cat1, dog1)
　　　　animal.make_sound()
　　　　animal.info()
　　　　animal.make_sound()

Output result

Maullar
Soy un gato. Mi nombre es Kitty. Soy　2.5　años.
Maullar
Ladrar
Soy un perro. Mi nombre es Fluffy. Soy　　4　años.
Ladrar

Aquí, creamos dos clases Cat y Dog. Tienen una estructura similar y comparten los mismos nombres de métodos info() y make_sound().

Pero, tenga en cuenta que aún no hemos creado una superclase común o hemos unido estas clases de alguna manera. Incluso así, podemos empacar estos dos objetos diferentes en una tupla y usar una variable común animal para iterar sobre ellos. Gracias a la polimorfia, esto es permitido.

Polimorfismo e herencia

Al igual que en otros lenguajes de programación, las subclases en Python heredan métodos y propiedades de la clase padre. Podemos redefinecir ciertos métodos y propiedades específicamente para la subclase, lo que se llamaMethod Overriding(Método sobreescrito).

La polimorfia nos permite acceder a estos métodos y propiedades cubiertos con el mismo nombre de la clase padre.

Veamos un ejemplo:

Example4Método sobreescrito

from math import pi
class Shape:
　　　　def __init__(self, name):
　　　　　　　　self.name = name
　　　　def area(self):
　　　　　　　　pass
　　　　def fact(self):
　　　　　　　　return "I am a two-dimensional shape."
　　　　def __str__(self):
　　　　　　　　return self.name
class Square(Shape):
　　　　def __init__(self, length):
　　　　　　　　super().__init__("Square")
　　　　　　　　self.length = length
　　　　def area(self):
　　　　　　　　return self.length**2
　　　　def fact(self):
　　　　　　　　return "Each corner of the square is"90 degrees."
class Circle(Shape):
　　　　def __init__(self, radius):
　　　　　　　　super().__init__("Circle")
　　　　　　　　self.radius = radius
　　　　def area(self):
　　　　　　　　return pi*self.radius**2
a = Square(4)
b = Circle(7)
print(b)
print(b.fact())
print(a.fact())
print(b.area())

Output result

Circle
I am a two-dimensional shape.
Each corner of the square is90 degrees.
153.93804002589985

Here, we can see that methods such as __str__ that have not been overridden in the subclass are used in the superclass.

Due to polymorphism, the Python interpreter automatically recognizes that the fact() method of object a (Square class) has been overridden. It uses the one defined in the subclass.

On the other hand, since the fact() method of object b has not been overridden, it can be used from the Parent Shape class.

Note:Method overloadingIt is a method that cannot be created with the same name but different parameters in Python.