python中的继承有什么特点_Python-类的继承

类的继承

谈类的继承之前我们要知道：

面向对象的三大特性：封装、继承、多态

接下来我们就来学习类的继承。

一、什么是类的继承？

继承：顾名思义子承父业，合法继承家产，就是如果你是独生子，而且你也很孝顺，不出意外，你会继承你父母所有家产，他们的所有财产都会由你使用。

类的继承：专业角度来说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]