Python OOPs/OOP：Python 中的多态性与示例_python中多态

概述

多态性是面向对象编程的一个基本概念，是一个函数执行多个功能的能力。它可以以不同的方式实现，包括运算符重载、内置函数、类和继承。在运算符重载中，同一个运算符以不同的方式使用，例如加法和字符串连接。

介绍

在英语中，同一个词可以根据我们的意图在不同的句子中使用。

例如——手表这个词。它可以以以下两种方式使用-

• “我今天买了一块新手表。”
• “我今晚真的很想看这部电影。”

显然，“手表”这个词首先被用作名词，然后用作动词。因此，这个词在两种情况下是相同的，但我们使用它的方式不同。就像我们提出的所有其他概念都有现实生活中的灵感一样，我们今天要讨论的概念也是如此——Python 中的多态性！

什么是 Python 中的多态性？

多态性的字面意思是 - 具有不同的形式。在编程中，多态性是指具有相同名称但以不同方式和不同场景使用的函数。这使得编程更容易、更直观。

多态性是面向对象编程的基本基石之一。它是一个功能同时显示多个功能的能力。它基本上创建了一个可以使用多种形式的对象的结构。

Python 中的多态性涉及一个子类，该子类从父类继承所有方法。这可以通过不同的方式实现，我们将在本文中详细介绍。

Python 示例中的多态性

让我们尝试通过这个简单的例子更好地理解多态性及其实现——

print(10+256)
print("Scaler"+"Academy")

上面的代码片段是最简单的示例。在这里，“+”运算符正在重载。

你一定想知道“超载”是什么意思。让我来阐明一下 -
运算符重载是使用运算符超出其预定义目的的概念。

因此，在我们的示例中，“+”运算符在第一行执行加法，而第二行是字符串连接的示例。

输出将清楚地表明差异

在这里，您可以看到如何以两种不同的方式使用相同的运算符。因此，算子重载可以说是 Python 中多态性的一种实现。

266
ScalerAcademy

运行时多态性的最好例子是方法

Python 中多态性的功能

在 Python 中，有几个函数通过与多种数据类型兼容来描述多态性。最好的例子是内置的 len（） 函数。

让我们看看一个小代码片段，看看它的实际效果——

print(len("Scaler Academy"))
print(len(["Python", "PHP", "C++"]))
print(len({"Name": "Rahul", "Address": "Kolkata,India"}))

输出-

14
3
2

从上面的代码片段中，我们可以清楚地了解 len（） 函数适用于所有三种数据类型——字符串、列表和字典。

Python 中的类多态性

Python 中的多态性也可以通过类来实现。Python 允许类具有相同名称的不同方法。

举个例子会让这个概念更清楚——

class Cat:
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
    def info(self):
        print(f"I am a cat. My name is {self.name}. I am {self.age} years old.")
 
    def make_sound(self):
        print("Meow")
 
 
class Cow:
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
    def info(self):
        print(f"I am a Cow. My name is {self.name}. I am {self.age} years old.")
 
    def make_sound(self):
        print("Moo")
cat1 = Cat("Kitty", 2.5)
cow1 = Cow("Fluffy", 4)
 
for animal in (cat1, cow1):
    animal.make_sound()
    animal.info()
    animal.make_sound()
'
运行
运行

现在在这个例子中，我们创建了两个类 “Cat” 和 “Cow”。它们是不同的动物，发出不同的声音。因此，make_sound（） 函数应该根据我们通过它们的对象生成两个不同的输出。在本例中，我们创建了两个对象“cat1”和“cow1”。

现在让我们看看我们将得到的最终输出 -

Meow
I am a cat. My name is Kitty. I am 2.5 years old.
Meow
Moo
I am a Cow. My name is Fluffy. I am 4 years old.
Moo

如前所述，make-sound（） 函数确实产生了两个不同的输出——“Meow”和“Moo”。

Python 中的多态性与继承

Python 中的多态性允许我们定义子类以具有与父类相同的名称方法。另一方面，继承 在 Python 中，子类继承了父类的所有方法。

现在，我们可能需要修改或重新定义其中的一些。专门对子类进行这些更改以确保它们无缝工作的过程称为方法重写。

让我们看一下在 Python 中通过继承实现多态性的代码片段 -

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 Circle(Shape):
    def __init__(self, radius):
        super().__init__("Circle")
        self.radius = radius
    def area(self):
        return pi*self.radius**2
shape_circle = Circle(7)
print(shape_circle)
print(shape_circle.area())
print(shape_circle.fact())
'
运行
运行

注意 - 您可能已经注意到，其中一个函数中使用了“pass”。Python 中的 pass 语句在语法上需要但不希望执行任何代码时使用。它基本上充当占位符，即使没有编写代码也可以防止错误。

输出-

我相信您可以从输出中看出类“Circle”没有 fact（） 方法，但即便如此，关于它的事实也被打印到控制台上。我知道你在想什么！

这一切正在发生，这一切都要归功于继承！由于父类 “Shape” 有一个 fact（） 方法，并且父类被子类 “Circle” 继承，因此 fact（） 函数被调用并显示。

类方法的多态性

Python 可以以相同的方式使用两种不同的类类型类时间。这可以通过一个简单的例子来证明，在这个例子中，我们创建了两个不同的类，并将它们放在一个元组中。

如果我们现在迭代这个对象元组，for 循环将为元组中的第一个对象执行所有给定的方法，然后是元组中的第二个对象，依此类推。

因此，通过这种方式，我们可以说 Python 将在不知道或不关心对象的类类型的情况下调用或使用这些方法。这只不过是 Python 中带有类方法的多态性示例。

为了使这个概念更加清晰，请查看以下示例 -

class Cat:
    def mood(self): 
       print("Grumpy") 
    def sound(self): 
       print("Meow") 
 
class Dog:
    def mood(self): 
       print("Happy") 
    def sound(self): 
       print("Woof") 
 
hello_kitty = Cat()
hello_puppy = Dog()
 
for pet in (hello_kitty, hello_puppy):
    pet.mood()
    pet.sound()

输出- 

函数 mood（） 和 sound（） 对于这两个类是相同的，但它们会产生不同的输出。此外，我们遍历了两个类“Cat”和“Dog”的对象，而不必担心类类型。因此，现在您知道如何使用类方法在 Python 中实现多态性。

函数和对象的多态性

Python 中具有函数和对象的多态性是一个非常有趣的用例。通过定义一个方法并通过它传递任何对象，我们可以在 Python 中使用函数和对象实现多态性。

请看这个简单的实现 -

class Beans(): 
     def type(self): 
       print("Vegetable") 
     def color(self):
       print("Green") 
class Mango(): 
     def type(self): 
       print("Fruit") 
     def color(self): 
       print("Yellow")      
def func(obj): 
       obj.type() 
       obj.color()
#creating objects
obj_beans = Beans() 
obj_mango = Mango() 
func(obj_beans) 
func(obj_mango)

在此代码片段中，我们创建了两个特定的类 - Beans 和 Mango。除此之外，我们还创建了一个泛型函数，它告诉我们传递的对象的类型和颜色。请注意，由于我们只通过“obj”传递了它，因此此 obj 可以是任何对象。接下来，我们创建上述两个类的两个对象。

现在让我们看看我们得到的输出是什么 -

从输出中可以清楚地看出，我们能够非常轻松地将两个对象传递给函数，并且还收到了准确的输出。因此，通过这种方式，我们可以利用类和对象的多态性。

结论

恭喜，你已经到了这篇文章的结尾！

总结一下我们目前所学到的东西，现在你可以自信地说——

• 您了解了多态性的含义。
• 特别是，您现在知道了 Python 中的多态性是什么以及实现它的不同方法。
• 您也清楚地知道哪种情况需要哪种多态性技术用于您未来的编码会话！