今日の内容：
1.多重継承を開く正しい方法：ミックスインメカニズム
2.サブクラスから派生した新しいメソッドで親クラスの関数を再利用する
方法方法1：名前付き姓が特定のクラスの下で関数を呼び出す= "継承関係に依存しない
方法2：super（）は、親クラスが提供するメソッドをそれ自体に呼び出します= "継承関係に厳密に依存
3.ポリモーフィズムとダックタイプ
4.バインディングメソッドと非バインディングメソッド
クラスメソッド
静的メソッド
5.組み込み関数
mixinsメカニズム
＃多重継承を開く正しい方法：ミックスインメカニズム
＃ミックスインメカニズムのコア：多重継承のコンテキストで多重継承の可読性を可能な限り向上させることです＃ps
：多重継承で人々の思考習慣を満足させる=「とは」どの
クラスの車両：
パス
クラスFlyableMixin：
def fly（self）：
pass
クラスCivilAircraft（FlyableMixin、Vehicle）：＃民間航空航空機
パス
クラスヘリコプター（FlyableMixin、Vehicle）：＃ヘリコプター
パス
クラスCar（Vehicle）：＃車は飛行しませんが、上記の継承関係に従って、車は
パスを飛行することもできます
import socketserver
＃追加：通常、ミックスイン結果クラスは左側に配置されます
02
サブクラスから派生した新しいメソッドで親クラスの関数を再利用する方法＃サブクラスから派生した新しいメソッドで親クラスの関数を再利用する方法
＃方法1：名前で特定のクラスの関数を呼び出す=>継承に依存しない関係
＃クラスOldboyPeople：
＃DEF __init __（自己、名前、年齢、性別）：
＃self.name名=
＃=年齢self.ageの
＃セックスself.sex =
＃
＃DEF F1（自己）：＃
印刷（「％S挨拶「％self.name） ＃
＃
＃
クラスの先生（OldboyPeople）：
DEF＃__init __（自己、名前、年齢、性別、レベル、給与）：
＃OldboyPeople .__のinit __（自己、名前、年齢、性別）
＃1
＃セルフ.level = level
＃self.salary = salary
＃＃
tea_obj = Teacher（ 'egon'、18、 'male'、
10,3000 ）＃print（tea_obj .__ dict__）
＃メソッド2：super（）は、親クラスによって提供されるメソッドをそれ自体に
呼び出す= "strict dependency inheritance" ＃super（）を呼び出すと、特別なオブジェクトが取得され、オブジェクトは、属性検索を開始したクラスのmroを参照して、現在のクラスに移動します。親クラスの属性を見つける
：＃クラスOldboyPeopleを
DEF＃__init __（自己、名前、年齢、性別）：
＃self.name名=
＃=年齢self.ageの
＃セックスself.sex =
＃
＃DEF F1（自己）：
＃印刷（ '％S挨拶' ％self.name） ＃
＃
＃
クラスの先生（OldboyPeople）：
＃DEF __init __（自己、名前、年齢、性別、レベル、給与）：
の##スーパー（教師、セルフ）.__のinit __（名、年齢、性別）
＃スーパー（）.__のinit __（名前、年齢、性別）＃メソッドの呼び出しで自動的に入ってくるオブジェクト
＃の
＃のself.levelレベル=
＃= self.salary給料
＃
##印刷（Teacher.mro（ ））
＃tea_obj = Teacher（ 'egon'、18、 'male'、
10,3000 ）＃print（tea_obj .__ dict__）
＃スーパー（）案例
＃クラスA：
試験DEF＃（自己）：
＃プリント（ 'からA'）
。＃スーパー（）試験（）
＃1
＃クラスB：
試験（自己）DEF＃：
Bから＃プリント（ ' 「）
＃1
＃クラスC（A、B）：
＃通過
＃
＃
＃OBJ = C（）
＃obj.test（）
＃1
＃プリント（C.mro（））
クラスA：
def test（self）：
print（ 'from A'）
super（）。test1（）
クラスB：
def test（self）：
print（ 'from B'）
クラスC（A、B）：
def test1（self）：
print（ 'from C'）
obj = C（）
obj.test（）
print（C.mro（））
3、多型と鴨の種類
、同じことのいくつかの形式があります。どのような多型＃1、
＃クラスの動物
＃パス
＃
＃クラスの人々 （動物）：
＃パス
＃
＃クラス・ドッグ（動物）：
＃パス
＃
＃クラス豚は、 （動物）：
＃パス
＃2.ポリモーフィズムがあるべき理由= "ポリモーフィズムはどのような特性をもたらすか、ポリモーフィズム
＃ポリモーフィズムとは、オブジェクトの特定のタイプを考慮せずにオブジェクトを使用することを指します
＃クラス動物：＃統合すべてのサブクラスのメソッドの
＃は、DEF（自己）と言う：
＃印刷（ '基本的な可聴周波数動物...'、エンド= ''） ＃
＃
ピープルクラス（動物）：
＃DEF（自己）と言う：
＃スーパー（） ... SAY（）
＃印刷（ '訓練を受け、訓練を受け、訓練を受け、訓練を受け、訓練を受け、訓練を受け、訓練を受けた、'） ＃
＃
クラス・ドッグ（動物）：
＃DEF（セルフ）は言う：
。＃スーパー（））（と言う
＃印刷（ '樹皮王'） ＃＃
豚のクラス（動物）：
＃DEF（自己）と言う：
＃スーパー（）と言う（）
＃印刷（ 'ハムハム'） ＃
＃
＃
人々 OBJ1 =（）
＃= obj2の犬（）
＃= OBJ3豚（）
＃＃
obj1.say（）
＃obj2.say（）
＃obj3.say（）
＃着信動物対象を受信するために統一されたインタフェースを定義
＃DEF animal_say（動物）：
＃animal.say（）
＃
＃animal_say（OBJ1）
＃animal_say（OBJ2）
＃animal_say（OBJ3）
＃印刷（ 'こんにちは'だけ.__ __（））
＃プリント（[1,2,3] .__のみ__（））
＃プリント（{ 'と' 1 'B'：2}のみ.__ __（））
＃
＃DEF my_len（val）：
＃valを返す.__のみ__（）
＃print（my_len（ 'hello'））
＃print（my_len（[1,2,3]））
＃print（my_len（{'a'：1、 'b'：2}））
＃len（ 'hello'）
＃len（[1,2,3]）
＃len（{'a'：1、 'b'：2}）
＃pythonの推崇的是鸭子类型
＃クラスのCPU：
＃DEF（自己を）読み：
＃印刷（ 'CPUの読み取り'）
＃
＃defの書き込み（自己）：
＃印刷（ 'CPU書き込み'） ＃
＃
クラスMemの：
＃defを読みます（自己）：＃
印刷（ 'MEMが読ん'）
＃
＃defの書き込み（自己）：
＃印刷（ 'MEM書き込み'） ＃
＃
＃
クラスtxtが：
＃はDEF（自己を）読み：
＃印刷（ 'TXT読み込み'）
＃
＃DEFライト（自己）：
（'ライトTXT'）＃印刷
＃
＃
＃OBJ1 = CPU（）
＃OBJ2 = MEM（）
＃OBJ3 = txtが（）
＃
＃obj1.read（）
＃obj1.write（） ＃＃
obj2.read（）
＃obj2.write（）
＃
＃obj3.read（）
＃obj3.write（）
＃理解：
abcのインポート
クラス動物（メタクラス= abc.ABCMeta）：＃すべてのサブクラスの標準を統一
@ abc.abstractmethod
def say（self）：
pass
＃obj = Animal（）＃抽象クラス自体をインスタンス化できません
クラスPeople（Animal）：
def say（self）：
pass
クラスDog（Animal）：
def say（self）：
pass
クラスPig（Animal）：
def say（self）：
pass
＃＃
obj1 = People（）
＃obj2 = Dog（）
＃obj3 = Pig（）
4.バインディングメソッドと非バインディングメソッド
classmethod
staticmethod
#One：バインディングメソッド：特別なことは、呼び出し元自体が最初のパラメーターとして自動的に渡されること
です。1。オブジェクトへのバインディングの方法：呼び出し元はオブジェクトであり、オブジェクトは自動的に
＃2で渡されます。メソッドクラス：発信者クラス、クラスが自動的に渡されます
＃インポート設定を
＃
＃クラスのMySQL：
＃DEF __init __（自己、IP、ポート）：
＃self.ip = IP
＃self.portポート=
＃
＃DEF FUNC（セルフ）：
＃印刷（ '％S：％S' ％（self.ip、self.port）） ＃
＃＃
以下の機能@classmethodクラスメソッドに装飾されたバインド
＃のDEFのfrom_conf（CLS）：
＃印刷（CLS）
＃のCLSのリターン（settings.IP、settings.PORT）
＃
## = MysqlのOBJ1（ '1.1.1.1'、3306）
＃
＃= obj2がMysql.from_conf（）
＃印刷（obj2の.__ dict__にマジック）
＃2：非バインドメソッド-"静的メソッド：
＃誰にもバインドされない：呼び出し元は、自動パラメーター受け渡しの影響なしにクラスまたはオブジェクトにすることができます
クラスMysql：
def __init __（self、ip、port）：
self.nid = self.create_id（）
self.ip = ip
self.port = port
@staticmethod＃次の関数を静的メソッド
def create_id（）として装飾します。import
uuid
return uuid.uuid4（）
@classmethod
def f1（cls）：
パス
def f2（self）：
pass
obj1 = Mysql（ '1.1.1.1'、3306）
＃print
（Mysql.create_id）＃print（obj1.create_id）
＃Mysql.create_id（1,2,3）
＃obj1.create_id（4,5,6）
print（Mysql.create_id）
print（Mysql.f1）
print（obj1.f2）
5.組み込み関数
＃print（abs（-1））
＃print（all（[1、 'aaa'、 '1']））
＃print（all（[]））
＃print（any（[0、None、1]））
＃print（any（[]））
＃print（bin（11））
＃print（oct（11））
＃print（hex（11））
＃print（bool（ ''））
＃def func（）：
＃pass
＃class Foo：
＃pass
＃print（callable（Foo））＃方
＃印刷（chr（65））
＃印刷（単語（ 'A'））
＃
不变集集＃s = frozenset（{1,2,3}）
＃ハッシュ（不変タイプ）
＃print（round（1.5））
＃print（round（1.4））
＃10 ** 2％3
＃print（pow（10,2,3））
＃s = slice（1,4,2）
＃l1 = ['a'、 'b'、 'c'、 'd'、 'E']
＃L2 = [ 'AAA'、 'BBB'、 'CCC'、 'DDD'、444] ＃
＃
プリント（L1 [1：4：2]）＃L1 [S]
＃プリント（L2 [1 ：4：2]）＃l2 [s]
＃=================》マスター
＃v1 = 'hello'
＃v2 = [111,222,333,444,5555,6666]＃res
= zip（v1、v2）＃print
（list（list（ res））
＃=================》マスター
＃印刷（divmod（10000,33））
＃=================》 Master
＃class Foo：
＃pass
＃obj = Foo（）
＃obj.xxx = 1111
＃print（dir（obj））＃obj。の属性
＃=================》掌握＃for
i、v in enumerate（['a'、 'b'、 'c']）：
＃print（i、v）
＃=================》 Master
＃res = eval（ '{"a"：1}'）＃文字列内の式を実行
＃print（res、type（ res））
＃=================》 Master
＃class Foo：
＃pass
＃obj = Foo（）
＃print（isinstance（obj、Foo））
＃print（isinstance（[]、 list））＃タイプの判断が推奨されますisinstance
＃print（type（[]）is list）＃推奨されません
＃=================》マスター＃import
'time'＃エラー
時間= __ import __（ 'time'）
time.sleep（3）
来週＃：反射
＃SETATTR
＃GETATTR
＃delattr
＃はhasattr