python3類與繼承

⑴ 又來求助了，大神求解答 python類繼承的問題

老式類就是經典類,不是繼承自object類.在多繼承時採用深度優先遍歷父類.
新式類就是基類繼承自object類 class xxx(object).多繼承時採用一種新的C3 演算法來遍歷父類.
實例如下:

新式類的打配絕印結果如下：

舊式類的列印結果如下：

由此我們可以看出新式類的搜索過程為:Son-->Father-->Mother,而舊式類的搜索過程為:Son-->Father-->GrandFather

我們可以看出舊式類和我們預期的繼承不太一樣。

老式類就是經典類,不是繼承自object類.在多繼承時採用深度優先遍歷父類.
新式類就是基類繼承自object類 class xxx(object).多繼承時採用一種新的C3 演算法來遍歷父類.

為什麼採用C3演算法呢？

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

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

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

為了解釋C3演算法，我們引入了mro(mro即 method resolution order (方法解釋順序)，主要用於在多繼承時判斷屬性的路徑(來自於哪個類))。

我們可以通過class.mro()來查看python類的mro

C3演算法
判斷mro要先確定一個線性序列，然後查找路徑由由序列中類的順序決定。所以C3演算法就是生成一個線性序列。
如果繼承至一個基類:
class B(A)
這時B的mro序列為[B,A]

如果繼承至多個基類
class B(A1,A2,A3 ...)
這時B的mro序列 mro(B) = [B] + merge(mro(A1), mro(A2), mro(A3) ..., [A1,A2,A3])

merge操作就是C3演算法的核心。
遍歷執行merge操作的序列，如果一個序列的第一個元素，是其他序列中的第一個元素，或不在其他序列出現，則從所有執行merge操作序列中刪除這個元素，合並到當前的mro中。
merge操作後的序列，繼續執行merge操作，直到merge操作的序列為空。
如果merge操作的序列無法為空，則說明不合法。

例子：
class A(O):pass
class B(O):pass
class C(O):pass
class E(A,B):pass
class F(B,C):pass
class G(E,F):pass

A、B、C都繼承至一個基類，所以mro序列依次為[A,O]、[B,O]、[C,O]
mro(E) = [E] + merge(mro(A), mro(B), [A,B])
= [E] + merge([A,O], [B,O], [A,B])
執行merge操作的序列為[A,O]、[B,O]、[A,B]
A是序列[A,O]中的第空拿一個元素，在序列[B,O]中不出現，在序列[A,B]中也是第一個元素，所以從執行merge操作的序列([A,O]、[B,O]、[A,B])中刪除A，合並到當前mro，[E]中。
mro(E) = [E,A] + merge([O], [B,O], [B])
再執行merge操作，O是序列[O]中的第一個元素，但O在序列[B,O]中出現並且不是其中第一個元素。繼續查看[B,O]的第一個元素B，B滿足條件，所以從執行merge操作的序列中刪除B，合並到[E, A]中。
mro(E) = [E,A,B] + merge([O], [O])
= [E,A,B,O]

⑵ python屬性可以繼承嗎繼承

python屬性可以繼承，但是不支持私有繼承。
繼承是面向對象的重要特徵之一，繼承是兩個類或者多個類之間的父子關系，子進程繼承了父進程的所有公有實例變數和方法。繼承實現了代碼的重用。重用已經存在的數據和行為，減少代碼的重新編寫，python在類名後用一對圓括弧表示繼承關系， 括弧中的類表示父類，如果父類定義了__init__方法，則子類必須顯示地調用父類的__init__方法，如果子類需要擴展父類的行為，可以添加__init__方法的參數。

⑶ Python中的繼承是什麼意思

繼承是子類復用父類的屬性和方法的機制，類的繼承是以生活中繼承為靈感設計的。

生活中繼承的例子有很多，例如，汽車的發展歷程就體現了繼承。最早汽車的輪胎都是實心的，功能少，性能差，而如今汽車的功能越來越多，性能越來越好，這是經過一代一代的發展而來的，每一代比上一代擴充了一些功能，改進了一些性能。縱觀整個汽車的發展史，每一代汽車都是在上一代汽車的特徵和行為的基礎之上，進行了設計和改良。這其中有些功能沒有改變，有些功能是新增的，也有些功能經過了改良。例如，從第一代的汽車到現在的汽車，做交通工具這一特點始終都在沿用。

生活中汽車的例子，與計算機中的繼承是非常相似的。這么一代又一代的更新是有好處的。

首先，節省了設計流程，不用閉門造車。

其次，在前一代汽車基礎之上設計，這樣原來重復的生產技術還可以復用，再設計一些新增的功能，這樣就能大大地提高生產效率。

下面介紹一個實際案例，來說明繼承的用處。

假設設計一個師生管理系統，具有學生和教師兩種用戶，需要設計兩個類，一個學生類(Student)，一個教師類(Teacher)。Student類有學號、姓名、性別、年齡、用戶名、密碼等屬性，Teacher類有姓名、性別、年齡、用戶名、密碼、學歷等屬性，這兩個類中都有屬性的getter和setter方法。由此可知，這兩個類中有許多相同的屬性和方法，也就是說代碼有冗餘。為了避免這樣的情況，就可以使用繼承來優化設計。將Student類和Teacher類中相同的屬性和方法抽取出來，單獨作為一個父類，這個父類稱為用戶類(User)，而Student類和Teacher類作為子類繼承父類User。Student類和Teacher類中就只放自己特有的屬性和方法即可。由於這兩個類都繼承User類，因此User類中的屬性和方法，它們可以直接使用。需要指出的是，在繼承中私有屬性和私有方法是不能被繼承的。

繼承提高了代碼的重用性，減少了代碼和數據的冗餘度。另外，如果要修改用戶名屬性，不採用繼承的情況下，兩個類的屬性都需要修改，而使用繼承後，只需要修改父類的用戶名屬性即可。由此可知，繼承使代碼的修改更加方便。

關於Python的基礎問題可以看下這個網頁的視頻教程，網頁鏈接，希望我的回答能幫到你。

⑷ Python中類繼承問題

Python新式類採用MRO演算法處理繼承關系，當調用c.say()方法時首先查找C類中是否定義了say()方法，若沒有繼續查找B類中是否定義了say()方法，找到B類中定義有say()方法，因此使用B類的say()方法。

⑸ python中的繼承和多態

繼承：在已有類的基礎上創建新類，這其中的一種做法就是讓一個類從另一個類那裡將屬性和方法直接繼承下來，從而減少重復代碼的編寫。
1.提供繼承信息的我們稱之為父類，也叫超類或基類；2.得到繼承信息的我們稱之為子類，也叫派生類或衍生類。3.子類除了繼承父類提供的屬性和方法，還可以定義自己特有的屬性和方法，所以子類比父類擁有的更多的能力
多態：子類在繼承了父類的方法後，通過方法重寫我們可以讓父類的同一個行為在子類中擁有不同的實現版本，這個就是多態。

⑹ Python中繼承的理解與運用

9.5. 繼承
當然，如果一種語言不支持繼承就，「類」就沒有什麼意義。派生類的定義如下所示:
class DerivedClassName(BaseClassName):

命名 BaseClassName （示例中的基類名）必須與派生類定義在一個作用域內。除了類，還可以用表達式，基類定義在另一個模塊中時這一點非常有用:
class DerivedClassName(modname.BaseClassName):
派生類定義的執行過程和基類是一樣的。構造派生類對象時，就記住了基類。這在解析屬性引用的時候尤其有用：如果在類中找不到請求調用的屬性，就搜索基類。如果基類是由別的類派生而來，這個規則會遞歸的應用上去。
派生類的實例化沒有什麼特殊之處： DerivedClassName() （示列中的派生類）創建一個新的類實例。方法引用按如下規則解析：搜索對應的類屬性，必要時沿基類鏈逐級搜索，如果找到了函數對象這個方法引用就是合法的。
派生類可能會覆蓋其基類的方法。因為方法調用同一個對象中的其它方法時沒有特權，基類的方法調用同一個基類的方法時，可能實際上最終調用了派生類中的覆蓋方法。（對於 C++ 程序員來說，Python 中的所有方法本質上都是 虛 方法。）
派生類中的覆蓋方法可能是想要擴充而不是簡單的替代基類中的重名方法。有一個簡單的方法可以直接調用基類方法，只要調用： BaseClassName.methodname(self, arguments)。有時這對於客戶也很有用。（要注意只有 BaseClassName 在同一全局作用域定義或導入時才能這樣用。）
Python 有兩個用於繼承的函數：
函數 isinstance() 用於檢查實例類型： isinstance(obj, int) 只有在 obj.__class__ 是 int 或其它從 int 繼承的類型
函數 issubclass() 用於檢查類繼承： issubclass(bool, int) 為 True，因為 bool 是 int 的子類。
然而， issubclass(float, int) 為 False，因為 float 不是 int 的子類。

⑺ 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類的繼承的認識了，希望對大家能有所幫助