（十）python之多态

一、面向对象三大特征

面向对象编程的三大特征：封装，集成，多态

• 封装：客官的事物封装成类（将数据和方法放在一个类中就构成了封装）
• 继承：在python中一个类可以集成于另一个类也可以继承多个类，被继承的类叫父类（或者叫基类，base class），继承的类叫子类
• 多态（polymorphism）：指的是一类事物有多种形态，一个抽象类有多个子类（因而多态的概念依赖于继承），不同的子类对象调用相同的方法，产生不同的执行结果，多态可以增加代码的灵活度

二、多继承（拓展）

（1）Demo类同时继承A类和B类，然后Demo类实例化一个对象d，这个对象d可以调用A类和B类里面的属性和方法。

class A:
    a_attr1 = 100

    def func_a(self):
        print('------func_a--------')


class B:
    b_attr1 = 999

    def func_b(self):
        print('------func_b--------')


class Demo(A, B):
    pass


d = Demo()
# 调用父类A的属性和方法
print(d.a_attr1)
d.func_a()

# 调用父类B的属性和方法
print(d.b_attr1)
d.func_b()


# 打印结果
100
------func_a--------
999
------func_b--------

（2） 如果继承了2个类，调用两个父类中同名的方法和属性会怎么取值呢？

答：就近原则，他先找括号里面左边这个类，左边这个类找到了就不会再去找右边这个类，左边的类如果找不到就去右边这个类找。

注意：如果demo这个类自己有这个方法，就不会再去父类里面找，如果demo这个类没有，才会去父类里面去找。

class A:
    a_attr1 = 100
    attr = 10

    def func_a(self):
        print('----funca——————')

    def work(self):
        print('----funca——work————')


class B:
    b_attr1 = 999
    attr = 99999

    def func_b(self):
        print('----funcb——————')

    def work(self):
        print('----funcb——work————')


class Demo(A, B):
    pass


d = Demo()

# 调用两个父类中同名的方法和属性
print(d.attr)



# 打印结果
10

（3）只读属性（property） 

方法名上面加了@property之后，不再是方法名，而是属性名称

class B:
    b_attr1 = 999
    attr = 99999

    def func_b(self):
        print('----funcb——————')

    def work(self):
        print('----funcb——work————')


class Demo(A, B):
    def work(self):
        print('demo---work')

    @property  # 定义只读属性
    def battr(self):
        return B.attr


d = Demo()

# 只读属性
print(d.battr)


# 打印结果
99999

（4）多继承的应用思想

"""
定义一个api测试的用例类
    1、用例数据处理
    2、接口请求
    3、响应数据提取
    3、断言




"""


class HandleData:
    pass


class RequestApi:
    pass


class BaseTest(HandleData, RequestApi):
    pass

三、多态

实现多态的步骤：

• 1、定义一个父类（Base），实现某个方法（比如：run）
• 2、定义多个子类，在子类中重写父类的方法（run），每个子类run方法实现不同的功能
• 3、假设我们定义了一个函数，需要一个Base类型的对象的参数，那么调用函数的时候，传入Base类不同的子类对象，那么这个函数就会执行不同的功能，这就是多态的体现。

还是不懂多态是啥意思吗？没关系，我们上一段代码就明白了。

一个父类，他具有多个子类，不同的子类在调用相同的方法，执行的时候产生不同的形态，这个叫多态。

class Animal(object):
    """动物类"""

    def func(self):
        print('动物发出了声音')


class Cat(Animal):
    """猫类"""

    def func(self):
        print('喵 喵 喵')


class Dog(Animal):
    """狗类"""

    def func(self):
        print('汪 汪 汪 ')


class Hero:
    def func(self):
        print('这个是英雄类的方法，不是动物类的对象')


def work01(musen: Animal):
    musen.func()


work01(Hero())

多态的意义：

• 对于一个变量，我们只需要知道他是Animal类型，无需确切地知道它的子类型，就可以放心地调用run()方法（调用方只管调用，不管细节）
• 当需要新增功能，只需要新增一个Animal的子类实现run()方法，就可以在原来的基础上进行功能扩展，这就是著名的“开放封闭”原则：​​​​​​​

“开放封闭”原则：

• 对扩展开放：允许新增Animal子类
• 对修改封闭：不需要修改依赖Animal类型的run()等函数

注意点：Python中函数的参数是没有类型限制的，所以多态在python中的体现并不是很严谨。多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。

class Animal(object):
    """动物类"""

    def func(self):
        print('动物发出了声音')


class Cat(Animal):
    """猫类"""

    def func(self):
        print('喵 喵 喵')


class Dog(Animal):
    """狗类"""

    def func(self):
        print('汪 汪 汪 ')


class Hero:
    def func(self):
        print('这个是英雄类的方法，不是动物类的对象')


def work01(musen: Animal):
    musen.func()


work01(Hero())

四、鸭子类型

• 鸭子类型概念：他并不要求严格的继承体系，关注的不是对象的类型本身，而是它是否具有要调用的方法（行为）
• 鸭子类型在python中的案例：
  ​​​​​​​
  内置函数iter：参数可以是实现迭代协议（__iter__方法）的任何类型的对象。
  ​​​​​​​

"""
"""
鸭子类型概念：它并不要求严格的继承体系，关注的不是对象的类型，而是它是否具有要调用的方法（行为）。
鸭子类型在python中的案例：
    内置函数iter：参数可以是实现迭代协议（`__iter__`方法）的任何类型的对象

"""

li = [11, 22, 33, 44]
s = '1212124'


class MyTest:
    def __iter__(self):
        return (i for i in range(10))

    def __len__(self):
        return 10


li1 = iter(li)  # 内置函数iter将可迭代对象转换为迭代器，，本质上是调用对象的__iter__
s1 = iter(s)  # 内置函数iter将可迭代对象转换为迭代器，，本质上是调用对象的__iter__
m = MyTest()
m1 = iter(m)

# 内置函数len获取数据的长度，本质上是调用对象的__len__
print(len(m))