2.1.4 Python继承

1，继承的基本概念

继承是非常重要的，因为继承让我们能够延续以前的东西，“继承”意味着一个人从另外一个人那里得到了一些什么。

高级编程语言中的“ 继承”，跟通常理解的继承会有所不同。“继承”在高级编程语言中是一个非常重要的概念。虽然不用继承一样能够编写程序，但是，当我们追求程序的更高阶层时，继承的作用就显现出来了。

继承（Inheritance）是面向对象软件技术当中的一个概念。如果一个类别A“继承”自另一个类别B，就把这个A称为“B的 子类别”，而把B称为“A的 父类别”，也可以称“B是A的 超类”。

继承可以使得子类别具有父类别的各种属性和方法，而不需要再次编写相同的代码。在令子类别继承父类别的同时，可以重新定义某些属性，并重写某些方法，即覆盖父类别的原有属性和方法，使其获得与父类别不同的功能。

继承的意图或者好处：

（1）可以实现 代码重用，但不是仅仅实现代码重用，有时候根本就没有重用。

（2）实现属性和方法继承。

从技术上说，OOP里继承最主要的用途是实现 多态。对于多态而言，重要的是接口继承性，属性和行为是否存在继承性，这是不一定的。

在Python里，因为存在Duck Type，接口定义的重要性大大降低，继承的作用也进一步被削弱了。

另外，从逻辑上说，继承的目的也不是为了复用代码，而是为了理顺关系。

#! /usr/bin/env python

# coding=utf-8

__metaclass__ = type

class Person:

def speak(self):

print "I love you."

def setHeight(self):

print "My height is：1.65m."

def breast(self,n):

print "My breast is：",n

class Girl(Person):

def setHeight(self):

print "The height is：1.80m."

if __name__ == "__main__":

c = Girl()

c.setHeight()

c.speak()

c.breast(80)

运行结果是：

>>>

The height is：1.80m.

I love you.

My breast is： 80

首先定义了一个类Person，在这个类中定义了三个方法。注意，没有定义初始化函数， 初始化函数在类中 不是必须的。

然后又定义了一个类girl，这个类的名字后面的括号中是上一个类的名字，这就意味着girl 继承了Person，girl是Person的 子类，Person是girl的 父类。

既然是 继承了Person，那么girl就拥有了Person中的 全部方法和属性。但是，如果girl里面有一个和Person同样名称的方法，那么就把Person中的同一个方法遮盖住了，显示的是girl中的方法，这叫作方法的 重写。

实例化类girl之后，执行实例方法c.setHeight()，由于在类girl中 重写了setHeight方法，那么Person中的那个方法就不显作用了，在这个实例方法中执行的是类girl中的setHeight方法。

虽然在类girl中没有看到speak方法，但是因为它继承了Person，所以c.speak()就执行类Person中的方法。同理c.breast（80），它们就好像是在类girl里面已经写了这两个方法一样。

2，多重继承

所谓 多重继承就是指某一个类所继承的父类，不止一个，而是多个。

#! /usr/bin/env python

# coding=utf-8

__metaclass__ = type

class Person:

def eye(self):

print "one eyes"

def breast(self,n):

print "My breast is：",n

class Girl:

age = 20

def color(self):

print "The girl is white"

class HotGirl(Person,Girl):

pass

if __name__ == "__main__":

k = HotGirl()

k.eye()

k.breast(80)

k.color()

print k.age

在这个程序中，前面有两个类：Person和girl，然后第三个类HotGirl 继承了这两个类，注意观察继承方法，就是在类的名字后面的括号中把所继承的两个类的名字写上。

然后实例化类HotGirl，既然继承了上面的两个类，那么那两个类的方法就都能够拿过来使用。

运行结果：

>>>

one eyes

My breast is： 80

The girl is white

20

在类girl中，有一个age=28，在对HotGirl实例化之后，因为继承的原因，这个类属性也被继承到HotGirl中，因此通过实例属性k.age一样能够得到该数据。

注意下 多重继承执行的顺序：

#! /usr/bin/env python

# coding=utf-8

__metaclass__ = type

class Person:

def eye(self):

print "one eyes"

def breast(self,n):

print "My breast is：",n

class Girl:

age = 20

def color(self):

print "The girl is white"

def eye(self):

print "two eye"

class HotGirl(Person,Girl):

pass

if __name__ == "__main__":

k = HotGirl()

k.eye()

k.breast(80)

k.color()

print k.age

运行结果：

>>>

one eyes

My breast is： 80

The girl is white

20

如果要执行eye()方法，首先看Person，有了就执行，即HotGirl==>Person==>Girl；breast(80)和color()也是按照这个顺序，找到了一个就不会往下找了。

这种对继承属性和方法搜索的顺序称之为“ 广度优先”。

在新式类中，以及python3.x的类中，都是按照“广度优先”原则搜寻属性和方法的。

3，super函数

初始化函数的继承跟一般方法的继承还有点不同，因为在子类中重写了某个方法之后，父类中同样的方法被遮盖了，那么如何再把父类的该方法调出来使用呢？

#! /usr/bin/env python

# coding=utf-8

__metaclass__ = type

class Person:

def __init__(self):

self.height = 150

def about(self,name):

print "{} is about {}".format(name,self.height)

class HotGirl(Person):

def __init__(self):

super(HotGirl,self).__init__() #重写之后调用父类初始化方法

self.breast = 90

def about(self,name):

print "{} is a hot girl,she is about {},and her break is {}".format(name,self.height,self.breast)

super(HotGirl,self).about("zhangsan") #重写之后调用父类方法

if __name__ == "__main__":

k = HotGirl()

k.about("kity")

在子类中，__init__方法重写了，为了调用父类同方法，使用 super（Girl，self）.__init__()的方式。super函数的参数，第一个是当前子类的类名字，第二个是self，然后是点号，点号后面是所要调用的父类的方法。同样在子类重写的about方法中，也可以调用父类的about方法。

执行结果：

>>>

kity is a hot girl,she is about 150,and her break is 90

zhangsan is about 150

最后要注意： super函数仅仅适用于新式类。

如果你用的是Python3.x，则使用super函数的形式稍微不同。自己查看下API