一、面向对象三大特征
面向对象编程的三大特征:封装,集成,多态
- 封装:客官的事物封装成类(将数据和方法放在一个类中就构成了封装)
- 继承:在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))