Formas de implementar polimorfismo en Python

En programación, el polimorfismo es un concepto de programación orientada a objetos. Permite usar una sola interfaz con la entrada de diferentes tipos de datos, diferentes clases o tal vez para un número diferente de entradas.

Ejemplo: En este caso, la función len() es polimórfica ya que toma una string como entrada en el primer caso y toma una lista como entrada en el segundo caso.

# length of string
x = len('Geeks')
print(x)
 
# length of list
y = len([1, 2, 3, 4])
print(y)

Producción:

5
4

En Python, el polimorfismo es una forma de hacer que una función acepte objetos de diferentes clases si se comportan de manera similar.

Hay cuatro formas de implementar polimorfismo en Python:

1. Duck Typing : Duck Typing es un concepto que dice que el «tipo» del objeto es un asunto de preocupación solo en tiempo de ejecución y no necesita mencionar explícitamente el tipo del objeto antes de realizar cualquier tipo de operación en ese objeto, a diferencia de la escritura normal donde la idoneidad de un objeto está determinada por su tipo.

En Python, tenemos el concepto de tipado dinámico, es decir, podemos mencionar el tipo de variable/objeto más adelante. La idea es que no necesita un tipo para invocar un método existente en un objeto si un método está definido en él, puede invocarlo.

class Geeks1:
  def code (self, ide):
    ide.execute()
     
class Geeks2:
  def execute (self):
    print("GeeksForGeeks is the best Platform for learning")
     
# create object of Geeks2   
ide = Geeks2()
 
# create object of class Geeks1
G1 = Geeks1()
 
# calling the function by giving ide as the argument.
G1.code(ide)

Producción:

GeeksForGeeks is the best Platform for learning

2. Sobrecarga de métodos: de forma predeterminada, Python no admite la sobrecarga de métodos, pero podemos lograrlo modificando los métodos.

Dada una sola función sum(), el número de parámetros puede ser especificado por usted. Este proceso de llamar al mismo método de diferentes maneras se llama sobrecarga de métodos .

class GFG:
    def sum(self, a = None, b = None, c = None):        
        s = 0
        if a != None and b != None and c != None:
            s = a + b + c
        elif a != None and b != None:
            s = a + b
        else:
            s = a
        return s
       
s = GFG()
 
# sum of 1 integer
print(s.sum(1))
 
# sum of 2 integers
print(s.sum(3, 5))
 
# sum of 3 integers
print(s.sum(1, 2, 3))

Producción:

1
8
6

3. Sobrecarga de operadores : la sobrecarga de operadores en Python es la capacidad de un solo operador para realizar más de una operación según la clase (tipo) de operandos. Entonces, básicamente, definir métodos para operadores se conoce como sobrecarga de operadores. Por ejemplo: para usar el operador + con objetos personalizados, debe definir un método llamado __add__.

 Sabemos que el operador + se usa para sumar números y al mismo tiempo para concatenar strings. Es posible porque el operador + está sobrecargado tanto por la clase int como por la clase str . Los operadores son en realidad métodos definidos en sus respectivas clases. 

Entonces, si desea usar el operador + para agregar dos objetos de alguna clase definida por el usuario, tendrá que definir ese comportamiento usted mismo e informar a Python al respecto.

class Student:
    def __init__(self, m1, m2):
        self.m1 = m1
        self.m2 = m2
 
S1 = Student (58, 60)
S2 = Student (60, 58)
 
# this will generate an error
S3 = S1 + S2

Producción:

TypeError: unsupported operand type(s) for +: 'Student' and 'Student'

Entonces podemos ver que el operador + no es compatible con una clase definida por el usuario. Pero podemos hacer lo mismo sobrecargando el operador + para nuestra clase.

class Student:
   
    # defining init method for class
    def __init__(self, m1, m2):
        self.m1 = m1
        self.m2 = m2
 
    # overloading the + operator
    def __add__(self, other):
        m1 = self.m1 + other.m1
        m2 = self.m2 + other.m2
        s3 = Student(m1, m2)
        return s3
 
s1 = Student(58, 59)
s2 = Student(60, 65)
s3 = s1 + s2
print(s3.m1)

Producción:

118

4. Sobreescritura de métodos: al usar la sobreescritura de métodos, una clase puede «copiar» otra clase, evitando el código duplicado y, al mismo tiempo, mejorar o personalizar una parte de ella. La anulación de métodos es, por lo tanto, parte del mecanismo de herencia.

En Python, la anulación de métodos se produce simplemente definiendo la clase secundaria en un método con el mismo nombre que un método en la clase principal.

# parent class
class Programming:
   
    # properties
    DataStructures = True
    Algorithms = True
     
    # function practice
    def practice(self):
        print("Practice makes a man perfect")
     
    # function consistency
    def consistency(self):
        print("Hard work along with consistency can defeat Talent")
         
# child class       
class Python(Programming):
     
    # function
    def consistency(self):
        print("Hard work along with consistency can defeat Talent.")
 
Py = Python()
Py.consistency()
Py.practice()

Producción:

Hard work along with consistency can defeat Talent.
Practice makes a man perfect