[Python知识库]Python学习基础笔记五十七——多态和鸭子类型

1、多态的概念：多态指的是一类事物有多种类型。Python天生支持多态，天生实现了多态。

例1：

class Payment:
    pass


class Alipay(Payment):
    def pay(self, money):
        print('已经用支付宝付了%s 元' % money)


class WeChat(Payment):
    def pay(self, money):
        print('已经用微信付了%s 元' % money)


class ApplePay(Payment):
    def pay(self, money):
        print('已经用苹果Pay付了%s 元' % money)


def pay(pay_obj, money):   # 统一支付入口  归一化设计
    pay_obj.pay(money)


app = ApplePay()
pay(app, 100)

不同的对象都从pay函数出作为参数传进来，然后根据不同的对象做不同的事情。

例2：

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')

例3：

import abc
class File(metaclass=abc.ABCMeta): #同一类事物:文件
    @abc.abstractmethod
    def click(self):
        pass

class Text(File): #文件的形态之一:文本文件
    def click(self):
        print('open file')

class ExeFile(File): #文件的形态之二:可执行文件
    def click(self):
        print('execute file')

2、多态性：

1）什么是多态动态绑定（在继承的背景下使用时，有时也称为多态性）

多态性是指在不考虑实例类型的情况下使用实例。

在面向对象方法中一般是这样表述多态性。

向不同的对象发送同一条消息，obj.func(): 是调用了obj的func，又称为向obj发送了一条消息func，不同的对象在接收时产生了不同的行为即方法。

也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。

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

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

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

Python是动态强类型的语言。

Python崇尚鸭子类型：

不崇尚根据继承所得带的相似。我们只是自己实现我们自己的代码就可以了。

如果两个类刚好相似，并不产生父类的子类的兄弟关系，而是鸭子类型。如果是鸭子类型，就是这两个类型非常相近。

全凭自觉，不是硬性规范。

index和tuple，这种相似，是自己写代码额时候约束的，而不是通过父类约束的。

优点：松耦合。每个相似的类都没有影响。

缺点：代码重复。太随意了，没有一个硬性的规范来约束，只能靠自觉。

接口类和抽象类在Python当中应用点并不是非常必要。

我们不崇尚用继承，Python崇尚鸭子类型。