【一】多态#

【1】什么是多态#

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

【2】示例#

比如动物有多种形态：猫、狗、猪

1
import abc
2

3

4
# 同一类事物:动物
5
class Animal(metaclass=abc.ABCMeta):
6
    @abc.abstractmethod
7
    def talk(self):
8
        pass
9

10

11
# 动物的形态之一:人
12
class People(Animal):
13
    def talk(self):
14
        print('你真帅')
15

16

17
# 动物的形态之二:狗
18
class Dog(Animal):
19
    def talk(self):
20
        print('汪汪汪')
21

22

23
# 动物的形态之三:猪
24
class Pig(Animal):
25
    def talk(self):
26
        print('哼唧哼唧')

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

1
import abc
2

3

4
# 同一类事物:文件
5
class File(metaclass=abc.ABCMeta):
6
    @abc.abstractmethod
7
    def click(self):
8
        pass
9

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

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

【二】多态性#

【1】什么是多态动态绑定(多态性)#

多态动态绑定在继承的背景下使用时，有时也称为多态性
多态性是指在不考虑实例类型的情况下使用实例
在面向对象方法中一般是这样表述多态性：
- 向不同的对象发送同一条消息（！！！obj.func()<是调用了obj的方法func>，又称为向obj发送了一条消息func）
- 不同的对象在接收时会产生不同的行为（即方法）。
- 也就是说，每个对象可以用自己的方式去响应共同的消息。
- 所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。
比如：老师.下课铃响了（），学生.下课铃响了()
- 老师执行的是下班操作
- 学生执行的是放学操作
- 虽然二者消息一样，但是执行的效果不同

【2】多态性的分类#

多态性分为静态多态性和动态多态性

（1）静态多态性#

如任何类型都可以用运算符 + 进行运算

（2）动态多态性#

1
import abc
2

3

4
# 同一类事物:动物
5
class Animal(metaclass=abc.ABCMeta):
6
    @abc.abstractmethod
7
    def talk(self):
8
        pass
9

10

11
# 动物的形态之一:人
12
class People(Animal):
13
    def talk(self):
14
        print('你真帅')
15

16

17
# 动物的形态之二:狗
18
class Dog(Animal):
19
    def talk(self):
20
        print('汪汪汪')
21

22

23
# 动物的形态之三:猪
24
class Pig(Animal):
25
    def talk(self):
26
        print('哼唧哼唧')
27

28

29
peo = People()
30
dog = Dog()
31
pig = Pig()
32

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

39

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

Python中一切皆对象，本身就支持多态性

1
# 我们可以在不考虑三者类型的情况下直接使用统计三个对象的长度
2
s.__len__()
3
l.__len__()
4
t.__len__()
5

6
# Python内置了一个统一的接口
7
len(s)
8
len(l)
9
len(t)

【3】为什么要用多态性（多态性的好处）#

增加了程序的灵活性
- 以不变应万变，不论对象千变万化，使用者都是同一种形式去调用，如func(animal)
增加了程序额可扩展性
- 通过继承animal类创建了一个新的类，使用者无需更改自己的代码，还是用func(animal)去调用

1
import abc
2

3

4
# 同一类事物:动物
5
class Animal(metaclass=abc.ABCMeta):
6
    @abc.abstractmethod
7
    def talk(self):
8
        pass
9

10

11
# 属于动物的另外一种形态：猫
12
class Cat(Animal):
13
    def talk(self):
14
        print('喵喵喵')
15

16

17
# 对于使用者来说，自己的代码根本无需改动
18
def func(animal):
19
    animal.talk()
20

21

22
# 实例出一只猫
23
cat1 = Cat()
24
# 甚至连调用方式也无需改变，就能调用猫的talk功能
25
func(cat1)

这样我们新增了一个形态Cat，由Cat类产生的实例cat1，使用者可以在完全不需要修改自己代码的情况下。
使用和人、狗、猪一样的方式调用cat1的talk方法，即func(cat1)

【三】鸭子类型 duck-typing#

【1】什么是鸭子类型 duck-typing#

鸭子类型是一种编程风格，决定一个对象是否有正确的接口
- 关注点在于它的方法或属性
- 而不是它的类型(如果它看起来像鸭子，像鸭子一样嘎嘎叫，那么它一定是鸭子。)。
通过强调接口而不是特定类型，设计良好的代码通过多态提高了灵活性。
- 鸭子类型无需使用 type() 或 isinstance() 进行检查(注意，鸭子类型可以用抽象基类来补充)
- 相反，它通常使用 hasattr() 来检查，或是 EAFP 编程。
但其实我们完全可以不依赖于继承，只需要制造出外观和行为相同对象，同样可以实现不考虑对象类型而使用对象，这正是Python崇尚的“鸭子类型”（duck typing）：
- “如果看起来像、叫声像而且走起路来像鸭子，那么它就是鸭子”。
- 比起继承的方式，鸭子类型在某种程度上实现了程序的松耦合度

【2】鸭子类型#

1
# 二者都像鸭子，因而就可以当鸭子一样去用
2
class NormalDuck():
3
    def eat(self):
4
        print(f"正常鸭子可以吃饭")
5

6
    def walk(self):
7
        print(f"正常鸭子可以走路")
8

9

10
class RockDuck():
11
    def eat(self):
12
        print(f"肉鸭子可以吃饭")
13

14
    def walk(self):
15
        print(f"肉鸭子可以走路")

音乐

音乐

【一】多态#

【1】什么是多态#

【2】示例#

【二】多态性#

【1】什么是多态动态绑定(多态性)#

【2】多态性的分类#

（1）静态多态性#

（2）动态多态性#

【3】为什么要用多态性（多态性的好处）#

【三】鸭子类型 duck-typing#

【1】什么是鸭子类型 duck-typing#

【2】鸭子类型#

支持与分享

音乐

Python面向对象之多态和鸭子类型

【一】多态#

【1】什么是多态#

【2】示例#

【二】多态性#

【1】什么是多态动态绑定(多态性)#

【2】多态性的分类#

（1）静态多态性#

（2）动态多态性#

【3】为什么要用多态性（多态性的好处）#

【三】鸭子类型 duck-typing#

【1】什么是鸭子类型 duck-typing#

【2】鸭子类型#

支持与分享