python多态和鸭子类型

多态与多态性

多态指的是一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承）。

　　比如：文件分为文本文件，可执行文件（在定义角度）

比如

我们按下 F1 键这个动作：

如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；
如果当前在 Word 下弹出的就是 Word 帮助；
在 Windows 下弹出的就是 Windows 帮助和支持。
同一个事件发生在不同的对象上会产生不同的结果。

　文件有多种形态：文本文件，可执行文件

import abc
# 抽象类
class File(metaclass=abc.ABCMeta):

    def __init__(self ,name):
        self.name = name

    @abc.abstractmethod
    def open(self):
        pass

# 继承File
class TxtFile(File):

    def open(self):
        print('open txtFile %s' % self.name)

# 继承File
class ExeFile(File):
    def open(self):
        print('open ExeFile %s' % self.name)

# （多态）
f1 = TxtFile('f1') #实例化对象TxtFile类 f1
f2 = ExeFile('f2') #实例化对象ExeFile类 f2
f1.open()
f2.open()

# ----------------输出结果-------------------
# open txtFile f1
# open ExeFile f2

什么是多态性（请务必注意：多态与多态性是两种概念。）

　　多态性：同一种调用方式，不同的执行效果（多态性）（在调用角度）

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

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

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

class Cat(Animal):# 动物的形态:猫
    def talk(self):
        print('say miao')

def func(animal):  # 定义一个函数，相当于一个接口，
    animal.talk()  # 传来不同的实例化对象，最后实现的结果也不一样
# 以下虽然对象不一样，但是调用的方法是一样的，这就是 多态性

为什么要用多态性（多态性的好处）

其实大家从上面多态性的例子可以看出，我们并没有增加什么新的知识，也就是说python本身就是支持多态性的，这么做的好处是什么呢？

1.增加了程序的灵活性

　　以不变应万变，不论对象千变万化，使用者都是同一种形式去调用，如func(File)

2.增加了程序额可扩展性

　通过继承File类创建了一个新的类，使用者无需更改自己的代码，还是用func(File)去调用 　

　　

鸭子类型

Python崇尚鸭子类型，即“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”

在鸭子类型中，关注的不是对象的类型本身，而是它是如何使用的。例如，在不使用鸭子类型的语言中，我们可以编写一个函数，它接受一个类型为鸭的对象，并调用它的走和叫方法。

在使用鸭子类型的语言中，这样的一个函数可以接受一个任意类型的对象，并调用它的走和叫方法。如果这些需要被调用的方法不存在，那么将引发一个运行时错误。

任何拥有这样的正确的走和叫方法的对象都可被函数接受的这种行为引出了以上表述，这种决定类型的方式因此得名。

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

import abc
# 抽象类
class File(metaclass=abc.ABCMeta):

    def __init__(self ,name):
        self.name = name

    @abc.abstractmethod
    def open(self):
        pass

# 继承File
class TxtFile(File):

    def open(self):
        print('open txtFile %s' % self.name)

    def read(self):
        print('read txtFile %s' % self.name)

    def write(self):
        print('write txtFile %s' % self.name)

# 继承File
class ExeFile(File):
    def open(self):
        print('open ExeFile %s' % self.name)

    def read(self):
        print('read ExeFile %s' % self.name)

    def write(self):
        print('write ExeFile %s' % self.name)

# 鸭子类型，没有继承File
class Disk:
    def read(self):
        print('disk read')

    def write(self):
        print('disk write')

def read(obj):
    obj.read()

def write(obj):
    obj.write()

read(Disk())
read(ExeFile('f1'))

write(Disk())
write(ExeFile('f2'))

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

#str,list,tuple都是序列类型
s=str('hello')
l=list([1,2,3])
t=tuple((4,5,6))

#我们可以在不考虑三者类型的前提下使用s,l,t
s.__len__()
l.__len__()
t.__len__()

len(s)
len(l)
len(t)