多态

指的是一类事物有多种形态

import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
    @abc.abstractmethod
    def talk(self):
        pass

class People(Animal): #动物的形态之一:人
    def talk(self):
        print('say hello')

class Dog(Animal): #动物的形态之二:狗
    def talk(self):
        print('say wangwang')

class Pig(Animal): #动物的形态之三:猪
    def talk(self):
        print('say aoao')

多态性

在面向对象方法中一般是这样表述多态性：
向不同的对象发送同一条消息（！！！obj.func():是调用了obj的方法func，又称为向obj发送了一条消息func），不同的对象在接收时会产生不同的行为（即方法）。
也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。

比如：老师.下课铃响了（），学生.下课铃响了()，老师执行的是下班操作，学生执行的是放学操作，虽然二者消息一样，但是执行的效果不同

又比如上次哪个支付系统。我统一了一个接口，我们调用的都是pay（）方法。但是我们是根据不同的对象实现不同的方法。

peo=People()
dog=Dog()
pig=Pig()

#peo、dog、pig都是动物,只要是动物肯定有talk方法
#于是我们可以不用考虑它们三者的具体是什么类型,而直接使用
peo.talk()
dog.talk()
pig.talk()

#更进一步,我们可以定义一个统一的接口来使用
def func(obj):
    obj.talk()

View Code

所以python是天生支持多态。

python崇尚鸭子类型。

鸭子类型：

　　1，list tupe

　Python崇尚鸭子类型，即‘如果看起来像、叫声像而且走起路来像鸭子，那么它就是鸭子’

python程序员通常根据这种行为来编写程序。例如，如果想编写现有对象的自定义版本，可以继承该对象

也可以创建一个外观和行为像，但与它无任何关系的全新对象，后者通常用于保存程序组件的松耦合度。

例1：利用标准库中定义的各种‘与文件类似’的对象，尽管这些对象的工作方式像文件，但他们没有继承内置文件对象的方法

例2：序列类型有多种形态：字符串，列表，元组，但他们直接没有直接的继承关系

#二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用
class TxtFile:
    def read(self):
        pass

    def write(self):
        pass

class DiskFile:
    def read(self):
        pass
    def write(self):
        pass

例子

python不崇尚根据继承所得来的相似，只要实现自己的代码就行了。如果两个类刚好相似，并不产生父类的子类的兄弟关系，而是鸭子类型。

优点：松耦合每个相似的类之间没有英雄。

缺点：太随意了，只能靠自觉。

列子：

class List:
    def __init__(self):
        pass
class Tuple:
    def __init__(self):
        pass
def len(l_t):
    return l_t.__len__()
L = List()
len(L)
#这两个类实现了相同的方法，不用去强制规定传入的数据类型。这就是鸭子类型

在其他强类型语言中，我们要实现多态就需要创建一个父类，做一个中转站。

class foo:
    pass
class List(foo):
    def __init__(self):
        pass
class Tuple(foo):
    def __init__(self):
        pass
def len(foo l_t):
    return l_t.__len__()
L = List()
len(L)

我们需要创建以一个摆设父类，我们在传如数据的时候，只要是foo的子类中的数据类型就可以接收，从而来实现多态。

原文地址：https://www.cnblogs.com/zly9527/p/11605244.html