ワン：オブジェクト指向の継承とは何ですか？
比較公式声明は次のとおりです。
継承（英語：継承は）の間で、オブジェクト指向ソフトウェア技術の概念です。
別のカテゴリB「から継承された」カテゴリAは、Aを入れた場合は、「サブカテゴリーB」と呼ばれています
そして、Bも呼び出すことができる「カテゴリーAの父」と呼ばれている「AのBは、スーパークラスです。」継承は、サブカテゴリーを作ることができます
もう一度同じコードを記述することなく、親クラスのさまざまなプロパティとメソッドを持ちます。玲子で
クラスは、特定のプロパティを再定義することができるが、親カテゴリを継承し、そして特定の方法、すなわち、コーティングをオーバーライド
オリジナルのプロパティとメソッドは、その親カテゴリ別の関数を取得するには、親カテゴリをカバーしています。さらに、サブクラス
新しいプロパティとメソッドが一般的である追加しないでください。一般的な静的なオブジェクト指向プログラミング言語、継承
コンパイル時に決定されたサブカテゴリーの行動を意味し、静的であり、実施期間中に展開することはできません。
文字通り意味：彼の父の足跡、あなたが唯一の子である場合に、ある家族の財産の法的後継者、そしてあなたは、
非常に親孝行は、他には何も、あなたはすべての家、あなたの親を継承しないだろう、と自分の財産のすべてがあなたによって使用されます
（放蕩子供を除きます）。
だから、例を見て継承されました：
クラスパーソン：
デフ__init __（自己、名前、性別、年齢）：
self.name =名前
self.age =年齢
self.sex =セックス
クラスキャット：
デフ__init __（自己、名前、性別、年齢）：
self.name =名前
self.age =年齢
self.sex =セックス
クラス犬：
デフ__init __（自己、名前、性別、年齢）：
self.name =名前
self.age =年齢
self.sex =セックス
＃継承用法：
クラスAniaml（オブジェクト）：
DEF __init __（自己、名前、性別、年齢）：
self.name =名前
self.age =年齢
self.sex =セックス
クラスの人（Aniaml）：
パス
クラスキャット（Aniaml）：
パス
クラス・ドッグ（Aniaml）：
パス
継承少しは明らかです。
1クラスの結合の増加は、（適切でない結合、微細であるべきです）。
図2に示すように、繰り返しコードを減らします。
3、合理化、コードはより標準化されます。
二つの継承された分類
上記の例の場合：
アミナールは、親クラス、基底クラス、スーパークラスと呼ばれます。
人猫犬：サブクラスで、派生クラス。
継承：に分けることができる単一継承、多重継承。
私たちは、Pythonでのクラス（必要を継承）種を追加する必要があります：
python2x版では2つのクラスがあります。
⼀と呼ばれるクラシックのpython2.2がストレート書き込みするかの古典的な何で古典的なルートベースクラスクラスクラスを使用する前に⼀....
⼀と呼ばれる新しいカテゴリインチpython2.2は、新しいクラスの後に登場しました。新機能は、ルートクラスは、オブジェクトクラスの基本クラスです。
python3xバージョンは唯一のクラスである：
操作の使用のpython3は、新しいクラス、デフォルトでは、クラスオブジェクトの継承を継承しない基本クラスならば。
III。単一継承
3.1クラス名、オブジェクトの親クラスのメソッドを実行します
Aniamlクラス（オブジェクト）：
TYPE_NAME = '動物の
デフ__init __（自己、名前、性別、年齢）：
self.name =名前
self.age =年齢
self.sex =セックス
DEF EAT（セルフ）：
印刷（セルフ）
を印刷（ '食べます'）
クラスの人（Aniaml）：
パス
クラスキャット（Aniaml）：
パス
クラス・ドッグ（Aniaml）：
パス
＃クラス名：
印刷（Person.type_name）＃は、親クラスの属性とメソッドを呼び出すことができます。
Person.eat（111）
印刷（Person.type_name）
オブジェクト＃：
＃インスタンス化オブジェクト
P1 =人（「チョン」は、「M」、18である）
プリント（P1 .__ dict__にマジック）
親クラス・オブジェクトのプロパティは、＃クラスのメソッドを実行されます。
印刷（p1.type_name）
p1.type_name = '666'
プリント（P1）
p1.eat（）
クラス名、オブジェクトはそれぞれ、親クラスのメソッドを呼び出します
3.2実行順序
クラスAniaml（オブジェクト）：
タイプ名= '动物类'
デフ__init __（自己、名前、性別、年齢）：
self.name =名前
self.age =年齢
self.sex =セックス
DEF EAT（セルフ）：
印刷（セルフ）
を印刷（ '食べます'）
クラスの人（Aniaml）：
デフを食べる（自己）：
プリント（ '％sの吃饭' ％self.name）
クラスキャット（Aniaml）：
パス
クラス・ドッグ（Aniaml）：
パス
P1 =人（「バリー」、 「 M」、18）
オブジェクトは、オブジェクトクラスから見＃1 __init__方法ではなく、親クラスから見たクラスではなく、親クラス、インスタンス化されるときに実行されます。
p1.eat（）
＃メソッドは最初、自分のクラスを食べて実行する必要があり、親クラスで独自のクラスを実行する方法はありません。
実行順序
3.3クラスと親クラスメソッドを行いながら
この方法の一つ：
あなたは親クラスのFUNCメソッドを実行したい場合は、この方法と夜の使用をサブクラス化し、サブクラスのメソッドに記述します。
.FUNC親クラス（オブジェクト他のパラメータ）
例えば：
クラスAniaml（オブジェクト）：
タイプ名= '动物类'
デフ__init __（自己、名前、性別、年齢）：
self.name =名前
self.age =年齢
self.sex =セックス
：DEF（自己を）EAT
（ '食べる'）を印刷
クラスの人（Aniaml）：
DEFの__init __（自己、名前、性別、年齢、マインド）：
'' '
自己= P1
名='チョン'
セックス=' laddboy '
年齢= 18
マインド='思考'
' ''
＃Aniaml .__のinit __（自己、名前 、性別、年齢）＃ メソッド
self.mind =心
：（自己）DEFを食べる
。スーパー（）を食べる（）
印刷（ '％sの吃饭' ％self.name）
クラスキャット（Aniaml）：
パスを
クラス・ドッグ（Aniaml）：
パス
＃方法1：.__ Aniamlのinit __（自己、名前、性別、年齢）
＃P1 =人（ 'チョン'、 'laddboy'、18、 ' 思考'）
＃印刷（P1 .__ dict__に）
＃方法は理解していない場合：
＃DEF FUNC（セルフ）：
＃印刷（セルフ）
＃= 3セルフ。
＃FUNC（セルフ）
方法2：
スーパー、スーパーを使用して（）。のFunc（パラメータ）
クラスAniaml（オブジェクト）：
タイプ名= '动物类'
デフ__init __（自己、名前、性別、年齢）：
self.name =名前
self.age =年齢
self.sex =セックス
：DEF（自己を）EAT
（ '食べる'）を印刷
クラスの人（Aniaml）：
DEFの__init __（自己、名前、性別、年齢、マインド）：
'' '
自己= P1
名='チョン'
セックス=' laddboy '
年齢= 18
マインド='思考'
' ''
＃スーパー（人、自己）.__のinit __（名前、性別、年齢）＃のメソッド2
スーパー（）.__のinit __（名前 、性別、年齢）＃のメソッド2
self.mind =心
：（自己）DEFを食べる
。スーパー（）を食べる（）
印刷（ '％sの吃饭' ％self.name）
クラスキャット（Aniaml）：
パスを
Dogクラス（Aniaml）：
パス
＃P1 =人（ 'チョン'、 'laddboy'、18、 ' 思考'）
＃印刷（P1 .__ dict__に）
単一継承演習：
＃1
クラスベース：
デフ__init __（自己、NUM）：
self.num = NUM
DEF関数func1（自己）：
プリント（self.num）
FOOクラス（塩基）：
合格
OBJ = FOO（123）
obj.func1（）＃123ベースを実行すると、関数func1とする場合
＃2
クラスベース：
デフ__init __（自己、NUM）：
self.num = NUM
DEF関数func1（自己）：
プリント（self.num）
クラスはFoo（塩基）：
DEF関数func1（自己）：
印刷（ "Fooの関数func1。"、 self.num）
OBJ =フー（123）
obj.func1（）＃フー。func1の123运⾏的是Fooの中的関数func1
。3＃
クラスBase：
DEF __init __（自己、NUM）：
self.num NUM =
DEF関数func1（セルフ）：
印刷（self.num）
Fooクラス（ベース）：
DEFの関数func1（自己）：
。印刷（ "フー関数func1"、 self.num）
OBJ =フー（123）
obj.func1（）＃123のFoo関数func1を実行することはFoo関数func1のである。
＃4。
クラスベース：
DEF __init __（自己、NUM）：
self.num NUM =
DEF関数func1（セルフ）：
印刷（self.num）
self.func2（）
DEF関数func2（セルフ）：
印刷（ "Base.func2"）
Fooクラス（ベース）：
DEFの関数func2（セルフ）：
印刷（ "Foo.func2"）
OBJ =はFoo （123）
obj.func1（）ベース＃123 Foo.func2 func1のサブメニューにある関数func2クラスである
＃再び
クラスベース：
：DEF __（自己、NUM）__init
self.num = NUM
DEF関数func1（自己）：
プリント（self.num）
self.func2（）
DEF関数func2（自己）：
プリント（111、self.num）
Fooクラス（ベース）：
DEF関数func2（自己）：
プリント（222、self.num）
LST = [ベース（1）、ベース（2）、フー（3）]
LSTにおけるOBJのための：
obj.func2（）＃111 1 | 111 2 | 222 3
＃再び
クラスベース：
DEF __init __（自己、NUM）：
self.num NUM =
DEF関数func1（セルフ）：
印刷（self.num）
self.func2（）
DEF関数func2（セルフ）：
印刷（111、self.num）
クラスFOO（塩基）：
：DEFの関数func2（自己）
印刷（222、self.num）
LST = [ベース、ベース（2）、FOO（1）（3）]
LSTにおけるOBJのための：
obj.func1（）はペン＃さあ。良い数
IV。多重継承
クラスShenXian：＃妖精
DEF FEI（セルフ）：
印刷（ "不滅の⻜ます"）
クラスモンキー：＃猿の
DEFのchitao（セルフ）：
印刷（ "桃のサブメニューを食べるのが好きモンキーサブメニュー"）
クラス孫悟空（ShenXian、モンキー）：＃猿王は不滅ですが、また⼀サル
パス
SXZ =孫悟空（）＃猿王
sxz.chitao（）＃は、桃サブメニュー食べるようになる
sxz.feiを（）＃意志⻜
この時点で、猿王はサル⼀サブメニューが、また、⼀神である。モンキーは、これら2つのカテゴリーを受け継いこと。猿自然な色が救済のこれら2つのクラスを実行することができます。
多重継承を使用することも十分に理解。シンプルですが、多重継承は、⼀ので、問題がある。2⽗クラスは、同じ名前の救済時に登場したとき。
そして、それを行うにはどのように？そして、それはこのような問題⽗⼀クラス救済そのMRO（メソッド解決順序）問題を見つける方法になります。
Pythonの操作の異なるバージョンの使用は、MROを完了するために、異なるアルゴリズムであるため、Pythonで⼀これは非常に複雑な問題です。
私たちは、Pythonでのクラス（必要を継承）種を追加する必要があります：
python2x版では2つのクラスがあります。
⼀と呼ばれるクラシックのpython2.2がストレート書き込みするかの古典的な何で古典的なルートベースクラスクラスクラスを使用する前に⼀....
⼀と呼ばれる新しいカテゴリインチpython2.2は、新しいクラスの後に登場しました。新機能は、ルートクラスは、オブジェクトクラスの基本クラスです。
python3xバージョンは唯一のクラスである：
操作の使用のpython3は、新しいクラス、デフォルトでは、クラスオブジェクトの継承を継承しない基本クラスならば。
多重継承はクラシック4.1です
そこにはクラシックでのpython3ではありません。しかし、古典的なクラスMRO'dが良い⼀学校を学ぶ。これは、⼀ツリートラバーサル⼀最も簡単な例一種ですが。
Pythonで継承階層では、クラスやクラス階層図⼀、コードのツリー構造に入れることができます。
クラスA：
パス
クラスB（A）：
パス・
クラスC（A）：
パス・
クラスD（B、C）：
パス・
クラスE：
パス
クラスF（D、E）：
パス・
クラスG（F、D）：
パス・
クラスH：
域
クラスはFoo（H、G）：
合格
サンプルコード
MROは、この図面に対処することができます。
継承図は。どのようにそれを見つける⾏に？⼀原則を覚えています。古典的なカテゴリで深さ優先探索⽅ケースを使用して記録されている。深さ、最初は何ですか。
⼀道は再び当時終わりに近づいていると。次のいずれかを記録するために探してください。
矢印や線が黒とラインテーブルに表示。各円は、卵のアドレスを送信する準備ができている図。それはあなたの最も下のコネクタ⾯Rに送信するために右に卵を送信するために指示して左にする必要があります。次に、どのようにそれを送信するために？
図に示すように、確かに送信するための順123456に。この順序は深さ優先探索と呼ばれていること。⽽それは142356ですか？これがワイドの-最初トラバーサルと呼ばれている。わかりました。
あまりにも多くの深さ優先。だから、はどのように？非常にシンプルなMROは何ですか？それ⾯上の地図を見つけることを覚えておくこと。左から右にスクラッチ。⼀道が頭や背中を行ってきました。
続行⼀道は頭を行ってきました。MROアルゴリズムは、古典的なクラスです。
4.2.1 MROシーケンス
MROは、クラスはそれが計算され作成されたとき、順序付けられたリストのLです。
一般式は次のとおりです。
MRO（チャイルド（BASE1、BASE2））= [子供] +マージ（BASE1のMRO（）、MRO（BASE2がルックアップされた）、[BASE1、BASE2のがルックアップされる]）
（子供BASE1、BASE2から継承された場合）
クラスMRO：Foo-> H - > G - > F - > E - > D - > B - > Aは、 - > C.あなたはそれを得ましたか。
継承する基底クラスの場合：クラスB（A）
時系列Bは、MROあります
MRO（B）= MRO（B（A）） = [B] +マージ（MRO（A）+ [A]） = [B] +マージ（[A] + [A]） = [B、A]
もし基底クラスの複数の承継：クラスB（A1、A2、 A3 ...）
この時系列B MRO
mro(B) = mro( B(A1, A2, A3 …) ) = [B] + merge( mro(A1), mro(A2), mro(A3) ..., [A1, A2, A3] ) = ...
计算结果为列表，列表中至少有一个元素即类自己，如上述示例[A1,A2,A3]。merge操作是C3算法的核心。
4.2.2. 表头和表尾
表头：
列表的第一个元素
表尾：
列表中表头以外的元素集合（可以为空）
示例
列表：[A, B, C]
表头是A，表尾是B和C
4.2.3. 列表之间的+操作
+操作：
[A] + [B] = [A, B]
（以下的计算中默认省略）
---------------------
merge操作示例：
如计算merge( [E,O], [C,E,F,O], [C] )
有三个列表 ： ① ② ③
merge不为空，取出第一个列表列表①的表头E，进行判断
各个列表的表尾分别是[O], [E,F,O]，E在这些表尾的集合中，因而跳过当前当前列表
取出列表②的表头C，进行判断
C不在各个列表的集合中，因而将C拿出到merge外，并从所有表头删除
merge( [E,O], [C,E,F,O], [C]) = [C] + merge( [E,O], [E,F,O] )
进行下一次新的merge操作 ......
---------------------
计算mro(A)方式：
mro(A) = mro( A(B,C) )
原式= [A] + merge( mro(B),mro(C),[B,C] )
mro(B) = mro( B(D,E) )
= [B] + merge( mro(D), mro(E), [D,E] ) # 多继承
= [B] + merge( [D,O] , [E,O] , [D,E] ) # 单继承mro(D(O))=[D,O]
= [B,D] + merge( [O] , [E,O] , [E] ) # 拿出并删除D
= [B,D,E] + merge([O] , [O])
= [B,D,E,O]
mro(C) = mro( C(E,F) )
= [C] + merge( mro(E), mro(F), [E,F] )
= [C] + merge( [E,O] , [F,O] , [E,F] )
= [C,E] + merge( [O] , [F,O] , [F] ) # 跳过O，拿出并删除
= [C,E,F] + merge([O] , [O])
= [C,E,F,O]
原式= [A] + merge( [B,D,E,O], [C,E,F,O], [B,C])
= [A,B] + merge( [D,E,O], [C,E,F,O], [C])
= [A,B,D] + merge( [E,O], [C,E,F,O], [C]) # 跳过E
= [A,B,D,C] + merge([E,O], [E,F,O])
= [A,B,D,C,E] + merge([O], [F,O]) # 跳过O
= [A,B,D,C,E,F] + merge([O], [O])
= [A,B,D,C,E,F,O]
---------------------
结果OK. 那既然python提供了. 为什么我们还要如此⿇烦的计算MRO呢? 因为笔
试.......你在笔试的时候, 是没有电脑的. 所以这个算法要知道. 并且简单的计算要会. 真是项⽬
开发的时候很少有⼈这么去写代码.
这个说完了. 那C3到底怎么看更容易呢? 其实很简单. C3是把我们多个类产⽣的共同继
承留到最后去找. 所以. 我们也可以从图上来看到相关的规律. 这个要⼤家⾃⼰多写多画图就
能感觉到了. 但是如果没有所谓的共同继承关系. 那⼏乎就当成是深度遍历就可以了