python27mro

A. python類的多重繼承問題深入分析

Python類的多重繼承問題深入分析
首先得說明的是,Python的類分為經典類 和 新式類
經典類是python2.2之前的東西,但是在2.7還在兼容,但是在3之後的版本就只承認新式類了
新式類在python2.2之後的版本中都可以使用
經典類和新式類的區別在於:
經典類是默認沒有派生自某個基類的,而新式類是默認派生自object這個基類的:
代碼如下:
# old style
class A():pass
# new style
class A(obejct):pass
2.經典類在類多重繼承的時候是採用從左到右深度優先原則匹配方法的..而新式類是採用C3演算法(不同於廣度優先)進行匹配的
3.經典類是沒有__MRO__和instance.mro()調用的,而新式類是有的.
為什麼不用經典類，要更換到新式類
因為在經典類中的多重繼承會有些問題...可能導致在繼承樹中的方法查詢繞過後面的父類:
代碼如下:
class A():
def foo1(self):
print "A"
class B(A):
def foo2(self):
pass
class C(A):
def foo1(self):
print "C"
class D(B, C):
pass
d = D()
d.foo1()
按照經典類的查找順序從左到右深度優先的規則，在訪問d.foo1()的時候,D這個類是沒有的..那麼往上查找,先找到B,裡面沒有,深度優先,訪問A,找到了foo1(),所以這時候調用的是A的foo1()，從而導致C重寫的foo1()被繞過.
所以python引入了新式類的概念,每個基類都繼承自object並且,他的匹配規則也從深度優先換到了C3
C3演算法
C3演算法是怎麼做匹配的呢..在問答版塊上面討論之後,歸結如下:
C3演算法的一個核心是merge.
在merge列表中，如果第一個序列mro的第一個類是出現在其它序列，並且也是第一個，或者不出現其它序列，那麼這個類就會從這些序列中刪除，並合到訪問順序列表中
比如:(引用問題中zhuangzebo的回答@zhuangzebo)
代碼如下:
class A(O):pass
class B(O):pass
class C(O):pass
class D(A,B):pass
class E(C,D):pass

首先需要知道 O(object)的mro(method resolution order)列表是[O,]
那麼接下來是:
代碼如下:
mro(A) = [A, O]
mro(B) = [B, O]
mro(C) = [C, O]
mro(D) = [D] + merge(mro(A), mro(B), [A, B])
= [D] + merge([A, O], [B, O], [A, B])
= [D, A] + merge([O], [B, O], [B])
= [D, A, B] + merge([O], [O])
= [D, A, B, O]
mro(E) = [E] + merge(mro(C), mro(D), [C, D])
= [E] + merge([C, O], [D, A, B, O], [C, D])
= [E, C] + merge([O], [D, A, B, O], [D])
= [E, C, D] + merge([O], [A, B, O])
= [E, C, D, A, B] + merge([O], [O])
= [E, C, D, A, B, O]

然後還有一種特殊情況:
比如：
merge(DO,CO,C) 先merge的是D
merge(DO,CO,C) 先merge的是C
意思就是.當出現有 一個類出現在兩個序列的頭(比如C) 這種情況和 這個類只有在一個序列的頭(比如D) 這種情況同時出現的時候,按照順序方式匹配。
新式類生成的訪問序列被存儲在一個叫MRO的只讀列表中..
你可以使用instance.__MRO__或者instance.mro()來訪問
最後匹配的時候就按照MRO序列的順序去匹配了
C3和廣度優先的區別:
舉個例子就完全明白了:
代碼如下:
class A(object):pass
class B(A):pass
class C(B):pass
class D(A):pass
class E(D):pass
class F(C, E):pass

按照廣度優先遍歷,F的MRO序列應該是[F,C,E,B,D,A]
但是C3是[F,E,D,C,B,A]
意思是你可以當做C3是在一條鏈路上深度遍歷到和另外一條鏈路的交叉點,然後去深度遍歷另外一條鏈路,最後遍歷交叉點
新式類和經典類的super和按類名訪問問題
在經典類中,你如果要訪問父類的話,是用類名來訪問的..
代碼如下:
class A():
def __init__(self):
print "A"
class B(A):
def __init__(self):
print "B"
A.__init__(self) #python不會默認調用父類的初始化函數的

這樣子看起來沒三問題,但是如果類的繼承結構比較復雜，會導致代碼的可維護性很差..
所以新式類推出了super這個東西...
代碼如下:
class A():
def __init__(self):
print "A"
class B(A):
def __init__(self):
print "B"
super(B,self).__init__()

這時候，又有一個問題:當類是多重繼承的時候,super訪問的是哪一個類呢?
super實際上是通過__MRO__序列來確定訪問哪一個類的...實際上就是調用__MRO__中此類後面的一個類的方法.
比如序列為[F,E,D,C,B,A]那麼F中的super就是E,E的就是D
super和按照類名訪問 混合使用帶來的坑
代碼如下:
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"
這時候列印出來是：
代碼如下:
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

可以看出來D和A的初始化函數被亂入了兩次！
按類名訪問就相當於C語言之前的GOTO語句...亂跳,然後再用super按順序訪問..就有問題了
所以建議就是要麼一直用super,要麼一直用按照類名訪問
最佳實現:
避免多重繼承
super使用一致
不要混用經典類和新式類
調用父類的時候注意檢查類層次
以上便是本人對於python類的繼承的認識了，希望對大家能有所幫助

B. Python有什麼缺點呢

1. - 運行速度慢，因為Python是解釋型語言，是一種高級語言，代碼會在執行的時候，一行一行的使用解釋器翻譯成底層代碼，翻譯成機器碼，而這個過程非常耗時，所以他運行過程中，比很多語言的代碼都慢了很多。
- 線程不能利用多CPU，這是Python最大的確定，GIL即全局解釋器鎖（Global Interpreter Lock），是計算機程序設計語言解釋器用於同步線程的工具，使得任何時刻僅有一個線程在執行，Python的線程是操作系統的原生線程。在Linux上為pthread，在Windows上為Win thread，完全由操作系統調度線程的執行。一個python解釋器進程內有一條主線程，以及多條用戶程序的執行線程。即使在多核CPU平台上，由於GIL的存在，所以禁止多線程的並行執行。
Python的優缺點可以看看傳智播客的社區，裡面很多技術老師寫的相關文章。並且有學習線路圖適合小白學習，每個板塊下面都有配套視頻。

C. Python可以多繼承嗎

Python支持多繼承，與C++一樣都會出現一種問題：子類繼承的多個父類又繼承了同一個父類，這時就有可能會出現父類構造方法被調用多次的情況。關於這個問題，我找了一些資料，雖然沒有親自全部驗證，這里我總結一下自己對這個問題的看法。

Python和C++的關於這個問題的解決方案不太一樣，當然Python還要看它的版本。

C++用的方案是引入了虛繼承的語法避免同一個類被構造了多次。

Python用的方法是MRO(method resolution order,方法解析順序) 。在在Python2.3之前，MRO的實現是基於DFS的，而在Python2.3以後MRO的實現是基於C3演算法。找到的資料解釋了一下更換演算法的原因:

為什麼採用C3演算法

C3演算法最早被提出是用於Lisp的，應用在Python中是為了解決原來基於深度優先搜索演算法不滿足本地優先順序，和單調性的問題。

本地優先順序：指聲明時父類的順序，比如C(A,B)，如果訪問C類對象屬性時，應該根據聲明順序，優先查找A類，然後再查找B類。

單調性：如果在C的解析順序中，A排在B的前面，那麼在C的所有子類里，也必須滿足這個順序。

------------------------------新式類和舊式類中查找屬性的順序不同-------------------------------------

在新式類中，查找一個要調用的函數或者屬性的時候，是廣度優先搜搜的。

在舊式類當中，是深度優先搜索的。

D. python 的range()函數怎麼使用，為什麼單獨運行print(range(1,5))輸出還是range(1,5),而不是[1,2,3,4]

print("類型：",type(range(1,5)))
print(range.mro())

看結果：

E. 如何獲取python編程基礎及應用實驗教程的實驗文件

在 Python 中創建一個類及其對象
在 Python 中創建一個空類
在 Python 中使用 Type 創建類
在 Python 中創建和調用類的方法
使用 __init__() 方法為數據屬性賦值
在 Python 中更新對象屬性
在 Python 中刪除對象屬性和對象
在 Python 中檢查和比較對象的類型
在Python中將對象的所有屬性復制到另一個對象
在 Python 中迭代對象屬性
在 Python 中列印對象的所有屬性
在python中在運行時創建類的數據屬性
在函數中將對象的實例作為參數傳遞
在 Python 中創建和使用自定義 Self 參數
使用self參數來維護對象的狀態
在 Python 中創建和使用靜態類變數
在 Python 中的一個函數上使用多個裝飾器
在 Python 中的方法中同時訪問 cls 和 self
從裝飾器訪問實例方法的類
使用給定的裝飾器獲取 Python 類的所有方法
裝飾一個 class
將類欄位作為參數傳遞給類方法上的裝飾器
在 Python 中創建多個傳入參數列表的類變數
Python 中的 wraps 裝飾器
使用可選參數構建裝飾器
在 Python 中將參數傳遞給裝飾器
@property 裝飾器
類和函數的裝飾器
Python 中帶參數和返回值的裝飾器
Python 使用參數 wraps 裝飾器
Python 裝飾器獲取類名
簡單裝飾器示例
在 Python 中使用 print() 列印類的實例
在 Python 中的類中將裝飾器定義為方法
獲取在 Python 中修飾的給定類的所有方法
帶參數和不帶參數的 Python 裝飾器
Python 中帶有 self 參數的類方法裝飾器
在 Python 中的另一個類中使用隱藏的裝飾器
裝飾器內部的 self 對象
在 Python 中將多個裝飾器應用於單個函數
Python 裝飾器獲取類實例
__init__ 和 __call__ 有什麼區別
在 Python 中使用 __new__ 和 __init__
Python 中的迭代重載方法
在 Python 中使用迭代器反轉字元串
Python 中 __reversed__ 魔術方法
Python 中的 __getitem__ 和 __setitem__
在 Python 中使用 __getattr__ 和 __setattr__ 進行屬性賦值
什麼是 __del__ 方法以及如何調用它
創建類的私有成員
一個 Python 封裝的例子
一個 Python 組合的例子
一個Python聚合的例子
Python 中的單級、多級和多級繼承
在 Python 中獲取一個類的父類
Python 中的多態性
訪問 Child 類中的私有成員
Python 中的抽象類
創建一個抽象類來覆蓋 Python 中的默認構造函數
使一個抽象類繼承另一個抽象類
Python 中的 super 是做什麼的
super() 如何在多重繼承中與 __init__() 方法一起工作
將 super 與類方法一起使用
mro 是做什麼的
Python 中的元類是什麼
元類的具體案例
在 Python 中使用元類的單例類
@staticmethod 和 @classmethod 有什麼區別
Python 中的裝飾器是什麼
製作函數裝飾器鏈