python之旅：面向对象之多态多态性

Posted 2020-10-31 墨颜丶

一 多态

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

eg：动物有多种形态：猫，狗，猪

 

class Animal:  #动物类
    def eat(self):  #吃
        pass
    def drink(self):  #喝
        pass
    def sleep(self): #睡
        pass

class Cat(Animal):
    def jiao(self):
        print(‘喵喵喵‘)
class Dog(Animal):
    def call(self):
        print(‘汪汪汪‘)
class Pig(Animal):
    def han(self):
        print(‘哼哼哼‘)

c=Cat()
d=Dog()
p=Pig()
# 多态性：可以在不用考虑对象具体类型的前提下而直接使用对象下的方法
c.drink()
d.drink()
p.drink()

c.sleep()
d.sleep()
p.sleep()

c.jiao()
d.call()
p.han()

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

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

 

 

二 多态性

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

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

 

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

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

详细解释

 

 

 

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

　　静态多态性：如任何类型都可以用运算符+进行运算

　　动态多态性：如下

c=Cat()
d=Dog()
p=Pig()
#c,d,p都是动物，只要是动物肯定有talk方法
#于是我们可以不用考虑它们三者的具体是什么类型,而直接使用
c.drink()
d.drink()
p.drink()
#更进一步,我们可以定义一个统一的接口来使用
def func(obj):
    obj.talk()

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

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

1.增加了程序的灵活性

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

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

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

在公司研发一套程序，基本是几个程序员合作完成的，所以需要创建一套强制要求去遵循的规则

用基类创建一套统一的规则，强制子类去遵循（使用抽象类实现），这样便可以在不用考略对象具体类型的前提下二直接使用对象下的方法

如何用多态

import abc  #导入abc模块来实现强制约束子类
#子类必须有父类的方法，否则实例话 TypeError: Can‘t instantiate abstract class People with abstract methods eat

class Animal(metaclass=abc.ABCMeta):  #动物类
    @abc.abstractmethod
    def eat(self):  #吃
        pass
    @abc.abstractmethod
    def drink(self):  #喝
        pass
    @abc.abstractmethod
    def sleep(self): #睡
        pass

class Cat(Animal):
    def eat(self):  #吃
        pass
    def drink(self):  #喝
        pass
    def sleep(self): #睡
        print(‘猫睡觉‘)
class People(Animal): #新添加  属于动物的另外一种形态：猫
    def eat(self):  
        pass
    def drink(self): 
        pass
    def sleep(self): 
        print(‘人睡觉‘)
        

def func(animal):  #对于使用者来说，自己的代码根本无须改动
    animal.sleep()

cat1=Cat()
peo1=People()  #实例话出一个人
func(peo1)　　#调用人的sleep功能
func(cat1)

 

 

三  鸭子类型

逗比时刻：

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

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

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

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

 

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

    def write(self):
        pass

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

例2：其实大家一直在享受着多态性带来的好处，比如Python的序列类型有多种形态：字符串，列表，元组，多态性体现如下

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