グイド・ヴァンロッサム（グイド・ヴァンロッサム）のPythonの創設者。クリスマス1989の間に、アムステルダムのグイド・ヴァンロッサム時間を渡すためには、ABCなどの言語を新しいスクリプトインタプリタの開発を決定しました継承.Pythonの一つは、純粋なフリーソフトウェアで、ソースコードやインタプリタは、Python :. Pythonの提唱者のGPL（GNU一般公衆利用許諾契約書）プロトコル哲学従っCPythonと：、「エレガント」「クリア」、「シンプル」を、Pythonはありますこの問題を解決するための最も単純で最もエレガントで最も明白な方法。
オブジェクト指向プログラミングは、思考の新しい方法を提供し、ソフトウェア設計の焦点は、プログラムの論理的な流れが、オブジェクト指向プログラミングの考えを使用してソフトウェアまたはプログラムオブジェクトとオブジェクト間の関係は、もはやあり、ソフトウェアアーキテクチャ、ソフトウェアの保守・モジュール、およびフレームワークやコンポーネントの簡単に再利用を設計しやすくなり。
Pythonのサポートプロセス指向、オブジェクト指向、関数型プログラミングおよび他のプログラミングパラダイム、および任意のプログラミングパラダイムを使用するように私たちを強制するものではありません、私たちは、小さなプログラムの作成、基本的にはない問題で使用される任意の手続き型プログラミングの手順を書くことができますしかし、中規模および大規模なプロジェクトのために、オブジェクト指向は、私たちに多くの利点を提供します。次は、オブジェクト指向と組み合わされる説明するために、Pythonの構文とオブジェクト指向プログラミングの基本的な概念を提供しています。
はじめにするために、オブジェクト指向プログラミング
オブジェクト指向は、OOP英文全称(Object-Oriented Programming)あるプログラミングのアイデアは、オブジェクト指向技術は、ソフトウェアの設計とオブジェクト指向プログラミングの分野における技術開発の主流となっている高効率のプログラミングモードがされ、「クラス」と「オブジェクト」を達成するため、オブジェクト指向プログラミングを使用します実際には、「クラス」と「オブジェクト」クラスの使用は、テンプレートはテンプレートは、複数のメソッド（関数）を含むことができる方法で様々な機能を実現するためには、オブジェクトは、例によって作成されたテンプレートの例でありますこの方法は、オブジェクトクラスで実行することができ、各オブジェクトは、同じ方法を有するが、それぞれのデータが異なっていてもよいです。
オブジェクト指向の設計では、プログラマが記述と前記各オブジェクトのデータは、クラスに含まれる内部構造の複雑さを隠し、一部のオブジェクトの抽象であり、目的を達成することができる新しいタイプ、クラス変数を作成することができると二つの部分の機能は、クラス変数と呼ばれる数据成员機能は、クラスと呼ばれ、成员函数それは抽象クラスで客観的なものであり、オブジェクトはエンティティ・クラスがインスタンス化されています、。
簡単に言えば、「オブジェクト指向」はプログラミングパラダイムであり、プログラミングパラダイムは、プログラミングの異なるプログラミング機能に要約され、ことわざにも、すべての道はローマにつながる、また、我々は最終的に到達するためにさまざまな方法を使用できることを言いました目的、しかし、高速で安全かつ効果的な比較するためのいくつかの方法、いくつかの方法は非効率的で不十分な結果である。同様に、プログラミングだけでなく、問題を解決するが、問題を解決するためにさまざまな視点やアイデアの多様性を持つことができ、前者「パラダイム」に起因するいくつかの普遍的かつ効果的なプログラミングモード、一般的なプログラミングパラダイムは、次のとおりです。
●プロセス指向のプログラミング：OPP（プログラミング手順を指向）
●オブジェクト指向プログラミング：OOP（オブジェクト指向プログラミング）の
●関数指向プログラミング：FP（機能プログラミング）
オブジェクト指向プログラミングは、3つの目的があります：再利用性、柔軟性、拡張性、およびいくつかの主要な目的の機能します：
●パッケージ：そうコードモジュラーコードマスク実装の詳細、唯一の外部インタフェース、実装の詳細を隠す
●継承：同じコード書き込まの重複を避けるために、既存のクラスコードの再利用を拡張することによって
●多型：多型インターフェイスの再利用を達成するために、そのような異なるクラス間の柔軟な呼複数のことです
ここでは、我々はあなたが理解したい場合は、自分自身のいくつかを学ぶためのマニュアルを参照して、すべてを行うことができない、ここに個人的なメモである、オーバー導入の基本的なオブジェクト指向の役割、特性、アプリケーションのシナリオを持っているから、上記の抜粋の中で最もその後、我々はに焦点を当てる、書籍に焦点を当て封装,继承,多态コアオブジェクト指向の概念を説明するような。
オブジェクト指向 - >パッケージ
パッケージは、オブジェクト指向の主な機能、およびオブジェクトクラスの概念の主な特徴の一つである。簡単に言えば、論理的エンティティデータをカプセル化し、データを、部分データとメソッドを操作する方法は、それが外部に露出されているクラス、ブロックの個々実装の詳細は、加えて、内部オブジェクトで、いくつかのデータやメソッドがプライベートすることができ、これらの個人データやメソッドは、外の世界へのアクセスを許可されていません。このように、内部データのオブジェクトは別のレベルを提供します保護。
抽象クラスとしてパッケージ客観的なものであり、クラスがそのデータとメソッドは、信頼できない情報隠蔽の唯一の信頼できるクラスやオブジェクト操作を可能に置くことができ、カプセル化は、クラス内にカプセル化されたデータによって、一般的にパッケージ、オブジェクトまたは自己の取得、およびその他のオブジェクト指向言語と同様のことではなく、コンストラクタによってカプセル化されたデータのために、それは意味、私たちは一緒にいくつかの機能と同様の機能を、私たちの呼び出しやメンテナンスの利便性を記述します。
◆簡単なクラスパッケージ◆
Pythonでは、クラスはによって定義されclass关键字たクラス名に続いて、クラスに続いて、クラス名は通常、単語の先頭で、続いて大文字()小括号、あなたは括弧で書くことができます(要继承的类名称)ダウンクラスから継承したクラスを示し、どのようにすることができます2は父类(基类)、通常クラス、使用を継承する権利なしでobject类、これはすべてのクラスがクラスを継承究極である、あなたは、デフォルトがロードされ、書いていない、書き込むことはできません。
>>> import sys
>>> import os
>>>
>>> class lyshark(object):
... def __init__(self,name,age,sex):
... self.name = name
... self.age = age
... self.sex = sex
...
>>>
>>> temp=lyshark("lyshark","22","Man")
>>> print("姓名:%s 年龄:%s 性别:%s"%(temp.name,temp.age,temp.sex))
姓名:lyshark 年龄:22 性别:Manこれらは、によって作成されるlyshark上記に示したクラスが__init__()クラスがインスタンス化されると、プロセスは、自動的に実行される（それがメソッド呼び出した関数と呼ばれるクラスの形式の関数である、ではないが）、初期化処理（又は構成法）と呼ばれていますいくつかの初期化アクションは、私たちはここに書く__init__(self,name,age,sex)あなたには、いくつかの初期化作業を行うために割り当てられた役割を作成するとき、それはこれらのプロパティを設定与えることです。
パラメータ行く
selfワークフローはこれです。メモリ内の関数ポインタに相当する変数名lyshark向け●オープンスペース、
最初に実行されるクラスをインスタンス化する●は__init__()、自動的に内部変数にパラメータを転送した後に実行され
、自動的に実行●__init__()工法、メモリをスペースの場合、self.* = *同じ2つの変数データ
インスタンスと呼ばれ、または上記のコードを参照するためにオブジェクトを作成し、temp=lyshark()この文は、であるlyshark类ハンドル、区別するためのハンドルにプロパティおよびオブジェクトのメソッド：オブジェクトが作成されたときに3つの特徴領域を含む、インスタンス化異なるオブジェクトは、オブジェクトが作成されるとき、オブジェクトは、すなわち、クラス属性とオブジェクトが対応する方法のオブジェクト識別アドレス記憶空間、メンバ変数とメンバ関数を記憶空間を取得します。
◆◆パブリックプロパティを持つパッケージ
クラスのプロパティとメソッドの組成、クラス属性データパッケージ、クラスオブジェクトのメソッドが動作を有するが、以下の使用パブリックプロパティパッケージと、関数（インスタンスメソッド）および変数（クラス変数）によって一般的にクラスを前記しましたデータメンバは、クラスの外で見ることができ、我々が使用することができtemp.name="xxoo"、このデータメンバの値を変更する方法をし、再度印刷機能を呼び出し、データが変更されていたが、これは明らかに十分に安全ではないことが判明しました。
>>> import sys
>>> import os
# =====================以下内容是类的定义====================
>>> class lyshark():
... def __init__(self,name,age): #构造函数,初始化数据
... self.name = name #封装的数据成员
... self.age = age
...
... def my_print(self): #封装的成员函数
... print("我的名字是:%s 我的年龄是:%s"%(self.name,self.age))
...
# =========================================================
>>>
>>> temp=lyshark("wangrui","22") #类的实例化,将参数传入类中
>>> temp.my_print() #调用类中的指定方法,打印数据
我的名字是:wangrui 我的年龄是:22
>>>
>>> print(temp.name) #直接调用类中的数据成员
wangrui
# ===============改变数据成员,再次调用看看===================
>>> temp.name="xxoo"
>>> temp.my_print()
我的名字是:xxoo 我的年龄是:22
# =========================================================小さな要約：インスタンスは、実際にして、コメントを追加するための1パブリックプロパティまたは静的プロパティは、また、0.2クラスのインスタンスを介してパブリックプロパティを変更する例としてクラスの直接の直接アクセスを介して直接アクセスすることができます。それが取り出さ0.3他のインスタンスのパブリックプロパティの値に影響を与えないように、同じ属性のクラスメンバーのパブリックプロパティ名は、実際のパブリックプロパティは、影響を受けません。カテゴリ別のパブリックプロパティを変更し、それは確かに公共の変更になりますプロパティの元の値が、彼はすべてのインスタンスのクラスが影響を受けています。
◆私有財産パッケージの使用◆
上記の小さな例では、我々はまた、いくつかの欠陥を発見し、その後、スキル私有財産、私有財産と同じ属性のメンバーのパッケージを見てみましょう、された__init__方法で宣言しますが、プロパティ名は、二重下線である必要があり__开头、私有財産短い、特別な部材特性、サブクラス（方法メンバーまたはプライベートメソッド）によって内部継承可能で、直接外部にオブジェクトクラス、オブジェクト・インスタンスのインスタンス・オブジェクトまたはインスタンスを介してアクセスを許可しないだけでなく、文：私有属性只有类的内部可以调用。
>>> import os
>>> import sys
# =====================以下内容是类的定义====================
class lyshark():
name = "lyshark" #定义公有属性(类变量,可共享数据)
__age = 22 #定义私有属性(类变量)
def __init__(self): #定义构造函数,初始化数据
self.__like = "soccer" #定义私有实例属性(实例变量)
self.hobby = "xxoo" #定义公有实例属性
def my_print(self): #定义公有函数,外部可以调用
print("我的名字: %s"%self.name)
print("我的年龄: %s"%self.__age)
print("我的爱好: %s"%self.__like)
print("其他: %s"%self.hobby)
def __new_test(self): #定义私有函数,只能内部类调用
print("hello world")
def __del__(self): #定义析构函数,清理数据
self.__nobody = "end"
#print("函数执行结束,销毁无用的数据. %s"%self.__nobody)
# =================(公有/私有)方法的调用====================
>>> temp=lyshark() #实例化对象
>>> temp.my_print() #调用类中方法(公有方法)
我的名字: lyshark
我的年龄: 22
我的爱好: soccer
其他: xxoo
>>> temp.__new_test() #调用私有方法,则会报错
# =================(公有/私有)属性的调用====================
>>> print(lyshark.name) #调用公有属性则成功
lyshark
>>> print(lyshark.__age) #调用私有属性,则会报错
>>> print(lyshark.__like)
# =========================================================小概要：により、公有属性および私有属性データの比較、我々は明らかにそれらの間のギャップを見ることができる、それはこのつまるところ、プライベート変数は、クラスを介して直接アクセスすることはできません、2つのプライベート変数は、オブジェクトのインスタンス、3直接アクセスすることができません。プライベート変数は、メソッド0.4クラス変数のメンバーによってアクセス可能一般インスタンス変数は、現在のインスタンスに適用され、インスタンス化された二つの間のデータ共有のために使用することができます。
◆オブジェクトクラスのカプセル化◆
いくつかの頻繁に上記パッケージ、およびフォーマットを理解することがより困難にパッケージに加えて使用される、これは以下の通りである、それは次いで、オブジェクトが別のクラスにパラメータとしてクラスのインスタンスであることを意味します別のクラスでは、我々はデータメンバとメンバ関数は、クラスの友人を渡されるアクセスするために呼び出すことができます。
import os
import sys
class main(object):
def __init__(self,name,obj): #OBJ参数用来接收对象
self.name=name
self.obj=obj
class uuid(object):
def __init__(self,uid,age,sex):
self.uid=uid
self.age=age
self.sex=sex
temp=uuid(1001,22,"Man") #首先给UUID类初始化
lyshark=main("lyshark",temp) #将生成的TEMP对象传递给main
# =========================================================
>>> lyshark.name
'lyshark'
>>> lyshark.obj.uid #最后通过多级指针的方式访问数据
1001
>>> lyshark.obj.sex
'Man'
>>> lyshark.obj.age
22オブジェクト指向 - >継承
オブジェクト指向プログラミング（OOP）言語継承が能力を指し、それは既存のクラスのすべての機能を使用すると、元のクラスの場合にこれらの機能を拡張することなく、再び書くことができ、主要な機能は、「継承」であります。
継承は、あなたが使用したり、既存のクラスの動作を変更することを目指し、継承を通じて、新しいクラスを作成することができ、重要なオブジェクト指向機能の一つであり、元のクラスは親クラスまたはスーパークラスと呼ばれる、新しいクラスは、サブクラスと呼ばれたり、クラスを派生されます継承メカニズムは、コードを再利用することができる場合、この方法の本質を継承サブクラスのすべてのコピーの親クラスであり、Pythonは多重継承の内部に継承でき、継承を介して、親クラスの機能を得ることができ、継承、もし自分の（サブカテゴリー）を見つけるために、優先順位を与え、親クラスのメソッドを複製します。
◆◆基本クラスの通常の機能を継承
以下では、関係が継承することができ、基本的な例である第一のbase()基底クラスであり、expand()由来する派生クラスであり、base()派生列は機能を有していないが、我々はまだ到来を印刷するためのprintf（）関数を呼び出すことができるかのように、データは、それが基底クラスの関数が内部継承されて説明することができます。
import os
import sys
class base(): #这个类是基类
def __init__(self,name,age):
self.name = name
self.age = age
def printf(self):
print("姓名:%s 年龄:%s"%(self.name,self.age))
class expand(base): #新建类expand继承base基类的方法
pass
# =========================================================
>>> temp=expand("lyshark","22")
>>> temp.printf()
姓名:lyshark 年龄:22◆◆基底クラスのコンストラクタを継承
もちろん、我々はまた、親のコンストラクタを継承し、適切なサブカテゴリーに新しいプロパティフィールドを追加することができ、あなたが直接することができますsuper()と呼ばれる内部のサブクラスの親クラスで体の直接の機能に近づくとに結果を返します。呼び出し側。
：直接はコンストラクタ拡張し、新たなexpand()継承、サブクラスをbase()親クラスの基底クラスのコンストラクタとデータを印刷できるが、サブクラス属性。
import os
import sys
class base():
def __init__(self,name,age):
self.name = name
self.age = age
def printf(self):
print("姓名:%s 年龄:%s"%(self.name,self.age))
class expand(base):
def __init__(self,name,age):
super(expand,self).__init__(name,age) #推荐使用本功能实现继承
#base.__init__(self,name,age) #此处和上面实现的功能相等
def printf(self):
print("姓名:%s 年龄:%s"%(self.name,self.age))
# =========================================================
>>> temp=base("lyshark","22")
>>> temp.printf()
姓名:lyshark 年龄:22
>>> temp=expand("lyshark","22")
>>> temp.printf()
姓名:lyshark 年龄:22新しいフィールドの追加：親クラスbase()元のフィールドの書き換えをもとに、サブクラスは、expand()新しいフィールドを追加sexし、パラメータを渡すことができます。
import os
import sys
class base(): #定义的父类
def __init__(self,name,age):
self.name = name
self.age = age
def printf(self):
print("姓名:%s 年龄:%s"%(self.name,self.age))
class expand(base): #定义的子类
def __init__(self,name,age,sex):
super(expand,self).__init__(name,age) #继承父类的属性
self.sex = sex #新添加的一个属性
def printf(self):
print("姓名:%s 年龄:%s 性别:%s "%(self.name,self.age,self.sex))
# =========================================================
>>> temp=base("lyshark","22") #原始基类,没有第三个字段
>>> temp.printf()
姓名:lyshark 年龄:22
>>> temp=expand("lyshark","22","Man") #在不影响父类情况下,重写新的字段
>>> temp.printf()
姓名:lyshark 年龄:22 性别:Man 親クラスの機能（必須）から継承されます：あなたは、サブクラスでメソッド前記親クラスを使用したい場合は、以下の方法を使用して実施することができます。
import os
import sys
class base(object):
def printf(self):
print("================================")
print("执行函数....")
print("================================")
return 0
class expand(base):
def fun(self):
ret=super(expand,self).printf() #强制调用父类中的printf方法
return ret #将结果返回给调用者
# =========================================================
>>> temp=base()
>>> temp.printf() #调用基类的方法
================================
执行函数....
================================
>>> obj=expand() #在子类中调用基类方法
>>> ret=obj.fun() #将返回值付给ret并打印
>>> print(ret)
================================
执行函数....
================================
0◆マルチクラスの継承と多重継承◆
シンプル多重継承：ここでは、我々はその実行順序でコードを説明します簡単な多重継承を実装し、騒ぎ、下図を参照してください。
import os
import sys
class A:
def fun(self):
print("我是A类里面的函数")
class B:
def fun1(self):
print("我是B类里面的函数1")
def fun2(self):
print("我是B类里面的函数2")
class C(A,B):
def fun(self):
print("我是C类里面的函数")
# =========================================================
>>> temp=C()
>>> temp.fun() #默认调用C类,如果C里面有fun()函数则默认执行自身
我是C类里面的函数 #如果自身没有,才会去基类里面去找fun()函数的存在
>>> temp.fun1() #由于C类中没有这个方法,它会去B或A类里面去找
我是B类里面的函数1 #这也为我们重写函数提供了可能性,我们只需修改C类且名称相同即可实现重写複雑な多重継承：次は、他のソースでは、重要かつ困難であるネストされた新しいプログラムを開発する場合継承に属し、とても乾燥している、それはそれを行うには最善ではない、そして最終的にさえ自身無知の力。
import os
import sys
class A:
def bar(self):
print('bar')
self.f1()
class B(A):
def f1(self):
print('b')
class C():
def f1(self):
print('c')
class D(B):
def f1(self):
print('d')
class E(C,D):
pass
temp=D()
temp.bar()マルチクラス継承（例）：多重継承も問題を解決するための方法である、私たちはどのような多重継承のシナリオを示すために、一例として、ここでは、我々は、次の3つのカテゴリがされている追加Person(人类)あなたが由来する2つを作成し、親クラスとして使用しますクラス1はTeacher(老师)、他のStudent(学生)二つのクラス、派生2つのクラスはPerson(人类)、すべての人間はある共通の属性を持っています。
1.私たちは、最初に基本クラスを作成するPerson()私達の範囲の歴史を記述するために、当然のことながら、人間は教師が生徒を持っているかどうかは、そのような名前、年齢など、いくつかの共通の属性を持っています。
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
def walk(self):
print('%s is walking...' % self.name)
def talk(self):
print('%s is talking...' % self.name )2.上記ベースに基づいて、クラス派生Teacherサブクラス、親クラスのプロパティとメソッドのいくつかを使用します。
class Teacher(Person):
def __init__(self, name, age, level, salary):
super(Teacher, self).__init__(name, age)
self.level = level
self.salary = salary
def teach(self):
print('%s is teaching...' % self.name)3.最後に、生徒のクラスを作成しStudent、公共のいくつかの基本的なプロパティとメソッドは、同じようにして親です。
class Student(Person):
def __init__(self, name, age, class_):
Person.__init__(self, name, age)
self.class_ = class_
def study(self):
print('%s is studying...' % self.name)4.最後に二つのパラメータ、印刷の結果を参照渡し、直接インスタンス化し、それが十分に理解されています。
>>> t1 = Teacher('张老师', 33, '高级教师', 20000)
>>> s1 = Student('小明', 13, '初一3班')
>>> t1.talk()
>>> t1.walk()
>>> t1.teach()
>>> s1.talk()
>>> s1.walk()
>>> s1.study()
张老师 is talking...
张老师 is walking...
张老师 is teaching...
小明 is talking...
小明 is walking...
小明 is studying...オブジェクト指向 - >ポリモーフィズム
多型（polymorphisn）は異なる方法で動作する現在のサブオブジェクトの特性に応じて親になることを許可するように設定し、自分のスキルに等しい1つまたは複数のサブオブジェクト、割り当て後、親オブジェクトは、それに割り当てることができるされています多型役割：我々は、包装コードがモジュラーであるように、継承は既存のコードモジュールを拡張することができ、彼らの目的は達成することです、実装の詳細を隠すことができます知っている代码的重用多型が、別の目的を達成するためにあり、それがある一方で、接口的重用、ポリモーフィックな役割は、クラスの継承にあると財産権の「家系」の使用は任意の一文内のクラスのインスタンスは、インターフェイスを再利用するときに呼び出されることを保証するための時間を導出しました。
import os
import sys
class Animal(object):
def __init__(self, name):
self.name = name
class Cat(Animal):
def talk(self):
print('%s: 喵喵喵!' %self.name)
class Dog(Animal):
def talk(self):
print('%s: 汪！汪！汪！' %self.name)
def func(obj): #这里制定一个接口,后期直接调用它
obj.talk()
# =========================================================
>>> c1 = Cat("catcat")
>>> d1 = Dog("dogdog")
>>> func(c1) #这里调用相同的方法,传入的数据不同
catcat: 喵喵喵!
>>> func(d1) #这里调用相同的方法,传入的数据不同
dogdog: 汪！汪！汪！オブジェクト指向 - >包装
上述したように、あまりにも、一般的にクラスにパッケージされているオブジェクト指向の概念数据(数据成员)の操作数据的方法(成员函数)これら二つのことは、データ属性、つまり、カテゴリのプロトタイプで構成され、上述した属性は、いくつかの分類の上にそれよりも小さいものではありません形成されています公有属性/类变量、成员属性/实例变量および私有属性、これらの特性に加えて、方法は今のクラスは、次のカテゴリに分類され、クラスで私たちに言います：
●部材方法は：典型的には、一例として、その類似の特性を有するメンバーは、オブジェクトのクラスにアクセスすることで、プロセスの最初のメンバーは、通常、引数を書き込まれる
selfメンバメソッドであるかを示すために、
二重下線：●プライベートメソッド(__)開始メンバーこの方法は、プライベートな方法である、と、オブジェクトのプライベートインスタンスが内部でのみアクセスすることができ、サブクラスによって継承することができないプライベートプロパティに類似している
方法●クラス：使用する@classmethodクラスメソッドとして定義されている、と呼ばれるクラスのメソッドのメソッドのメンバーを飾るために、クラスのみアクセスでき変数は、インスタンス変数ではなく
、静的メソッドを●：使用@staticmethod方法を飾るためにメンバーを静的メソッドと呼ばれ、静的メソッドは、クラスを持つ任意の関連を持っていない、と通常のキットを書き込むために使用
●プロパティ・メソッド：になるための方法を静的プロパティ、あなたはメンバーのプロパティとしてアクセス方式を訪問しに行く、とによりすることはできませんので()、括弧、パラメータを渡します
◆◆クラスメソッド
我々は追加した場合も、上記に簡単には通常メンバ関数上に記載@classmethodクラスメソッドと呼ばれるメンバ・メソッドを飾るために最初の引数は現在のクラスである、としなければならない必要とし、公有属性/静态属性同様に、一例として以外の目的であってもよいですアクセスもクラス名を介して直接アクセスすることができ、そして最初のパラメータは、通常、CLSのように書かれた、現在のクラスを表し、別のクラスのメソッドのみパブリックプロパティにアクセスすることができることに留意すべきであり、部材のプロパティにアクセスすることができないので、第一CLSは、現在のクラスの送信パラメータの代表ではなく、自己のインスタンスオブジェクトを示します。
import os
import sys
class lyshark(object):
name="wangrui" #赋值等待被调用
age="22"
sex="Man"
def __init__(self,x,y,z):
self.x=x
self.y=y
self.z=z
@classmethod #声明下方的函数为类方法
def printf(cls): #此函数只能调用类变量,而不能调用成员属性
print("姓名:%s 年龄:%s 性别:%s"%(cls.name,cls.age,cls.sex))
# =========================================================
>>> temp=lyshark("100","100")
>>> temp.printf()
姓名:wangrui 年龄:22 性别:Man私たちは、印刷機能の呼び出しインスタンス変数よりも変数を変更した場合、エラーはデコレータが原因で発生していないclassmethodが存在するデコレータコードをマスクした場合、あなたは成功、それを呼び出すことができますが、コールはもはやクラス変数でありますデータが、インスタンス変数のデータ。
def __init__(self,x,y,z):
self.x=x
self.y=y
self.z=z
#@classmethod #此装饰器存在,不允许调用实例变量
def printf(self):
print("姓名:%s 年龄:%s 性别:%s"%(self.x,self.y,self.z))
# =========================================================
>>> temp=lyshark("lyshark","33","Man")
>>> temp.printf()
姓名:lyshark 年龄:22 性别:Man◆静的メソッド◆
上記簡潔にはまた、我々は、上記のメンバ関数を追加した場合、通常の状況下で、ことを示して@staticmethod飾るための方法のメンバーを静的メソッドと呼ばれ、静的メソッドはクラスの関数である、静的メソッドのインスタンスは、主ストアロジックに使用されませんコードは、論理のクラスに属するが、それは問題ではない、そして静的メソッドのクラス自体は、すなわち、特性及び動作クラスのメソッドに関連していないの静的な方法は、単純な関数は無関係であると理解することができますそれだけで、通常の状況下で、我々は独自のツールキットを実装するために使用することができ、使用と保守が容易で、クラスの名前空間をホストされています。
import os
import sys
class lyshark(object):
@staticmethod
def sum(x,y):
return x+y
@staticmethod
def sub(x,y):
return x-y
# =========================================================
>>> #temp=lyshark() #这里无需实例化
>>> text=lyshark.sum(10,20)
>>> print("两数之和:%s"%text)
两数之和:30
>>> text=lyshark.sub(100,50)
>>> print("两数之差:%s"%text)
两数之差:50他のデータ我々はZenmoを使用していなかったこれまでの開発では、この機能を呼び出すクラスなので、ツールボックスは、それの最も適切な使用はもちろん、あるとしてそれを指示することができないため、上記の、小型パッケージの典型的な例でありますあまりにも。
◆◆プロパティメソッド
プロパティがそれにアクセスするために、いくつかの機能（ファンクション）を実行し、値を返しますが、彼はメソッド静的プロパティになることができ、特別なプロパティである、あなたは、このメソッドにアクセスするなどのメンバーのプロパティにアクセスすることができ、そしてできないことで()、括弧、移転最初のパラメータでなければならないパラメータは、オブジェクトの現在のインスタンスであり、この方法は、戻り値を持たなければなりません。
import os
import sys
class lyshark(object):
def __init__(self,name,weight,height):
self.name=name
self.weight=weight
self.height=height
@property
def foo(self):
return self.weight + self.height
# =========================================================
>>> temp=lyshark("wangrui",75,1.88)
>>> print(temp.foo) #此处我们直接调用这个属性,并没有传递参数
76.88上記の小さな例、我々は内部関数fooを呼び出すときに、後でクラスの例を見て、ブラケットを追加していないが、それでも成功した呼び出し、ユニバーサル・アクセスの原則に従うように、この機能を使用することができ、それが外にありますユーザーはクラス変数と呼ばれている感を与えるためにそれを使用する変数を呼び出すこととちょうど同じ、詳細をシールド。
、アクセス、変更、削除、以下のコードを見て：新しいクラスには3つのアクセス方法を持っているので、我々は同じプロパティで定義された三つの方法のために、それぞれ、それらのプロパティのいくつかの機能にアクセスできます。
import os
import sys
class lyshark(object):
@property
def get(self):
print("get 函数运行了我...")
@get.setter
def get(self,value):
print("set 设置参数运行了我,传递的参数是: %s"%value)
@get.deleter
def get(self):
print("工作结束了,可以删除数据了")
# =========================================================
>>> temp = lyshark() #实例化
>>> temp.get #调用get属性,则会执行get()函数
get 函数运行了我...
>>> temp.get = 'hello' #设置属性则会执行get.setter函数
set 设置参数运行了我,传递的参数是: hello
>>> del temp.get #删除工作,则会走get.deleter函数
工作结束了,可以删除数据了具体的な例を見てみましょう、我々は直接呼び出すことができobj.price、商品の価格も代入文や他の商品価格により変更することができます取得します。
class Goods(object):
def __init__(self):
# 原价
self.original_price = 100
# 折扣
self.discount = 0.8
@property
def price(self):
# 实际价格 = 原价 * 折扣
new_price = self.original_price * self.discount
return new_price
@price.setter
def price(self, value):
self.original_price = value
@price.deltter
def price(self, value):
del self.original_price
# =========================================================
>>> obj = Goods()
>>> obj.price # 获取商品价格
>>> obj.price = 200 # 修改商品原价
>>> del obj.price # 删除商品原价