何为继承

• 在现实生活中，继承，意味着一个人从另外一个人那里得到了某些东西，比如优秀的品质或者万贯的家财。
• 在编程中，继承相对来说是有明确规定和预期结果的。类别A继承制类别B，那么A称之为子类，B称之为父类或者超类。
  继承使得子类拥有父类的非私有方法和属性，子类中可以不用写重复的代码。而子类继承父类的同时，可以重新定义某些属性，并重写某些方法，即覆盖父类原有的属性很方法，使其获得与父类不同的功能。子类可以有属于自己的属性和方法。

继承的意图和好处

• 可以实现代码重用，但不仅仅只是重用，有时根本就没有重用。
• 实现属性、方法的继承

从技术上说，OOP 里，继承最主要的用途是实现多态。对于多态而言，重要的是接口继承性，属性和行为是否存在继承性，这是不一定的。事实上，大量工程实践表明，重度的行为继承会导致系统过度复杂和臃肿，反而会降低灵活性。因此现在比较提倡的是基于接口的轻度继承理念。这种模型里因为父类（接口类）完全没有代码，因此根本谈不上什么代码复用了。

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

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

例子：

代码：

>>> class Person:
...     def setName(self,n):
...         print "my name is:",n
...     def sayHello(self):
...         print "hello word"
...     def setAge(self,n):
...         print "my age is:",n
... 
>>> class Boy(Person):
...     def setName(self):
...         print "the name is : wxx"
...     def setHeight(self):
...         print "the height is 175"
...

>>> boy = Boy()
>>> boy.setName()
the name is : wxx

>>> boy.sayHello()
hello word

>>> boy.setAge(23)
my age is: 23

>>> boy.setHeight()
the height is 175

说明：

• 定义一个Person类，类中定义了三个方法，而且没有初始化函数，初始化函数在类中并不是不可或缺的。
• 又定义了一个Boy类，继承自Person类。因此，Boy是Person的子类，Person是Boy的父类。
• 在Boy中，拥有了父类Person的三个方法，因此实例化之后可以调用父类的方法。setName(self) 则是方法的重写。setName()则是子类自己的方法。

多重继承

即父类不止一个。

>>> class AA(object):
...     def ADef(self):
...         print "AA ADef"
... 
>>> class BB(object):
...     def BDef(self):
...         print "BB BDef"
... 
>>> class CC(AA,BB):
...     pass
... 
>>> cc = CC()  #实例化CC类
>>> cc.ADef()
AA ADef
>>> cc.BDef()
BB BDef
>>> 

多重继承的顺序

如果一个子类继承自两个父类，而两个父类中拥有相同的方法或属性，子类会调用谁的？
举个例子：

>>> class K1(object):
...     def foo(self):
...         print "K1-foo"
... 
>>> class K2(object):
...     def foo(self):
...         print "K2-foo"
...     def mod(self):
...         print "K2-mod"
... 

>>> class J1(K1,K2):
...     pass
... 
>>> class J2(K1,K2):
...     def mod(self):
...         print "J2-mod"
... 
>>> class C(J1,J2):
...     pass
... 

>>> c = C()
>>> c.foo()
K1-foo
>>> c.mod()
J2-mod

从以上例子可以看出，实例化C()后，调用foo()，查找foo()的书顺序是：C -> J1 -> J2 ->K1;
而调用mod(),查找mod()的顺序是：C -> J1 -> J2。
以上这种继承的属性和方法的查找方式称之为“广度优先”。

super

例子

#!/usr/bin/env python
# coding=utf-8

__metaclass__ = type

class Person:
    def __init__(self):
        self.height = 160

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

class Girl(Person):
    def __init__(self):
        super(Girl, self).__init__()
        self.breast = 90

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

if __name__ == "__main__":
    cang = Girl()
    cang.about("wangguniang")

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

执行结果：

$ python 20903.py 
wangguniang is a hot girl, she is about 160, and her breast is 90
wangguniang is about 160

最后要提醒注意：super 函数仅仅适用于新式类。当然，你一定是使用的新式类。“喜新厌旧”是程序员的嗜好。