一、問題的發現與提出

在Python類的方法(method)中，要調用父類的某個方法，在Python 2.2以前，通常的寫法如代碼段1：

代碼段1：

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

即，使用非綁定的類方法(用類名來引用的方法)，并在參數列表中，引入待綁定的對象(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：

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"

嘗試執行上面同樣的代碼，結果一致，但修改的代碼只有一處，把代碼的維護量降到最低，是一個不錯的用法。因此在我們的開發過程中，super關鍵字被大量使用，而且一直表現良好。

在我們的印象中，對于super(B, self).__init__()是這樣理解的：super(B, self)首先找到B的父類(就是類A)，然后把類B的對象self轉換為類A的對象(通過某種方式，一直沒有考究是什么方式，慚愧)，然后“被轉換”的類A對象調用自己的__init__函數。考慮到super中只有指明子類的機制，因此，在多繼承的類定義中，通常我們保留使用類似代碼段1的方法。

有一天某同事設計了一個相對復雜的類體系結構(我們先不要管這個類體系設計得是否合理，僅把這個例子作為一個題目來研究就好)，代碼如代碼段4：

代碼段4：

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"

>>> f = F()

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

明顯地，類A和類D的初始化函數被重復調用了2次，這并不是我們所期望的結果！我們所期望的結果是最多只有類A的初始化函數被調用2次——其實這是多繼承的類體系必須面對的問題。我們把代碼段4的類體系畫出來，如下圖：

object

| /

| A

| / |

B C D

/ / |

E |

/ |

F

按我們對super的理解，從圖中可以看出，在調用類C的初始化函數時，應該是調用類A的初始化函數，但事實上卻調用了類D的初始化函數。好一個詭異的問題！

詳情請點擊：Python中的super用法詳解_python_腳本之家?www.jb51.net

注意點：

1.__init__是析構函數，也就是類被實例化(生成對象)之后默認加載的內容，常用于初始化類。

2.__init__是函數只加在一次，且在類運行時首先運行。

3.#通過super初始化父類，__init__()函數無self，若直接QtWidgets.QWidget.__init__(self)，括號里是有self的

總結

以上是生活随笔為你收集整理的python中的super用法详解_【Python】【类】super用法详解的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。