ディレクトリ
はじめに：
Pythonのオブジェクト指向の三つの特徴：継承、カプセル化、ポリモーフィズム。
1.パッケージ：パッケージ⼀機能コードブロックを固定⼀するコードパッケージ内のオブジェクトへのデータの多くは、機能、オブジェクト、特定の状況に属しているパッケージにパッケージ化されたモジュールは、あなたのような特定の分析を考えた....非常に⽜B⼀機能を書いた。これはまた、被験体思想に⾯に包装ものと呼ぶことができる。⽆一見何および使用を格納⼀⼀するシステムからのコンテンツのより重要⼀組み合わせです。これはパッケージです。
2.継承：サブメニュークラスを自動的に持つことができる⽗私有財産に加えて、他のすべてのコンテンツと同様に、ホワイトは言った、とサブメニューが簡単に東⻄父が、私の友人の子供の使用に到達することができ、⼀⼀一つのことが明確でなければならない認識して与えられました...まず、父親は、子供のサブメニューの到達後。順序は混沌とすることはできません、Pythonで実装の継承は非常に簡単です。文のクラスでは、⾯クラス名の後の括弧のために1時間を追加し、あなたが相続を完了することができます。だから何を使用することができますそれを継承する？簡単な。両方のクラスは、コードレベルから、同じ機能や特徴を持っているとき⾯ビューのポイントは継承された使用抽出⼀⽗クラスの形で撮影することができ、このクラスは⽗二つのクラスの同じ部分を書きます。 2つのクラスは、このクラスを拡張し、その上に撮影された。この書き込みの利点は、我々は機能の重複の多くを回避し、コードを書くことができるということです。あなたは例意味解析から行く場合。xの出現のコンテキストがある場合ははるかに簡単になります⼀種類Y。この場合、Yは、概念の一般化の⼀一種である。X Yのより具体的な。それは猫が動物猫はアクティブ動物、動物を継承⼀であるようなサブメニューのX Yの種類、次にである。猫も活性です。その後、猫は動物の作製にあり 「アクション」は、このプロパティを設定します。別の例として、呼ばれる白い細かい骨⼀モンスターです。モンスターの日⽣が⼀比較的貧しい機能「食べるためにフェイス、」白い細かい骨がする方法を知っている⽣うち⼀「顔を食べる。」これをとき白い細かい骨がモンスターを継承しました。
3.多型：我々だけではない、特に例えば、我々は⼀変数A = 10を作成して使用するには白いストレートを⼀ので、オブジェクト、Pythonでこの様々な形の⼀同じで、実際に説明するのは非常に簡単です....我々はこの時点でaは整数型であることを知っているが、我々はプログラムA =「アレックス」、この時、文字列型に分離保証することができます。これは、我々はすべて知っているものです。しかし、私はあなたのことをお伝えしたいと思います。これは⼀変数は、様々な形態も可能で多型です。
パッケージ
パッケージは、定義によりパッケージの内容はどこか、通話内容をどこかにカプセル化された後に行くされています。
パッケージのオブジェクト指向特性を使用する場合したがって、それは必要です。
- どこかへのコンテンツのカプセル化
- コールコンテンツがどこからカプセル化されています
最初のステップ：どこかにパッケージの内容
OBJ1 =フー（「wupeiqi」、18）が実行されたとき、それは、自己等しいOBJ1自己パラメータの形態であります
=フー（ 'アレックス'、78）OBJ2行う、自己等しいOBJ2
だから、実際には、コンテンツオブジェクトobj1とobj2の中にカプセル化され、各オブジェクトは、記憶するには、図のように名前と年齢特性を有します。
ステップ2：どこかからパッケージの内容を呼び出します
あなたはコンテンツがパッケージ化されて呼び出すと、2つのケースがあります。
- オブジェクトを介して直接呼び出し
- 自己を通じて間接呼び出し
図1に示すように、コンテンツを直接呼び出すオブジェクトによってカプセル化され
オブジェクト属性名：図は、オブジェクトOBJ1 OBJ2を示し、メモリモードに格納され、格納されたコンテンツのフォーマットによればこれに包装コールであってもよいです
class` `Foo:` ` ``def` `__init__(``self``, name, age):`` ``self``.name ``=` `name`` ``self``.age ``=` `age` `obj1 ``=` `Foo(``'wupeiqi'``, ``18``)``print` `obj1.name ``# 直接调用obj1对象的name属性``print` `obj1.age ``# 直接调用obj1对象的age属性` `obj2 ``=` `Foo(``'alex'``, ``73``)``print` `obj2.name ``# 直接调用obj2对象的name属性``print` `obj2.age ``# 直接调用obj2对象的age属性2、自己パッケージ化されたコンテンツによって間接呼び出し
クラスのメソッドを実行すると、自己パッケージ化されたコンテンツを通じて間接呼び出しを必要と
class` `Foo:`` ` ` ``def` `__init__(``self``, name, age):`` ``self``.name ``=` `name`` ``self``.age ``=` `age`` ` ` ``def` `detail(``self``):`` ``print` `self``.name`` ``print` `self``.age`` ` `obj1 ``=` `Foo(``'wupeiqi'``, ``18``)``obj1.detail() ``# Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18`` ` `obj2 ``=` `Foo(``'alex'``, ``73``)``obj2.detail() ``# Python默认会将obj2传给self参数，即：obj1.detail(obj2)，所以，此时方法内部的 self ＝ obj2，即：self.name 是 alex ； self.age 是 78要約すると、オブジェクト指向のパッケージを、実際には、コンテンツオブジェクトのコンストラクタカプセル化を使用することであり、そのオブジェクトを介して間接的に又は直接的に自己取得したコンテンツをパッケージ化。
つ以上の状態
多型、同じオブジェクト、様々な形態。デフォルトのPythonのサポート多型。
ポリモーフィズム
# 在java或者c#定义变量或者给函数传值必须定义数据类型，否则就报错。
def func(int a):
print('a必须是数字')
# 而类似于python这种弱定义类语言,a可以是任意形态（str,int,object等等）。
def func(a):
print('a是什么都可以')
# 再比如：
class F1:
pass
class S1(F1):
def show(self):
print 'S1.show'
class S2(F1):
def show(self):
print 'S2.show'
# 由于在Java或C#中定义函数参数时，必须指定参数的类型
# 为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类
# 而实际传入的参数是：S1对象和S2对象
def Func(F1 obj):
"""Func函数需要接收一个F1类型或者F1子类的类型"""
print obj.show()
s1_obj = S1()
Func(s1_obj) # 在Func函数中传入S1类的对象 s1_obj，执行 S1 的show方法，结果：S1.show
s2_obj = S2()
Func(s2_obj) # 在Func函数中传入Ss类的对象 ss_obj，执行 Ss 的show方法，结果：S2.show
Python伪代码实现Java或C # 的多态アヒルタイプ
python中有一句谚语说的好，你看起来像鸭子，那么你就是鸭子。
对于代码上的解释其实很简答：
class A:
def f1(self):
print('in A f1')
def f2(self):
print('in A f2')
class B:
def f1(self):
print('in A f1')
def f2(self):
print('in A f2')
obj = A()
obj.f1()
obj.f2()
obj2 = B()
obj2.f1()
obj2.f2()
# A 和 B两个类完全没有耦合性，但是在某种意义上他们却统一了一个标准。
# 对相同的功能设定了相同的名字，这样方便开发，这两个方法就可以互成为鸭子类型。
# 这样的例子比比皆是：str tuple list 都有 index方法，这就是统一了规范。
# str bytes 等等 这就是互称为鸭子类型。制約の三種類
そのため、特に第一に、あなたが知っている必要があります。制約はクラスです。
例と話します。
次のように自分のウェブサイトの完全な決済機能させるために会社暁明、暁明は、二つのカテゴリーに書きました：
class QQpay:
def pay(self,money):
print('使用qq支付%s元' % money)
class Alipay:
def pay(self,money):
print('使用阿里支付%s元' % money)
a = Alipay()
a.pay(100)
b = QQpay()
b.pay(200)上司は彼が整流、支払方法の統一を見てみましょうと言わしかし、この場所は上記を記述することは容易ではない、それは無理がある、暁明は残業を終えて始めました：
class QQpay:
def pay(self,money):
print('使用qq支付%s元' % money)
class Alipay:
def pay(self,money):
print('使用阿里支付%s元' % money)
def pay(obj,money): # 这个函数就是统一支付规则，这个叫做： 归一化设计。
obj.pay(money)
a = Alipay()
b = QQpay()
pay(a,100)
pay(b,200)暁明は最終的に大きなプロジェクトを受け取った、無味会社の結果は、チュンはボブの仕事を引き継いだ野生のプログラマーを募集インタフェースの半分を書いて、上司はチョンスケジュールされたタスクを与えたので、彼は、マイクロチャネルの決済機能を書きました：
class QQpay:
def pay(self,money):
print('使用qq支付%s元' % money)
class Alipay:
def pay(self,money):
print('使用阿里支付%s元' % money)
class Wechatpay: # 野生程序员一般不会看别人怎么写，自己才是最好，结果......
def fuqian(self,money):
print('使用微信支付%s元' % money)
def pay(obj,money):
obj.pay(money)
a = Alipay()
b = QQpay()
pay(a,100)
pay(b,200)
c = Wechatpay()
c.fuqian(300)チュン結果、罰、および整流は、その後、コロンビアの春は、懸命に働いて、あなたのpython関連情報を学ぶことを教える白を見て、再ソートコード：
class Payment: """ 此类什么都不做，就是制定一个标准，谁继承我，必须定义我里面的方法。 """
def pay(self,money):pass
class QQpay(Payment):
def pay(self,money):
print('使用qq支付%s元' % money)
class Alipay(Payment):
def pay(self,money):
print('使用阿里支付%s元' % money)
class Wechatpay(Payment):
def fuqian(self,money):
print('使用微信支付%s元' % money)
def pay(obj,money):
obj.pay(money)
a = Alipay()
b = QQpay()
pay(a,100)
pay(b,200)
c = Wechatpay()
c.fuqian(300)再びプログラマの野生のは、彼は、他の支払い方法を見ていないあなたは意味をなさないメソッドを継承するクラスを定義したい理由がわからないので、彼は独自の道を行くならばしかし、これは、問題になります。
class Payment:
""" 此类什么都不做，就是制定一个标准，谁继承我，必须定义我里面的方法。
"""
def pay(self,money):pass
class QQpay(Payment):
def pay(self,money):
print('使用qq支付%s元' % money)
class Alipay(Payment):
def pay(self,money):
print('使用阿里支付%s元' % money)
class Wechatpay(Payment):
def fuqian(self,money):
print('使用微信支付%s元' % money)
def pay(obj,money):
obj.pay(money)
a = Alipay()
b = QQpay()
pay(a,100)
pay(b,200)
c = Wechatpay()
c.fuqian(300)だから、今回は二つの方法でクラスのクラス制約、制約を使用する必要があります。
その後、\ 1の抽出⽗クラスとは⽗クラスで救済を定義した。この救済で乾燥して何もして。⼀それに例外をスローする。このようなクラスは、救済をオーバーライドする必要がありますすべてのサブメニューを。それ以外の場合は。訪問の時はエラーになります。
\ 2.メタクラスは抽象救済がメタクラス⼀に記載されている⽗クラスを説明した。このようなクラスは、サブメニューがカメラのための抽象メソッドの特定の実装を与えるだろう。制約にも効果を果たしている可能性があります。
解決する最初の方法で最初に：
class Payment:
"""
此类什么都不做，就是制定一个标准，谁继承我，必须定义我里面的方法。
"""
def pay(self,money):
raise Exception("你没有实现pay方法")
class QQpay(Payment):
def pay(self,money):
print('使用qq支付%s元' % money)
class Alipay(Payment):
def pay(self,money):
print('使用阿里支付%s元' % money)
class Wechatpay(Payment):
def fuqian(self,money):
print('使用微信支付%s元' % money)
def pay(obj,money):
obj.pay(money)
a = Alipay()
b = QQpay()
c = Wechatpay()
pay(a,100)
pay(b,200)
pay(c,300)第二の方法：抽象クラスの治療の概念を導入します。
from abc import ABCMeta,abstractmethod
class Payment(metaclass=ABCMeta): # 抽象类 接口类 规范和约束 metaclass指定的是一个元类
@abstractmethod
def pay(self):pass # 抽象方法
class Alipay(Payment):
def pay(self,money):
print('使用支付宝支付了%s元'%money)
class QQpay(Payment):
def pay(self,money):
print('使用qq支付了%s元'%money)
class Wechatpay(Payment):
# def pay(self,money):
# print('使用微信支付了%s元'%money)
def recharge(self):pass
def pay(a,money):
a.pay(money)
a = Alipay()
a.pay(100)
pay(a,100) # 归一化设计：不管是哪一个类的对象，都调用同一个函数去完成相似的功能
q = QQpay()
q.pay(100)
pay(q,100)
w = Wechatpay()
pay(w,100) # 到用的时候才会报错
# 抽象类和接口类做的事情 ：建立规范
# 制定一个类的metaclass是ABCMeta，
# 那么这个类就变成了一个抽象类(接口类)
# 这个类的主要功能就是建立一个规范概要：⾏制約のサブメニュークラスにサブメニュークラスの制約実際に⽗クラスはPythonのシャッターモードと救済に2つの制約がありますxxxの救済を記述する必要があります...。
1.抽象クラスと抽象的救済、ソーステキストが⽅JavaやC＃であるから。周波数を使用するので、少しです
2.⽅珍しいケースを投げる。そしてNotImplementErrorをスローするようにしようとするフェイスを使用した。 比較的明確なエラー。（推奨）
四。スーパー（）の深い理解
承継の順序で超厳密に従って、クラスです！！！
他の方法は、スーパークラスであり
class A:
def f1(self):
print('in A f1')
def f2(self):
print('in A f2')
class Foo(A):
def f1(self):
super().f2()
print('in A Foo')
obj = Foo()
obj.f1()厳密にクラスのMROの順序に従ってスーパー（）
class A:
def f1(self):
print('in A')
class Foo(A):
def f1(self):
super().f1()
print('in Foo')
class Bar(A):
def f1(self):
print('in Bar')
class Info(Foo,Bar):
def f1(self):
super().f1()
print('in Info f1')
obj = Info()
obj.f1()
'''
in Bar
in Foo
in Info f1
'''
print(Info.mro()) # [<class '__main__.Info'>, <class '__main__.Foo'>, <class '__main__.Bar'>, <class '__main__.A'>, <class 'object'>]class A:
def f1(self):
print('in A')
class Foo(A):
def f1(self):
super().f1()
print('in Foo')
class Bar(A):
def f1(self):
print('in Bar')
class Info(Foo,Bar):
def f1(self):
super(Foo,self).f1()
print('in Info f1')
obj = Info()
obj.f1()