类的继承
谈类的继承之前我们要知道:
面向对象的三大特性:封装、继承、多态
接下来我们就来学习类的继承。
一、什么是类的继承?
继承:顾名思义子承父业,合法继承家产,就是如果你是独生子,而且你也很孝顺,不出意外,你会继承你父母所有家产,他们的所有财产都会由你使用。
类的继承:专业角度来说B继承A类 B叫做A的子类又称派生类,A叫做B的父类,又称基类或超类。B类以及B的对象使用A类的所有的属性以及方法。
那么我们来举一个最简单的例子。如果我们想要写三个类,通常我们的写法是这样的。class Person:
def __init__(self,name,sex,age):
self.name = name
self.age = age
self.sex = sex
class Cat:
def __init__(self,name,sex,age):
self.name = name
self.age = age
self.sex = sex
class Dog:
def __init__(self,name,sex,age):
self.name = name
self.age = age
self.sex = sex
通过上边的例子可以看出我们定义了三个类,且方法以及方法的属性都相同。那么我们用继承实现同样的效果。class Animal:
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
class Person(Animal): ##括号里为继承也是父类
pass
class Dog(Animal):
pass
class Cat(Animal):
pass
通过上边的继承我们可以看出继承的优点:
1、节省代码
2、增强了耦合性
3、使代码更加规范化
二、继承的分类
就向上面的例子:
Aminal 叫做父类,基类,超类。
Person Cat Dog: 子类,派生类。
继承:可以分单继承,多继承
三、单继承
1、子类以及对象可以调用父类的属性及方法。class Animal:
live="有生命的"
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def eat(self):
print("动物都需要进食")
class Person(Animal):##括号里为继承,父类
pass
## 1、从类名执行父类的属性
print(Person.live)
Person.eat(55)
运行结果:
有生命的
人类都需要进食
## 2、从对象执行父类一切
(1) 实例化对象时一定会执行三件事,一定会执行__init__
p1=Person("LiMing",20,"男")
print(p1.__dict__)
运行结果:
{'name': 'LiMing', 'age': 20, 'sex': '男'}
(2)对象执行类的父类的属性,方法。
p1=Person("LiMing",20,"男")
print(p1.live)
p1.eat()
运行结果:
有生命的
动物都需要进食
(3)对象空间重写继承父类的方法
p1.eat="LiMing"
print(p1.eat)
运行结果:
LiMing
#注:这里修改的是p1对象空间,不是父类的方法。
子类以及子类的对象只能调用父类的属性以及方法,不能操作(增删改)
2、对象执行顺序class Animal:
live="有生命的"
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def eat(self):
print("动物都需要进食")
class Person(Animal):##括号里为继承,父类
def eat(self):
print("人类都需要进食")
p1=Person("LiMing",20,"男")
p1.eat()
运行结果:
人类都需要进食
总结:对象查找顺序:从对象空间找名字,子类找名字,父类找名字
3、 如何既要执行父类方法又要执行子类方法
方法一:如果想执行父类的方法,这个方法与子类方法一起用,那么就在子类的方法中写上:
父类.__init__(对象,其他参数)
比如:class Animal:
live="有生命的"
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def eat(self):
print("动物都需要进食")
class Person(Animal):##括号里为继承,父类
def __init__(self,name,age,sex,hobby):
Animal.__init__(self,name,age,sex)
self.hobby=hobby
def eat(self):
print("人类都需要进食")
p1=Person("LiMing",20,"男","看书")
print(p1.__dict__)
运行结果:
{'name': 'LiMing', 'age': 20, 'sex': '男', 'hobby': '看书'}
方法二:利用super(子类类名,self(这里的参数可以不写)).__init__(参数)
比如:class Animal:
live="有生命的"
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def eat(self):
print("动物都需要进食")
class Person(Animal):##括号里为继承,父类
def __init__(self,name,age,sex,hobby):
super(Person,self).__init__(name,age,sex)
self.hobby=hobby
def eat(self):
print("人类都需要进食")
p1=Person("LiMing",20,"男","看书")
print(p1.__dict__)
运行结果:
{'name': 'LiMing', 'age': 20, 'sex': '男', 'hobby': '看书'}
举一反三,我们执行子类与父类的eat方法class Animal:
live="有生命的"
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def eat(self):
print("动物都需要进食")
class Person(Animal):##括号里为继承,父类
def __init__(self,hobby):
self.hobby=hobby
def eat(self):
print("人类都需要进食")
super().eat()
p1=Person("看书")
p1.eat()
运行结果:
人类都需要进食
动物都需要进食
接着我们做几道单继承练习题。
1、class Base:
def __init__(self, num):
self.num = num
def func1(self):
print(self.num)
class Foo(Base):
pass
obj = Foo(123) #实例化对象,创建对象空间obj,自动执行__init__方法,将123传给self
obj.func1() # 123 对象的调用,执行Base中的func1
运行结果
123
2、class Base:
def __init__(self, num):
self.num = num
def func1(self):
print(self.num)
class Foo(Base):
def func1(self):
print("Foo. func1", self.num)
obj = Foo(123)
obj.func1() #根据对象执行顺序,先找---->对象空间------>子类------>父类,所以对象调用func1, 子类与父类都有func1时先找子类
运行结果:
Foo. func1 123
3class Base:
def __init__(self, num):
self.num = num
def func1(self):
print(self.num)
self.func2() #self----->obj #对象查询空间,此时的func2应该是子类中的func2,符合执行顺序
def func2(self):
print("Base.func2")
class Foo(Base):
def func2(self):
print("Foo.func2")
obj = Foo(123)
obj.func1() # func1是Base中的 func2是⼦类中的
运行结果:
123
Foo.func2
4class Base:
def __init__(self, num):
self.num = num
def func1(self):
print(self.num)
self.func2()
def func2(self):
print(111, self.num)
class Foo(Base):
def func2(self):
print(222, self.num)
lst = [Base(1), Base(2), Foo(3)]
for obj in lst:
obj.func1() #调用父类时只执行父类,调用子类时先执行子类,在执行父类
运行结果:
1
111 1
2
111 2
3
222 3
通过上边的执行过程,结果你都答对了吗?
四、多继承
谈到多继承我们先来一个案例进行了解吧!class God:
def __init__(self,name):
self.name=name
def fly(self):
print("会飞")
def climb(self):
print("神仙累了也需要爬树")
class Monkey:
def __init__(self,sex):
self.sex=sex
def climb(self):
print("爬树")
class MonkeySun(God,Monkey):
pass
sun=MonkeySun()
sun.climb()
运行结果:
神仙累了也需要爬树
#上边MonkeySun类继承了God类以及Monkey类,MonkeySun自然就可以执行这两类中的方法,这就是简单的多继承。多继承⽤起来简单. 也很好理解. 但是多继承中, 存在着这样⼀个问题. 当两个⽗类中出现了重名⽅法的时候. 这时该怎么办呢? 这时就涉及到如何查找⽗类⽅法的这么⼀个问题.即MRO(method resolution order) 问题. 在python中这是⼀个很复杂的问题. 因为在不同的python版本中使⽤的是不同的算法来完成MRO的.
Python中类的种类
在python2x版本中存在两种类.:
⼀个叫经典类. 在python2.2之前. ⼀直使⽤的是经典类. 经典类在基类的根如果什么都不写.
⼀个叫新式类. 在python2.2之后出现了新式类. 新式类的特点是基类的根是object类。
python3x版本中只有一种类:
python3中使⽤的都是新式类. 如果基类谁都不继承. 那这个类会默认继承 object。
也就是在大体上Python的类分为两种:一种是基类的根不是object的经典类,一种是基类的根是object的新式类。
我们先说经典类的MRO算法。
首先我们举一个实例:class A:
pass
class B(A):
pass
class C(A):
pass
class D(B, C):
pass
class E:
pass
class F(D, E):
pass
class G(F, D):
pass
class H:
pass
class Foo(H, G):
pass
然后第一步我们先画出他的MRO图,来展示一下他各个类之间的关系:
经典类-MRO图
我们乍一看,这个图就像一棵树一样,而经典类的MRO算法恰巧也是根据树状结构推导的。
经典类的MRO算法就是用来遍历树状结构的深度优先遍历,他的原理如下。
首先我们会从左向右依次查找节点,如果后面查找的节点在前面已经查找过,则忽略不计。
树状图
现在我们有一个树状结构如上,那么他的遍历顺序就是:
遍历顺序
现在让我们回到我们实例的MRO图,然后按照深度优先遍历规则,他的顺序应该是如下:实例类的MRO:Foo-> H -> G -> F -> E -> D -> B -> A -> C
到这里,就有了一个问题,假如类A与类C中都有一个方法sum(),但是类C是继承类A的,也就是说类C重写了类A的方法。按照继承层级,如果我们的FOO类使用sum()这个方法,应该使用的类C中重写的sum()方法,而不是使用类A中原生的sum()方法。
这也就是Python2.2之前的一个诟病,Python3彻底改变了这种MRO算法,使用了一种新的方法。
接着我们说新式类的MRO算法。
Python3使用的这种新的方法叫做MRO序列。
这个序列在类被创建之时就计算出来了,他是创建类时的伴生物。他的通用公式如下:mro(Child(Base1,Base2)) = [ Child ] +merge( mro(Base1), mro(Base2), [ Base1, Base2] )
(其中Child继承自Base1, Base2)
只看通用公式太过枯燥,让我们举个实例看看:假设有类C,他继承类A和类B。即 class C(A,B)
此时类C的序列是:
mro( C ) = mro( C(A,B) )
= [C] + merge( mro(A) + mro[B] + [A,B] )
= [C] + merge( [A] + [B] + [A,B] )
= [C,A,B]
诶,这里就有一个问题了,为什么是[C,A,B],而不是[C,B,A]呢,这就要说MRO序列的一个特性--表头提取。
首先我们先了解两个概念,表头,表尾。
我们拿我们的MRO序列[C,A,B]来举例,C就是表头,A,B就是表尾。
接着来说表头提取。
我们在进行到[C] + merge( [A] + [B] + [A,B] )这一步时,加号右边的计算规则是:
[A] + [B] + [A,B]
我们把这三个序列标位①,②,③。
1.首先查看①的表头A,然后去其他两个序列中,查看A是否在表尾中,如果在表尾中,则跳过①,去②中重复操作。
2.但是①的表头A不在其他序列的表尾中,所以提出A,同时删除其他序列中的A。
3.这是式子就变成了[B],提取出来的序列是[A].
4.接着重复第一步操作,直至式子清空。这个式子的结果就是序列[A,B]
然后我们的式子就变成了[C] + [A,B],序列之间的加法就是连接操作,他们相加的结果就是:[C,A,B].
最后我们来举一个实例:class A:
pass
class B(A):
pass
class C(A):
pass
class D(B, C):
pass
class E:
pass
class F(D, E):
pass
class G(F, D):
pass
class H:
pass
class Foo(H, G):
pass
实例代码如上,MRO图不再赘述。
根据上面的MRO序列算法得:mro( FOO ) = mro( FOO(H,G) )
= [FOO] + merge( mro(H) + mro[G] + [H,G] )
= [FOO] + merge( [H] + MRO[G] + [H,G] )
= [FOO] + merge( [H] + [G,F,D,B,C,A,E] + [H,G] )
= [FOO,H] + merge([G,F,D,B,C,A,E] + [G] )
= [FOO,H,G] + merge([F,D,B,C,A,E])
= [FOO,H,G,F,D,B,C,A,E]
此时,因为类G也是一个多重继承类,所以要提出来单独计算。
mro( G ) = mro( G(F,D) )
= [G] + merge( mro(F) + mro[D] + [F,D] )
= [G] + merge( [F,D,B,C,A,E] + [D,B,C,A] + [F,D] )
= [G,F] + merge( [D,B,C,A,E] + [D,B,C,A] + [D] )
= [G,F,D] + merge( [B,C,A,E] + [B,C,A] )
= [G,F,D,B,C,A,E]
同理,类F和类D也要进行单独计算。
mro( F ) = mro( F(D,E) )
= [F] + merge( mro(D) + mro[E] + [D,E] )
= [F] + merge( [D,B,C,A] + [E] + [D,E] )
= [F,D] + merge( [B,C,A] + [E] + [E] )
= [F,D,B,C,A,E]
mro( D ) = mro( D(B,C) )
= [D] + merge( mro(B) + mro[C] + [B,C] )
= [D] + merge( [B,A] + [C,A] + [B,C] )
= [D,B] + merge( [A] + [C,A] + [C] )
= [D,B,C] + merge( [A] + [A] )
= [D,B,C,A]
最后,他的MRO顺序为:[FOO,H,G,F,D,B,C,A,E]