python super()

心已赠人 2022-08-06 09:11 159阅读 0赞

http://www.cnblogs.com/lovemo1314/archive/2011/05/03/2035005.html

一、问题的发现与提出

在Python类的方法（method）中，要调用父类的某个方法，在Python 2.2以前，通常的写法如代码段1：

代码段1：

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

![复制代码][copycode.gif]

class A:
      def __init__(self):
       print "enter A"
       print "leave A"
    
     class B(A):
      def __init__(self):
       print "enter B"
       A.__init__(self)
       print "leave B"
    
     >>> b = B()
     enter B
     enter A
     leave A
     leave B

![复制代码][copycode.gif]

即，使用非绑定的类方法（用类名来引用的方法），并在参数列表中，引入待绑定的对象（self），从而达到调用父类的目的。

这样做的缺点是，当一个子类的父类发生变化时（如类B的父类由A变为C时），必须遍历整个类定义，把所有的通过非绑定的方法的类名全部替换过来，例如代码段2，

代码段2：

class B(C):    # A --> C
      def __init__(self):
       print "enter B"
       C.__init__(self) # A --> C
       print "leave B"

如果代码简单，这样的改动或许还可以接受。但如果代码量庞大，这样的修改可能是灾难性的。

因此，自Python 2.2开始，Python添加了一个关键字super，来解决这个问题。下面是Python 2.3的官方文档说明：

super(type\[, object-or-type\])

Return the superclass of type. If the second argument is omitted the super object  
  returned is unbound. If the second argument is an object, isinstance(obj, type)   
  must be true. If the second argument is a type, issubclass(type2, type) must be   
  true. super() only works for new-style classes.

A typical use for calling a cooperative superclass method is:

class C(B):  
       def meth(self, arg):  
           super(C, self).meth(arg)

New in version 2.2.

从说明来看，可以把类B改写如代码段3：

代码段3：

![复制代码][copycode.gif]

class A(object):    # A must be new-style class
      def __init__(self):
       print "enter A"
       print "leave A"
    
    class B(C):     # A --> C
      def __init__(self):
       print "enter B"
       super(B, self).__init__()
       print "leave B"

![复制代码][copycode.gif]

尝试执行上面同样的代码，结果一致，但修改的代码只有一处，把代码的维护量降到最低，是一个不错的用法。因此在我们的开发过程中，super关键字被大量使用，而且一直表现良好。

在我们的印象中，对于super(B, self).\_\_init\_\_()是这样理解的：super(B, self)首先找到B的父类（就是类A），然后把类B的对象self转换为类A的对象（通过某种方式，一直没有考究是什么方式，惭愧），然后“被转换”的类A对象调用自己的\_\_init\_\_函数。考虑到super中只有指明子类的机制，因此，在多继承的类定义中，通常我们保留使用类似代码段1的方法。

有一天某同事设计了一个相对复杂的类体系结构（我们先不要管这个类体系设计得是否合理，仅把这个例子作为一个题目来研究就好），代码如代码段4：

代码段4：

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

![复制代码][copycode.gif]

class A(object):
      def __init__(self):
       print "enter A"
       print "leave A"
    
     class B(object):
      def __init__(self):
       print "enter B"
       print "leave B"
    
     class C(A):
      def __init__(self):
       print "enter C"
       super(C, self).__init__()
       print "leave C"
    
     class D(A):
      def __init__(self):
       print "enter D"
       super(D, self).__init__()
       print "leave D"
     class E(B, C):
      def __init__(self):
       print "enter E"
       B.__init__(self)
       C.__init__(self)
       print "leave E"
    
     class F(E, D):
      def __init__(self):
       print "enter F"
       E.__init__(self)
       D.__init__(self)
       print "leave F"

![复制代码][copycode.gif]

f = F() result:

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

![复制代码][copycode.gif]

enter F
     enter E
     enter B
     leave B
     enter C
     enter D
     enter A
     leave A
     leave D
     leave C
     leave E
     enter D
     enter A
     leave A
     leave D
     leave F

![复制代码][copycode.gif]

明显地，类A和类D的初始化函数被重复调用了2次，这并不是我们所期望的结果！我们所期望的结果是最多只有类A的初始化函数被调用2次——其实这是多继承的类体系必须面对的问题。我们把代码段4的类体系画出来，如下图：

object  
     /    \\  
   |        A  
   |      / |  
   B  C  D  
    \\   /   |  
      E    |  
        \\   |  
          F

按我们对super的理解，从图中可以看出，在调用类C的初始化函数时，应该是调用类A的初始化函数，但事实上却调用了类D的初始化函数。好一个诡异的问题！

也就是说，mro中记录了一个类的所有基类的类类型序列。查看mro的记录，发觉包含7个元素，7个类名分别为：

F E B C D A object

从而说明了为什么在C.\_\_init\_\_中使用super(C, self).\_\_init\_\_()会调用类D的初始化函数了。 ???

我们把代码段4改写为：

代码段9：

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

class A(object):
      def __init__(self):
       print "enter A"
       super(A, self).__init__()  # new
       print "leave A"
    
     class B(object):
      def __init__(self):
       print "enter B"
       super(B, self).__init__()  # new
       print "leave B"
    
     class C(A):
      def __init__(self):
       print "enter C"
       super(C, self).__init__()
       print "leave C"
    
     class D(A):
      def __init__(self):
       print "enter D"
       super(D, self).__init__()
       print "leave D"
     class E(B, C):
      def __init__(self):
       print "enter E"
       super(E, self).__init__()  # change
       print "leave E"
    
     class F(E, D):
      def __init__(self):
       print "enter F"
       super(F, self).__init__()  # change
       print "leave F"

f = F() result:

![复制代码][copycode.gif]

enter F
     enter E
     enter B
     enter C
     enter D
     enter A
     leave A
     leave D
     leave C
     leave B
     leave E
     leave F

![复制代码][copycode.gif]

明显地，F的初始化不仅完成了所有的父类的调用，而且保证了每一个父类的初始化函数只调用一次。

再看类结构：

![复制代码][copycode.gif]

object
         /   \
        /      A
       |     /   \
      B-1  C-2   D-2
        \   /    /
         E-1    /
            \  /
              F

![复制代码][copycode.gif]

E-1,D-2是F的父类，其中表示E类在前，即F（E，D）。

所以初始化顺序可以从类结构图来看出 ： F－>E->B -->C --> D --> A

由于C，D有同一个父类，因此会先初始化D再是A。

三、延续的讨论

我们再重新看上面的类体系图，如果把每一个类看作图的一个节点，每一个从子类到父类的直接继承关系看作一条有向边，那么该体系图将变为一个有向图。不能发现mro的顺序正好是该有向图的一个拓扑排序序列。

从而，我们得到了另一个结果——Python是如何去处理多继承。支持多继承的传统的面向对象程序语言（如C++）是通过虚拟继承的方式去实现多继承中父类的构造函数被多次调用的问题，而Python则通过mro的方式去处理。

但这给我们一个难题：对于提供类体系的编写者来说，他不知道使用者会怎么使用他的类体系，也就是说，不正确的后续类，可能会导致原有类体系的错误，而且这样的错误非常隐蔽的，也难于发现。

四、小结

1. super并不是一个函数，是一个类名，形如super(B, self)事实上调用了super类的初始化函数，  
       产生了一个super对象；  
　　2. super类的初始化函数并没有做什么特殊的操作，只是简单记录了类类型和具体实例；  
　　3. super(B, self).func的调用并不是用于调用当前类的父类的func函数；  
　　4. Python的多继承类是通过mro的方式来保证各个父类的函数被逐一调用，而且保证每个父类函数  
       只调用一次（如果每个类都使用super）；  
　　5. 混用super类和非绑定的函数是一个危险行为，这可能导致应该调用的父类函数没有调用或者一  
       个父类函数被调用多次。

http://www.cnblogs.com/dkblog/archive/2011/02/24/1980654.html

# [关于Python的super用法研究][Python_super] #

Python中对象方法的定义很怪异，第一个参数一般都命名为self（相当于其它语言的this），用于传递对象本身，而在调用的时候则不必显式传递，系统会自动传递。  
  
举一个很常见的例子：  
  
>>> class Foo:  
def bar(self, message):  
print(message)  
  
>>> Foo().bar("Hello, World.")  
Hello, World.  
  
当存在继承关系的时候，有时候需要在子类中调用父类的方法，此时最简单的方法是把对象调用转换成类调用，需要注意的是这时self参数需要显式传递，例如：  
  
>>> class FooParent:  
def bar(self, message):  
print(message)  
  
>>> class FooChild(FooParent):  
def bar(self, message):  
FooParent.bar(self, message)  
  
>>> FooChild().bar("Hello, World.")  
Hello, World.  
  
这样做有一些缺点，比如说如果修改了父类名称，那么在子类中会涉及多处修改，另外，Python是允许多继承的语言，如上所示的方法在多继承时就需要重复写多次，显得累赘。为了解决这些问题，Python引入了super()机制，例子代码如下：  
  
>>> class FooParent:  
def bar(self, message):  
print(message)  
  
  
>>> class FooChild(FooParent):  
def bar(self, message):  
super(FooChild, self).bar(message)  
  
  
>>> FooChild().bar("Hello, World.")  
Hello, World.  
  
表面上看 super(FooChild, self).bar(message)方法和FooParent.bar(self, message)方法的结果是一致的，实际上这两种方法的内部处理机制大大不同，当涉及多继承情况时，就会表现出明显的差异来，直接给例子：  
  
代码一：  
  
class A:  
def \_\_init\_\_(self):  
print("Enter A")  
print("Leave A")  
  
class B(A):  
def \_\_init\_\_(self):  
print("Enter B")  
A.\_\_init\_\_(self)  
print("Leave B")  
  
class C(A):  
def \_\_init\_\_(self):  
print("Enter C")  
A.\_\_init\_\_(self)  
print("Leave C")  
  
class D(A):  
def \_\_init\_\_(self):  
print("Enter D")  
A.\_\_init\_\_(self)  
print("Leave D")  
  
class E(B, C, D):  
def \_\_init\_\_(self):  
print("Enter E")  
B.\_\_init\_\_(self)  
C.\_\_init\_\_(self)  
D.\_\_init\_\_(self)  
print("Leave E")  
  
E()  
  
结果：  
  
Enter E  
Enter B  
Enter A  
Leave A  
Leave B  
Enter C  
Enter A  
Leave A  
Leave C  
Enter D  
Enter A  
Leave A  
Leave D  
Leave E  
  
执行顺序很好理解，唯一需要注意的是公共父类A被执行了多次。  
  
代码二：  
  
class A:  
def \_\_init\_\_(self):  
print("Enter A")  
print("Leave A")  
  
class B(A):  
def \_\_init\_\_(self):  
print("Enter B")  
super(B, self).\_\_init\_\_()  
print("Leave B")  
  
class C(A):  
def \_\_init\_\_(self):  
print("Enter C")  
super(C, self).\_\_init\_\_()  
print("Leave C")  
  
class D(A):  
def \_\_init\_\_(self):  
print("Enter D")  
super(D, self).\_\_init\_\_()  
print("Leave D")  
  
class E(B, C, D):  
def \_\_init\_\_(self):  
print("Enter E")  
super(E, self).\_\_init\_\_()  
print("Leave E")  
  
E()  
  
结果：  
  
Enter E  
Enter B  
Enter C  
Enter D  
Enter A  
Leave A  
Leave D  
Leave C  
Leave B  
Leave E  
  
在super机制里可以保证公共父类仅被执行一次，至于执行的顺序，是按照mro进行的（E.\_\_mro\_\_）。

[ContractedBlock.gif]: http://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif
[ExpandedBlockStart.gif]: /images/20220806/52a7e96803c2441bb28b69688673fec1.png
[copycode.gif]: /images/20220806/c1360d1ee5e04a48b9b05d89aee2022d.png
[Python_super]: http://www.cnblogs.com/dkblog/archive/2011/02/24/1980654.html