方法解析順序, Method Resolution Order

從一段代碼開始

考慮下面的情況:

class A(object): def foo(self): print(’A.foo()’)class B(object): def foo(self): print(’B.foo()’)class C(B, A): passc = C()c.foo()

C同時繼承了類A和類B, 它們都有各自的foo()方法. 那么C的實例c調用foo()方法時, 到底是調用A.foo()還是B.foo()?

__mro__

Python的每一個有父類的類都有一個與方法解析順序相關的特殊屬性:__mro__, 它是一個tuple, 裝著方法解析時的對象查找順序: 越靠前的優先級越高. 執行下面的代碼:

print type(C.__mro__)print C.__mro__

輸出:

<type ’tuple’>(<class ’__main__.C’>, <class ’__main__.B’>, <class ’__main__.A’>, <type ’object’>)

可以看到, B在C的前面, 所以在上一段代碼中, c.foo()調用的是B.foo()而不是A.foo().

之所以B在C的前面, 是因為在指定C的父類時先指定了B:

class C(B, A):

若將它改成:

class C(A, B):

c.foo()執行的就是A.foo()了.

熟悉環境變量的可以將__mro__理解為以目標對象為環境的PATH變量: 從左到右開始查找, 找到就執行, 然后返回結果.

方法解析順序

從C.__mro__的值可以看出, Python的方法解析優先級從高到低為:

1. 實例本身(instance)

2. 類(class)

3. super class, 繼承關系越近, 越先定義, 優先級越高.

其實屬性解析順序也基本一致, 只不過多了個__getattr__的查找(見Python對象的屬性訪問過程).

補充知識：python中的單繼承，多繼承和mro順序

python作為一門動態語言，是和c++一樣支持面向對象編程的。相對對象編程有三大特性，分別是繼承，封裝和多態。今天我們重點講解的是，python語言中的單繼承和多繼承。

繼承概念：

如果一個類繼承了另外一個類時，它將自動獲得另一個類的所有屬性和方法，那么原有的類稱為父類，而新類稱為子類。子類繼承了其父類的所有屬性和方法。同時還可以定義自己的屬性和方法。單繼承就是一個子類只能繼承一個父類。

格式： class 子類（父類）

舉例： class A(B)

A類擁有了B類的所有的特征，A類繼承了B類

B類 父類，基類

A類 子類 派生類 后代類

繼承的作用：功能的升級和擴展功能的升級就是對原有 的功能進行完善重新，功能的擴展就是對原本沒有的功能進行添加。減少代碼的冗余。

下面我們舉一個單繼承的例子：

class Dog(): #父類 def __init__(self): #父類的屬性初始化 self.name=’狗’ self.leg=4 def __str__(self): return '名字:%s %d 條腿'%(self.name,self.leg)class Taidi(Dog): #定義一個Taidi 泰迪 類繼承自Dog類 -->單繼承 passtaidi=Taidi()print(taidi) 輸出結果--> 名字:狗 4 條腿

多繼承:

多繼承就是一個子類同時繼承自多個父類，又稱菱形繼承、鉆石繼承。

首先，我們先講多繼承中一個常見方法，單獨調用父類的方法。在子類初始化的時候需要手動調用父類的初始化方法進行父類的屬性的構造，不然就不能使用提供的屬性。

在子類中調用父類的初始化方法格式就是： 父類名._init_(self)

下面舉一個單獨調用父類方法的例子：

print('******多繼承使用類名.__init__ 發生的狀態******')class Parent(object): #父類 def __init__(self, name): print(’parent的init開始被調用’) self.name = name #屬性的初始化 print(’parent的init結束被調用’)class Son1(Parent): #單繼承 Son1子類繼承父類 def __init__(self, name, age): print(’Son1的init開始被調用’) self.age = age Parent.__init__(self, name) #單獨調用父類的屬性 print(’Son1的init結束被調用’)class Son2(Parent): #也是單繼承 Son2繼承父類 def __init__(self, name, gender): print(’Son2的init開始被調用’) self.gender = gender #單獨調用父類的初始化屬性方法 Parent.__init__(self, name) print(’Son2的init結束被調用’)class Grandson(Son1, Son2): #多繼承，繼承兩個父類 def __init__(self, name, age, gender): print(’Grandson的init開始被調用’) Son1.__init__(self, name, age) # 單獨調用父類的初始化方法 Son2.__init__(self, name, gender) print(’Grandson的init結束被調用’)gs = Grandson(’grandson’, 18, ’男’) #實例化對象print(’姓名：’, gs.name)print(’年齡：’, gs.age)print(’性別：’, gs.gender)print('******多繼承使用類名.__init__ 發生的狀態******nn')

下面讓我們看看運行的結果：

******多繼承使用類名.__init__ 發生的狀態******Grandson的init開始被調用Son1的init開始被調用parent的init開始被調用parent的init結束被調用Son1的init結束被調用Son2的init開始被調用parent的init開始被調用parent的init結束被調用Son2的init結束被調用Grandson的init結束被調用姓名： grandson年齡： 18性別： 男******多繼承使用類名.__init__ 發生的狀態******

mro順序

查看上面的運行結果，我們發現由于多繼承情況，parent類被的屬性被構造了兩次，如果在更加復雜的結構下可能更加嚴重。

為了解決這個問題，Python官方采用了一個算法將復雜結構上所有的類全部都映射到一個線性順序上，而根據這個順序就能夠保證所有的類都會被構造一次。這個順序就是MRO順序。

格式：

類名._mro_()

類名.mro()

多繼承中super調用有所父類的被重寫的方法

super本質上就是使用MRO這個順序去調用 當前類在MRO順序中下一個類。 super().init()則調用了下一個類的初始化方法進行構造。

print('******多繼承使用super().__init__ 發生的狀態******')class Parent(object): def __init__(self, name, *args, **kwargs): # 為避免多繼承報錯，使用不定長參數，接受參數 print(’parent的init開始被調用’) self.name = name print(’parent的init結束被調用’)class Son1(Parent): def __init__(self, name, age, *args, **kwargs): # 為避免多繼承報錯，使用不定長參數，接受參數 print(’Son1的init開始被調用’) self.age = age super().__init__(name, *args, **kwargs) # 為避免多繼承報錯，使用不定長參數，接受參數 print(’Son1的init結束被調用’)class Son2(Parent): def __init__(self, name, gender, *args, **kwargs): # 為避免多繼承報錯，使用不定長參數，接受參數 print(’Son2的init開始被調用’) self.gender = gender super().__init__(name, *args, **kwargs) # 為避免多繼承報錯，使用不定長參數，接受參數 print(’Son2的init結束被調用’)class Grandson(Son1, Son2): def __init__(self, name, age, gender): print(’Grandson的init開始被調用’) # 多繼承時，相對于使用類名.__init__方法，要把每個父類全部寫一遍 # 而super只用一句話，執行了全部父類的方法，這也是為何多繼承需要全部傳參的一個原因 # super(Grandson, self).__init__(name, age, gender) super().__init__(name, age, gender) print(’Grandson的init結束被調用’)print(Grandson.__mro__)gs = Grandson(’grandson’, 18, ’男’)print(’姓名：’, gs.name)print(’年齡：’, gs.age)print(’性別：’, gs.gender)print('******多繼承使用super().__init__ 發生的狀態******nn')

查看下運行結果：

******多繼承使用super().__init__ 發生的狀態******(<class ’__main__.Grandson’>, <class ’__main__.Son1’>, <class ’__main__.Son2’>, <class ’__main__.Parent’>, <class ’object’>)Grandson的init開始被調用Son1的init開始被調用Son2的init開始被調用parent的init開始被調用parent的init結束被調用Son2的init結束被調用Son1的init結束被調用Grandson的init結束被調用姓名： grandson年齡： 18性別： 男******多繼承使用super().__init__ 發生的狀態******

單繼承中super

print('******單繼承使用super().__init__ 發生的狀態******')class Parent(object): def __init__(self, name): print(’parent的init開始被調用’) self.name = name print(’parent的init結束被調用’)class Son1(Parent): def __init__(self, name, age): print(’Son1的init開始被調用’) self.age = age super().__init__(name) # 單繼承不能提供全部參數 print(’Son1的init結束被調用’)class Grandson(Son1): def __init__(self, name, age, gender): print(’Grandson的init開始被調用’) super().__init__(name, age) # 單繼承不能提供全部參數 print(’Grandson的init結束被調用’)gs = Grandson(’grandson’, 12, ’男’)print(’姓名：’, gs.name)print(’年齡：’, gs.age)#print(’性別：’, gs.gender)print('******單繼承使用super().__init__ 發生的狀態******nn')

運行結果：

******單繼承使用super().__init__ 發生的狀態******Grandson的init開始被調用Son1的init開始被調用parent的init開始被調用parent的init結束被調用Son1的init結束被調用Grandson的init結束被調用姓名： grandson年齡： 12******單繼承使用super().__init__ 發生的狀態******

下面讓我們總結下：

MRO保證了多繼承情況 每個類只出現一次

super().__init__相對于類名.init，在單繼承上用法基本無差

但在多繼承上有區別，super方法能保證每個父類的方法只會執行一次，而使用類名的方法會導致方法被執行多次

多繼承時，使用super方法，對父類的傳參數，應該是由于python中super的算法導致的原因，必須把參數全部傳遞，否則會報錯

單繼承時，使用super方法，則不能全部傳遞，只能傳父類方法所需的參數，否則會報錯

多繼承時，相對于使用類名.__init__方法，要把每個父類全部寫一遍,而使用super方法，只需寫一句話便執行了全部父類的方法，這也是為何多繼承需要全部傳參的一個原因

下面是一個簡答的面試題：

class Parent(object): x = 1class Child1(Parent): passclass Child2(Parent): passprint(Parent.x, Child1.x, Child2.x)Child1.x = 2print(Parent.x, Child1.x, Child2.x)Parent.x = 3print(Parent.x, Child1.x, Child2.x)

運行結果：

1 1 11 2 13 2 3

以上這篇淺談Python的方法解析順序(MRO)就是小編分享給大家的全部內容了，希望能給大家一個參考，也希望大家多多支持好吧啦網。