继承
1. 继承介绍
1. 继承的概念
继承是一种新建类的方式 , 新建的类称之为子类 , 被继承的类称之为父类/基类/超类
python 支持多继承
2. 继承的目的
子类会遗传父类的属性 , 所有继承是用来解决类与类之间代码冗余的问题
3. 继承的实现
要找出类与类之间的继承关系 , 需要先抽象 , 再继承 . 抽象即总结相似之处 , 总结对象之间的相似之处得到类 , 总结类与类之间的相似之处就可以得到父类 , 基于抽象的结果 , 我们就找到了继承关系
class Parent1:
pass
class Parent2:
pass
class Sub1(Parent1):
pass
class Sub2(Parent1,Parent2):
pass
# 通过类的内置属性 __bases__ 可以查看类继承的所有父类
print(Sub1.__bases__)
print(Sub2.__bases__)
# 继承案例
class OldboyPeople:
school = "oldboy"
class Student(OldboyPeople):
def __init__(self,name,age,gender,stud_id,course):
self.name = name
self.age = age
self.gender = gender
self.stud_id = stud_id
self.course = course
def choose(self):
print("%s 正在选课" % self.name)
class Teacher(OldboyPeople):
def __init__(self,name,age,gender,salary,level):
self.name = name
self.age = age
self.gender = gender
self.salary = salary
self.level = level
def score(self,stu,num):
stu.num = num
stu1 = Student("艾利克斯",73,"male",1001,"python全栈开发")
tea1 = Teacher("egon",18,"male",2000,10)
print(stu1.school)
2. 在子类派生的新方法中重用父类的功能
1. 方式一: 指名道姓地调用某一个类的函数
特点: 不依赖于继承关系
class OldboyPeople:
school = "oldboy"
# 空对象,"艾利克斯",73,"male"
def __init__(self,name,age,gender):
self.name = name
self.age = age
self.gender = gender
def f1(self):
print("11111111")
class Student(OldboyPeople):
# 空对象,"艾利克斯",73,"male",1001,"python全栈开发"
def __init__(self,name,age,gender,stu_id,course):
# OldboyPeople.__init__(空对象,"艾利克斯",73,"male")
OldboyPeople.__init__(self,name,age,gender)
self.stu_id = stu_id
self.course = course
def choose(self):
print("%s 正在选课" %self.name)
def f1(self):
OldboyPeople.f1(self)
print("222222222")
class Teacher(OldboyPeople):
def __init__(self,name,age,gender,salary,level):
OldboyPeople.__init__(self,name,age,gender)
self.salary = salary
self.level = level
def score(self,stu,num):
stu.num = num
stu1 = Student("艾利克斯",73,"male",1001,"python全栈开发")
tea1 = Teacher("egon",18,"male",2000,10)
stu1.f1()
3. 属性查找
有了继承关系 , 对象在查找属性时 , 先从对象自己的__dict__中找 , 如果没有则去子类中找 , 然后再去父类中找
**1. 由对象发起的属性查找 **
会从对象自身的属性里检索 , 没有则会按照对象的类.mro()规定的顺序依次找下去
**2. 由类发起的属性查找 **
会按照当前类.mro()规定的顺序依次找下去
# 案例1
# obj.f1() 会在父类Foo中找到f1,先打印Foo.f1,然后执行self.f2(),即obj.f2()
# 按照: 对象本身 -> 类bar -> 父类Foo 的顺序依次找下去,在类Bar中找到f2,因而打印结果为Bar.f2
class Foo:
def f2(self):
print("Foo.f2")
def f1(self):
print("Foo.f1")
self.f2() # obj.f2()
class Bar(Foo):
def f2(self):
print("Bar.f2")
obj = Bar()
obj.f1()
# 案例2
# 父类如果不想让子类覆盖自己的方法,可以在方法名字前加前缀 __ , 将方法设置为私有的
class Foo:
def __f2(self): # _Foo__f2
print("Foo.f2")
def f1(self):
print("Foo.f1")
self.__f2() # obj._Foo__f2()
class Bar(Foo):
def __f2(self): # _Bar__f2
print("Bar.f2")
obj = Bar()
obj.f1()
4. 继承的实现原理
1. 菱形问题
一个子类继承的多条分支最终汇聚到一个非object类
2. 菱形继承下属性查找方式
在菱形继承下,新式类与经典类关于属性查找的方式不同
1.新式类: 广度优先
2.经典类: 深度优先
# 例1: 非菱形继承,经典类与新式类的属性查找顺序都一样
class E:
def test(self):
print("from E")
pass
class F:
def test(self):
print("from F")
class B(E):
def test(self):
print("from B")
pass
class C(F):
def test(self):
print("form C")
class D:
def test(self):
print("from D")
class A(B,C,D):
def test(self):
print("from A")
obj=A()
obj.test()
# 例2: 菱形继承
class G(object): # 在python2中,未继承object的类及其子类,都是经典类
def test(self):
print("from G")
pass
class E(G):
def test(self):
print("from E")
class F(G):
def test(self):
print("from F")
class B(E):
def test(self):
print("from B")
class C(F):
def test(self):
print("from C")
class D(G):
def test(self):
print("from D")
class A(B,C,D):
def test(self):
print("from A")
obj=A()
obj.test()
print(A.mro())
"""
[
<class '__main__.A'>, <class '__main__.B'>,
<class '__main__.E'>,<class '__main__.C'>,
<class '__main__.F'>, <class '__main__.D'>,
<class '__main__.G'>, <class 'object'>
]
"""
5. 补充知识
1. 新式类 : 但凡是继承了object类的子类 , 该子类子子孙孙类都称之为新式类
2. 经典类 : 没有继承object类的子类 , 该子类子子孙孙类都称之为经典类
3. python3 中全都是新式类 , python2 中才有经典类
4. 在python3 中没有继承任何类的类会默认继承object类
class Foo(object):
pass
print(Foo.__bases__) # <class 'object'>
5. MRO (method resolution order) 方法解析顺序
事实上 , 程序中定义的每个类 , python都会计算出一个方法解析顺序 , 代表类继承的顺序
6. MRO列表的顺序是通过C3线性化算法来实现的 , MRO列表就是合并所有父类的列表
7. MRO列表的特点
-
子类永远在父类的前面
-
如果有多个父类 , 会根据它们在列表中的顺序去检查
-
如果对下一个类存在两种不同的合法选择 , 那么选择第一个父类
6.python Mixins机制
1. 继承关系 : is-a
2. Mixins机制
Mixins机制指的是子类混合(mixin)不同类的功能 , 而这些类采用统一的命名规范(例如Mixin后缀) , 以此标识这些类知识用来混合功能的 , 并不是用来标识子类的从属"is-a"关系的 , 所有Mixins机制本质仍是多继承 , 但同样遵守"is-a"关系
Mixins机制的命名方式就是用来明确告诉别人,这个类是作功能添加到子类中 , 而不是作为父类
3. 使用Mixin类实现多重继承的注意点
1. 该类必须表示某一种功能 , 而不是某个物品 , python 对于mixin类的命名方式一般以 Mixin , able , ible 为后缀
2. 该类必须责任单一 , 如果有多个功能 , 那就写多个Mixin类 , 一个类可以继承多个Mixin , 为了保证遵循继承的"is-a"原则 , 只能继承一个标识其归属含义的父类
3. Mixin类不依赖于子类的实现
4. 子类即便没有继承Mixin类 , 也照样可以工作 , 就是缺少了某些功能
7. 单继承
如果一个类继承另外一个类 , 该类叫做子类(衍生类),被继承的类叫做父类(基类,超类)
继承: (1) 单继承 (2) 多继承
class Human(object):
hair = "黑色"
sex = "男"
def cry(self):
print("人类在伤心的时候,会留下鳄鱼的眼泪")
def eat(self):
print("人类在远古时候,抓到猎物直接吃")
def __makebaby(self):
print("人类在发育到成熟的时候,会造人")
# (1) 子父继承之后,子类可以调用父类的公有成员
class Man(Human):
pass
obj = Man()
print(obj.hair)
obj.cry()
# (2) 子父继承之后,子类不能调用父类的私欲成员
class Woman(Human):
def pub_func(self):
self.__makebaby()
obj = Woman()
# obj.__makebaby() error
# obj.pub_func() error
# (3) 子父继承之后,子类可以改写父类中的方法
"""
子父继承之后
如果子类里面有该成员属性或者方法,优先调用自己的
如果没有该成员,调用父类中的成员
如果都没有,直接报错
"""
class Children(Human):
sex = "女性"
def cry(self):
print("小孩只会哇哇哇的哭")
obj = Children()
obj.cry()
print(obj.__dict__)
print(Children.__dict__)
8. 多继承
# (1) 基本语法
class Father():
property = "风流倜傥,一表人才,一枝梨花压海棠"
def f_hobby(self):
print("社会摇,蹦迪,吃喝嫖赌,大保健")
class Mother():
property = "闭月羞花,倾国倾城,一枝红杏出墙来"
def m_hobby(self):
print("打麻将,打牌,喝酒抽烟烫头,跳广场舞")
class Daughter(Father,Mother):
pass
# 实例化对象
obj = Daughter()
print(obj.property)
obj.m_hobby()
# (2) super用法
"""
(1)super本身是一个类 super()是一个对象 用于调用父类的绑定方法
(2)super() 只应用在绑定方法中,默认自动传递self对象 (前提:super所在作用域存在self)
(3)super用途: 解决复杂的多继承调用顺序
"""
class Father():
property = "风流倜傥,一表人才,一枝梨花压海棠"
def f_hobby():
print("社会摇,蹦迪,吃喝嫖赌,大保健")
class Mother():
property = "闭月羞花,倾国倾城,一枝红杏出墙来"
def m_hobby(self):
print("打麻将,打牌,喝酒抽烟烫头,跳广场舞")
class Son(Father,Mother):
property = "喜欢打游戏,wow,lol,dnf,泡泡堂,cf,dota,大话西游,跑跑卡丁车,吃鸡"
# 1.利用类来调用父类的成员
def skill1(self):
Father.f_hobby()
print(Mother.property)
# 2.利用对象调用父类的成员
def skill2(self):
self.m_hobby()
print(self.property)
# 3.利用super调用父类的属性和方法
"""
super()只调用父类的相关公有成员,不会调用自己的本类成员,父类没有直接报错.
super()在调用父类方法时,只调用父类的绑定方法,默认传递参数是本类的对象self
"""
def skill3(self):
# print(super())
print(super().property)
super().m_hobby()
# super().f_hobby() error
obj = Son()
print("<===============>")
obj.skill1()
print("<===============>")
obj.skill2()
print("<===============>")
obj.skill3()
"""
self 和 super()的区别
self 在调用成员时,先看看自己的类对象中是否存在该成员,如果有调用自己的,如果没有,调用父类的.如果都没有报错
super() 在调用成员时,只调用父类的相关成员(属性,绑定方法),永远不会调用自己的.如果父类没有,直接报错.
"""
9. 菱形继承
"""
Human
Man Woman
Children
"""
class OldWoman():
pass
class Human():
pty = 4
def feelT(self):
print("原始人类如果热了,脱皮1")
print(self.pty)
print("原始人类如果冷了,扒别人的皮2")
class Man(Human):
# pty = 3
def feelT(self):
print("现代男人如果热了,脱衣服,脱裤子3")
super().feelT()
print("现代男人如果冷了,脱别人的衣服,脱别人的裤子4")
class Woman(Human):
# pty = 2
def feelT(self):
print("现代女人如果热了,吹空调,吃雪糕5")
super().feelT()
print("现代女人如果冷了,喝热水,用暖宝宝6")
class Children(Man,Woman):
# pty = 1
def feelT(self):
print("现代小孩如果热了,就哭,嗯哭7")
super().feelT()
print("现代小孩如果冷了,也要哭8")
obj = Children()
obj.feelT()
# 73512648
# mro 列表 : super用途的一个体现.解决复杂的多继承调用顺序关系
"""
类.mro() 返回的是方法调用顺序列表,针对于多继承下的同名方法,按照顺序依次的进行调用
"""
lst = Children.mro()
print(lst)
"""
[
<class '__main__.Children'>,
<class '__main__.Man'>,
<class '__main__.Woman'>,
<class '__main__.Human'>,
<class 'object'>
]
"""
# issubclass 判断子父关系 (应用在类当中,判断子父关系)
"""只要在一条继承链上即可(有血缘关系)"""
res = issubclass(Children,Man)
print(res)
res = issubclass(Children,Woman)
print(res)
res = issubclass(Children,Human)
print(res)
res = issubclass(Children,(Human,Woman,Man,OldWoman))
print(res)
res = issubclass(Children,OldWoman)
print(res)
# isinstance (应用在对象和类之间,判断类型)
"""只要在一条继承链上即可(有血缘关系)"""
res = isinstance(obj,Children)
print(res)
res = isinstance(obj,Human)
print(res)
res = isinstance(obj,(Human,Children,Woman))
print(res)
res = isinstance(obj,OldWoman)
print(res)
10. _init_ 魔术方法
_init_ 魔术方法 (构造方法)
触发时机: 实例化对象,初始化的时候触发
功能:为对象添加成员
参数:参数不固定,至少一个self参数
返回值:无
# (1) 基本语法
class MyClass():
def __init__(self):
print("初始化方法被触发")
# 为当前对象self 添加成员 name
self.name = "袁伟倬"
# 实例化对象
obj = MyClass()
print(obj.name)
# (2) 带有多个参数的构造方法
class MyClass():
def __init__(self,name):
# self.成员名 = 参数
self.name = name
# 实例化对象
obj = MyClass("宋云杰") # 在实例化对象时候,给构造方法传递参数
print(obj.name)
# (3) 类可以是一个,对象可以是多个
"""一个类可以实例化多个不同的对象,而对象和对象之间彼此独立,但都可以使用类中的公有的成员"""
class Children():
def __init__(self,name,skin):
self.name = name
self.skin = skin
def cry(self):
print("小孩一出生就哇哇哇的哭")
def drink(self):
print("小孩一下生就要喝奶奶")
def __la(self):
print("小孩拉粑粑是私有的")
def pub_info(self):
print("该对象的名字是{},该对象的肤色是{}".format(self.name,self.skin))
# 创建第一个小孩
afanda = Children("阿凡达","蓝色的")
afanda.pub_info()
afanda.cry()
# 创建第二个小孩
afanti = Children("阿凡提","黄色的")
afanti.pub_info()
afanti.drink()
# 创建第三个小孩
bao = Children("我滴宝强","绿色的")
bao.pub_info()
bao.__la() # 无法在类外调用私有的成员