Python进阶(十五)----面向对象之~继承(单继承,多继承MRO算法)
Python进阶(十五)----面向对象之~继承
一丶面向对象的三大特性:封装,继承,多态
二丶什么是继承
# 什么是继承
# b 继承 a ,b是a的子类 派生类 , a是b的超类 基类 父类
# b类或者b对象 能够使用 a类的所有属性和方法
# 为什么要有继承
由子类继承父类，从而完成了对子类功能的扩展
#第一:
子类对父类的继承是全部的公有和受保护的继承，这使得子类可能继承了对子类无用甚至有害的父类的方法。换句话说，子类只希望继承父类的一部分方法，怎么办？
#第二:
实际的对象千变万化，如果每一类的对象都有他们自己的类，尽管这些类都继承了他们的父类，但有些时候还是会造成类的无限膨胀。
#第三:
继承的子类，实际上需要编译期确定下来，这满足不了需要在运行内才能确定对象的情况。而组合却可以比继承灵活得多，可以在运行期才决定某个对象。
#摘自: hivon博主
# 总结:
# 对类的功能的扩展，要多用组合，少用继承。
三丶继承的优缺点
#优点:
#1.节省代码, 2.增强耦合性 , 3. 代码规范化 , 4 .重构父类方法
#缺点:
# 继承关系会造成 高耦合性
转一篇关于 继承 优缺点的文章
四丶单继承
## 单继承
class Animal:
live = '活着'
def __init__(self, name, sex, age):
self.name = name
self.sex = sex
self.age = age
def eat(self):
print('in eat function')
class Person(Animal):
pass
### 1. 子类以及对象 可以调用父类的方法和属性
print(Person.live) # 子类名.父类中的属性 , 查看或获取父类中的变量
Person.eat('d') # 子类名.父类中的方法,调用父类的方法
print(Person.__dict__) # 查看 子类中 存在的属性
### 2. 从对象执行父类的一切.
# 实例化对象一定一定会执行三件事. 一定会执行__init__
p1 = Person('ly', '男', '21')
print(p1.live) # 对象调用 类中的属性
p1.eat() # 对象 调用类中的方法
print(p1.__dict__) # 查看 p1对象的属性
Person.live = 'xxx'
print(Person.live)
# 注意: 子类以及子类对象,只能调用父类的属性以及方法 , 不能操作增删改
## 单继承super的使用 ,
class Animal:
live = '活着'
def __init__(self, name, sex, age): # self 接收的 p1 对象内存空间,给p1封装属性
self.name = name
self.sex = sex
self.age = age
def eat(self):
print('in 父类 eat function')
class Person(Animal):
def __init__(self,name,age,sex,hobby): # 给p1 封装 hobby属性
# Animal.__init__(self,name,age,sex) # 执行父类的 __init__方法 , self 是当前p1 对 .
# super(Person, self).__init__(name,sex,age)
super().__init__(name,sex,age) #执行父类 __init__方法
self.hobby=hobby
def eat(self):
print('子类吃')
super().eat()
p1=Person('ly','33','人妖','服务')
p1.eat()
print(p1.__dict__) #打印p1对象中的属性, 父类定义的属性, 和子类自定义的属性 都存在
五丶多继承
python 2.2 之前: 都是经典类
class A: # 经典类 不继承object类
pass
python 2.2 直至 python2.7 之间存在两种类型:经典类,新式类
经典类:
基类不继承object ,查询规则:依靠深度优先(先深入继承树左侧查找，然后再返回，开始查找右侧)
新式类:
必须继承object , 查询规则: MRO算法
class A: # 经典类
pass
class B(object): #新式类
pass
python3x 只有新式类
class B(object): # 新式类 , (object) 默认可以不写 继承object类
pass
### 多继承案例
class ShenXian: # 神仙
def fei(self):
print("神仙都会⻜")
class Monkey: # 猴
def chitao(self):
print("猴⼦喜欢吃桃⼦")
class SunWukong(ShenXian, Monkey): # 孙悟空是神仙, 同时也是⼀只猴
pass
sxz = SunWukong() # 孙悟空
sxz.chitao() # 会吃桃⼦
sxz.fei() # 会⻜
多继承的难点就是继承顺序的问题
MRO算法:
#### 新式类 继承关系的运算
### mro算法
# 公式:
# mro(Child(Base1，Base2)) = [ Child ] + merge( mro(Base1), mro(Base2), [ Base1, Base2] )
# mro(Foo(H,G)) = [Foo] + merge(mro(H), mro(G),[H,G])
# 表头：
# 列表的第一个元素
# 表尾：
# 列表中表头以外的元素集合（可以为空）
# 表头,表尾
# [A,B,C] : 表头: A 表尾: [B,C]
# [A] : 表头: A 表尾: []
# +操作
# [A] + [B] = [A, B]
class O:
pass
class D(O):
pass
class E(O):
pass
class F(O):
pass
class B(D,E):
pass
class C(E,F):
pass
class A(B,C):
pass
a = A()
#### 方式一 套用公式
'''
mro(A(B,C))=[A] + merge(mro(B) , mro(C)), [B,C] # merge(mro(B) , mro(C)) 放到下面拆解了
=[A] + merge( [B,D,E,O] , [C,E,F,O] ) ,[B,C]
=[A,B] + merge([D,E,O],[C,E,F,O]),[C]
=[A,B,D] + merge([E,O],[C,E,F,O]),[C]
=[A,B,D,C,] + merge([E,O],[E,F,O])
=[A,B,D,C,E] + merge([O],[F,O])
=[A,B,D,C,E,F] + merge([O])
=[A,B,D,C,E,F,O]
mro(B(D,E))=[B] + merge(mro(D),mro(E)), [D,E] # C3算法, merge操作是C3算法的核心。
=[B] + merge([D]+[O],[O] ,[E]+[O],[O]),[D,E] # 公式拆解,
=[B] + merge([D,O],[E,O]),[D,E]
=[B,D] + merge([O],[E,O]),[E]
=[B,D,E] + merge([O])
=[B,D,E,O]
mro(C[E,F])=[C] + merge(mro(E),mro(F)),[E,F]
=[C] + merge([E]+megre([O]),[F]+megre([O])),[E,F]
=[C] + merge([E,O],[F,O]) ,[E,F]
=[C,E] + merge([O],[F,O]),[F]
=[C,E,F] + merge([O],[O])
=[C,E,F,O]
'''
#### 方式二 使用 mro()
print(A.mro()) # [<class '__main__.A'>, <class '__main__.B'>, <class '__main__.D'>, <class '__main__.C'>, <class '__main__.E'>, <class '__main__.F'>, <class '__main__.O'>, <class 'object'>]
