（十）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))