Polimorfismo no Python

Neste tutorial, vamos aprender sobre polimorfismo, diferentes tipos de polimorfismo e como demonstrá-los com exemplos no Python.

O que é polimorfismo?

O significado literal do polimorfismo é a aparência em diferentes formas.

O polimorfismo é um conceito muito importante na programao. Ele se reflete no uso de uma íntica entidade de tipo (método, operador ou objeto) para representar diferentes cenários de diferentes tipos.

Vamos dar um exemplo:

Exemplo1Operador de adicião polimórfico

Nós sabemos + O operador já é amplamente utilizado em programas Python. No entanto, não tem um uso único.

Para o tipo de dados inteiro, usa-se + operadores para realizar operações aritméticas.

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

Portanto, o programa acima imprime 3

Da mesma forma, para o tipo de dados de string, usa-se + operadores para concatenar.

str1　= "Python"
str2　= "Programação"
print(str1+"\t"+str2)

Como resultado, o programa acima imprime : Programao Python

Aqui, podemos ver o uso do operador + Executam operações diferentes para diferentes tipos de dados. Isso é um dos polimorfismos mais simples no Python.

Polimorfismo de funções no Python

No Python, existem funções que são compatíveis com vários tipos de dados.

Um desses tipos de funções é o função len(). Ele pode ser executado com muitos tipos de dados no Python. Vamos ver alguns exemplos de uso dessa função.

Exemplo2Muitiplas funcionalidades do função len()

print(len("w3codebox"))
print(len(["Python", "Java", "C"]))
print(len({"Nome": "John", "Endereço": "Nepal"}))

Resultados de Saída

5
3
2

Aqui, podemos ver que muitos tipos de dados (por exemplo, strings, listas, tuplas, conjuntos e dicionários) podem usar a função len(). No entanto, podemos ver que ele retorna informações específicas sobre o tipo de dados específico.

Polimorfismo de classe no Python

No programação orientada a objetos, o polimorfismo é um conceito muito importante.

Para obter mais informações sobre a POO no Python, acesse:Programação Orientada a Objetos (POO) em Python

Ao criar métodos de classe, podemos usar o conceito de polimorfismo, pois o Python permite que classes diferentes tenham métodos com o mesmo nome.

Depois, podemos generalizar a chamada desses métodos mais tarde, ignorando o objeto em uso. Vamos ver um exemplo:

Exemplo3Método de polimorfismo em classe

class Cat:
　　　　def __init__(self, name, age):
　　　　　　　　self.name = name
　　　　　　　　self.age = age
　　　　def info(self):
　　　　　　　　print(f"Eu sou um gato. Meu nome é {self.name}. Eu tenho {self.age} anos.")
　　　　def make_sound(self):
　　　　　　　　print("Meow")
class Dog:
　　　　def __init__(self, name, age):
　　　　　　　　self.name = name
　　　　　　　　self.age = age
　　　　def info(self):
　　　　　　　　print(f"Eu sou um cachorro. Meu nome é {self.name}. Eu tenho {self.age} anos.")
　　　　def make_sound(self):
　　　　　　　　print("Bark")
cat1　= Cat("Kitty",　2.5)
dog1　= Dog("Fluffy",　4)
for animal in (cat1, dog1)
　　　　animal.make_sound()
　　　　animal.info()
　　　　animal.make_sound()

Resultados de Saída

Meow
Eu sou um gato. Meu nome é Kitty. Eu tenho　2.5　Anos.
Meow
Bark
Eu sou um cachorro. Meu nome é Fluffy. Eu tenho　　4　Anos.
Bark

Aqui, criamos duas classes, Cat e Dog. Elas têm uma estrutura semelhante e métodos com os mesmos nomes, info() e make_sound().

Mas, note que ainda não criamos uma superclasse comum ou ligamos essas classes de alguma forma. Mesmo assim, podemos empacotar esses dois objetos diferentes em um tupla e iterar sobre eles usando uma variável comum animal. Isso é permitido devido à polimorfia.

Polimorfismo e Herança

Como em outras linguagens de programação, as subclasses em Python também herdam métodos e atributos da classe pai. Podemos redefinir métodos e atributos específicos para a subclassa, o que chamamos deMethod Overriding(Método de sobrescrita).

A polimorfia nos permite acessar esses métodos e atributos cobertos com o mesmo nome da classe pai.

Vamos ver um exemplo:

Exemplo4Método de sobrescrita

from math import pi
class Shape:
　　　　def __init__(self, name):
　　　　　　　　self.name = name
　　　　def area(self):
　　　　　　　　pass
　　　　def fact(self):
　　　　　　　　return "Sou uma forma bidimensional."
　　　　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 "Cada canto do quadrado é"90 graus."
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())

Resultados de Saída

Circle
Sou uma forma bidimensional.
Cada canto do quadrado é90 graus.
153.93804002589985

Aqui, podemos ver que métodos como __str__ não foram sobrescritos na subclasse, que foram usados na classe pai.

Devido ao polimorfismo, o interpretador Python identifica automaticamente que o método fact() do objeto a (classe Square) foi sobrescrito. Ele usa aquele definido na subclasse.

Por outro lado, pois o método fact() do objeto b não foi sobrescrito, ele pode ser usado a partir da classe Parent Shape.

Atenção:Sobrecarga de MétodosÉ uma maneira de criar métodos que têm o mesmo nome mas diferentes parâmetros, que não pode ser feita no Python.