Pythonのクラスの概要

合計のpython

Pythonでチャットのクラス

Pythonのクラスがどのようなものです、多くの人々は確かに容易にプレーされます

class Student(object):
    def __init__(self):
        pass
jack = Student()
Helen = Student()

逃げるが、それは真実ではない、Pythonのクラスがまだ考えることがたくさんとレコードを持っています

根拠に

前述したように、それは、我々は、オブジェクトの概念なしで行うことはできませんので、来るのは、物理学の基礎Pythonクラス、ファーストクラスをみましょう、Pythonはインタプリタの動的言語、どこでもPythonはオブジェクトです。私たちは、これらのオブジェクトを生成するためのテンプレートを持っているしたいコースの目的は、そこにあるので、私たちはクラスを呼び出します。Pythonでは、上記のように学生として抽象クラスは、抽象的概念であるとしてクラスを総称して、彼はテンプレートです。そして、ジャックとヘレンは彼の例です。オブジェクト指向ので、クラス（クラス）およびインスタンス（インスタンス）の概念は、単に抽象クラスの概念がテンプレートであることを覚えて、出てきました。例では、これらのテンプレートによって生成例です。

最も基本的なクラスの継承

今、私たちはクラスを作成することを意味概念、がなければならないことがわかり、我々は複数のインスタンスを作成するために彼を使用することができます。だから、より多くの一つのクラスよりも、あなたは複数の複数のインスタンスを作成することができます。だから、実際には、これらのクラスは、新しいクラスとオブジェクトのクラス継承するかどうかに応じて、古典的なクラスを区別するためにPython2.4-3で、最も基本的なクラスオブジェクトのいずれかから継承するが、あなたができるようのpython3で、デフォルトではObjectクラスを継承してきました書き込み

class Student:
    def __init__(self):
        pass

例クラスのメモリ

クラスはテンプレートのインスタンスを作成することですので、あなたは、メモリの種類を格納する場所を持っている必要があります

class Student(object):
    def __init__(self):
        pass

if __name__ == "__main__":
    print(Student)
    print(Student())
    a = Student()
    print(a)

結果出力は次の

PS E:\app> & C:/Users/alpaca/AppData/Local/Programs/Python/Python37/python.exe e:/app/demo1.py
<class '__main__.st'>
__init__
<__main__.st object at 0x000001BB998EFB88>
__init__
<__main__.st object at 0x000001BB998EFB88>

プロセス出力

# st返回的是  <class '__main__.st'>  类的对象名
# print(st())时 st()创建了一个实例，python会为他创建一个实例，赋值给st() 然后再由print输出，因此会先执行__init__初始化,即先输出"__init__",再输出类的实例
# a = st() 创建一个实例a,会执行__init__ 后再输出 类的实例 
# 输出类的实例内容包括  <__main__.st     object at 0x00000141C826FE08>  创建实例的类的对象名 和 实例的存储地址

クラスのプロパティとメソッド

今、どこでも彼らは、オブジェクトが、そのオブジェクトがジャッキとして、変化するかもしれ言うとヘレンはまた、彼らは私たちが呼んでいるものと同じでも異なってい異なる場所に存在しなければならない財産当社固有の属性の便宜のために、我々は__init__コンストラクタプロパティを使用して初期化フェーズにおいて、クラスに定義されています

class Student(object):
    def __init__(self,name,age):
        # 因人而异的属性
        self.name = name
        self.age = age

        # 固有的属性
        self.type = "People"


if __name__ == "__main__":
    jack = Student("jack",12)
    Helen = Student("Helen",18)

    print(jack.name)
    print(Helen.name)
    
    # 输出固有属性
    print(jack.type)
    print(Helen.type)

    # 随着年龄的增增长，属性也会随之变大
    Helen.age = Helen.age + 1
    jack.age +=1
    print(jack.age)
    print(Helen.age)

    # Helen比较自私，他有别人没有的属性
    Helen.HasCar = "Helen has one car "
    print(Helen.HasCar)

出力内容

PS E:\app> & C:/Users/alpaca/AppData/Local/Programs/Python/Python37/python.exe e:/app/demo2.py
jack
Helen
People
People
13
19
Helen has one car

例と実施例との間の特性は互いに独立している、覚えています。

私有財産
彼は年齢に望んでいるので、彼は、彼の年齢が上昇したくなかったので、ヘレンは女の子で、彼はこの性質自体が、私有財産となり、彼女の年齢を大切に。彼は__ダブルアンダースコアに年齢の初めに民間（プライベート）__age、あなたが外を変更したい場合、あなたはエラーを見つけることができますを追加しました。

class Student(object):
    def __init__(self,name,age):
        # 因人而异的属性
        self.name = name
        self.__age = age

if __name__ == "__main__":
    jack = Student("jack",12)
    Helen = Student("Helen",18)

    print(jack.age)
    jack.age +=1
    print(jack.age)

結果出力

PS E:\app> & C:/Users/alpaca/AppData/Local/Programs/Python/Python37/python.exe e:/app/3.py
Traceback (most recent call last):
  File "e:/app/3.py", line 17, in <module>
    print(jack.age)
AttributeError: 'Student' object has no attribute 'age'

実際に、彼らは二重下線が引かれても、それはないアクセスが、我々は_Student__ageを取得するために使用することができますすることができ、必ずしもである
彼は変更することはできませんこれらの事の当然の年齢の、我々は、我々が対応するメソッドを追加する必要があり、これらを取得する方法を考えます

class Student(object):
    def __init__(self,name,age):
        # 因人而异的属性
        self.name = name
        self.__age = age
        
    def get_age(self):
        return self.__age

    def __set_age(self,age):
        self.__age = age

if __name__ == "__main__":
    jack = Student("jack",12)
    Helen = Student("Helen",18)

    print(Helen.get_age())
    Helen._Student__set_age(19)
    print(Helen.get_age())

特性に加えて、このクラスはまた、我々の一般的な（固有の）クラスのクラスに、同じようにメソッドを含んでいてもよいです

class Student(object):
    def __init__(self,name,age):
        # 因人而异的属性
        self.name = name
        self.age = age

    def say(self,msg):
        print(msg+", my name is "+ self.name)

if __name__ == "__main__":
    jack = Student("jack",12)
    Helen = Student("Helen",18)

    jack.say("hello")

出力内容

PS E:\app> & C:/Users/alpaca/AppData/Local/Programs/Python/Python37/python.exe e:/app/demo4.py
hello, my name is jack

すべてのメソッドは、最初の引数としてクラス内部の自己に基づいており、それは着信が任意の値を必要としないとき、自分自身のクラスを作成するポイント

クラスの継承

私たちは、この基底クラスオブジェクトから継承するすべてのクラスを介して話をした上で。我々は秘密達成されなかったであろう前に、同様に、あなたも、この、物事でヘレン・自動車所有で、クラス間お互いを継承することができ、その後、彼は自分自身のクラスを継承することができます

class Student(object):
    def __init__(self,name,age):
        # 因人而异的属性
        self.name = name
        self.age = age
        
        # 固定的属性
        self.type = "People"

class Man_HasCar(Student):
    def HasCar(self):
        print(self.name+" has one car ")

if __name__ == "__main__":
    jack = Student("jack",12)
    Helen = Man_HasCar("Helen","18")

    Helen.HasCar()

オブジェクトの型を取得します。

タイプ（）
オブジェクトタイプを決定するために型（）を使用して
）（でisinstanceを
特定のインスタンスは、クラスのインスタンスであるかどうかを決定するためでisinstanceを使用して、すなわち、Bは仮想例Bである、階層繰り返し考えることができ、Bは、印刷、親クラスAであります（例えば（B、A））は =真
の基本的なタイプがでisinstanceでisinstance（ ''、STR）を決定するためにも使用することができます

print(instance(b,A)) # true
isinstance('a',str) # True
isinstance([1, 2, 3], (list, tuple)) # True

DIR（）
オブジェクトのすべてのプロパティとメソッドを取得する場合、Dir関数を使用することができる、彼はこのようなオブジェクトのメソッド列strへのアクセスとしてリストを含む文字列を返します。

dir("ABC")
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

この方法で魔法のいくつかは、もちろん、我々はまた、取得する）（LENを使用することができますすることは二重下線は、そのような文字の戻り長さなどで再びですが、実際にはまだ、このメソッドを呼び出している__len__

print("ABC".__len__())
print(len("ABC"))

class return_len_string(object):
    # 重写__len__
    def __len__(self):
        return 100

rls = return_len_string()
print(len(rls))
# 返回100

オブジェクトのプロパティを取得します。

Pythonは、直接オブジェクトのプロパティを操作することができるGETATTR（）、SETATTR（）はhasattr（）を調製しました

# 获得属性
getattr(cls,'name')
# 设置属性
setattr(cls,'name','Helen')
# 判断某个类是否具有某个属性
hasattr(cls,'name')

特別なプロパティ__slot__

私たちは、Pythonは動的言語のクラスであることを知って、その後、私たちはクラスを完了した後に作成し、彼の例を作成し、我々はどのように行うにインスタンスの制限プロパティにしたい場合は、このインスタンスがために、任意のプロパティとメソッドを追加してバインドすることができます限定の目的を達成するために、Pythonのクラス定義がクラスのインスタンス属性を制限する__slots__変数の特定の定義を添加することができる場合、可能

class Student(object):
    __slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称

"""实际执行效果"""
>>> class Student(object):
...     __slots__ = ('name', 'age')
...
>>> s = Student()
>>> s.name = 'digg'
>>> s.age = '19'
>>> s.score = 99
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'score'
>>>

唯一の現在のクラスのための有効な__slot__また、クラスの継承が無効です。

__str__、__ repr__

魔法のメソッドは、カスタムコンテンツを返します。

class tt(object):
    def __str__(self):
        return "自定义"
    
    def __repr__(self):
        return "自定义"
    # 或者
    __repr__ = __str__
class ss(object):
    pass

if __name__ == "__main__":
    print(tt())
    print(ss())

実際には、ほぼ同じ被写体に、ほとんどの場合、使用strを__repr__と__str__

__iter__と__next__

あなたが使用するクラス...ループで、そのリストやタプルに類似したい場合は、（__イテレータオブジェクトを返す）メソッドを、__iterを実装する必要があり、その後、ループのためのPythonは反復可能オブジェクトを呼び出すしていきますエラーが呼び出すとStopIteration出口にループを遭遇するまで__next __（）メソッドは、次のサイクルの値を取得します。

class Fib(object):
    def __init__(self):
        self.a, self.b = 0, 1 # 初始化两个计数器
    def __iter__(self):
        return self # 实例本身即是迭代对象，故而返回自己
    def __next__(self):
        self.a, self.b = self.b, self.a + self.b # 计算下一个值
        if self.a > 100000: # 退出循环条件
            raise StopIteration();
        return self.a
# 测试
for n in Fib():
    print(n)

列挙型クラス

元类

---

使用して、staticmethodクラスメソッドを異なります

一般的には、クラスを使用するには、オブジェクトをインスタンス化してからメソッドを呼び出す必要があります。
または、@staticmethod @classmethodを使用するインスタンス化する必要がない場合も、クラス名を指示します。メソッド名（）が呼び出されます。
これは、組織コードを容易にし、関数がそのクラスに行くために、特定のクラスに属し、そして助けきれいな名前空間なければなりません。
@staticmethodと@classmethodは（）。メソッド名をクラス名を指示することができます呼び出され、彼らは違いがそれをしないものを持っていることをするので
、その使用の観点から、

• @staticmethod自体は全く同じ機能を使用して、オブジェクトと自身の自己CLSクラスのパラメータを表現するために必要はありません。
• @classmethodあなたは自己の引数を必要としませんが、最初のパラメータには、独自の必要なパラメータCLSクラスです。
• @classmethodは、以下のクラスメソッドであることを意味し、関数修飾子ですが、通常我々は、例えばメソッドが呼び出された参照してください。
• 第1のパラメータCLSクラスメソッドは、最初のパラメータは、そのような例を示す自己の方法の一例です。
• 共通オブジェクト・プロセスは、少なくともクラス・オブジェクト・インスタンスの自己パラメータ代表的な必要
  、着信クラス変数CLSクラスのメソッドをいくつかの処理関連のCLSを実行するために使用することができます。サブクラスの継承がある場合には、そのようなメソッドを呼び出すときと、入ってくるクラスは、CLS変数のサブクラスではなく、親クラスです。
• クラスメソッドは、クラスを通じて呼び出すことができるため、幾分類似しているだけ++ Test.foo（）、Cにおける静的メソッドのように、また、試験（）のようなクラスのインスタンスを介して呼び出すことができる。フー（）、ここでテスト（）その一例は、それはクラスの後に書かれています。
  
• 静的メソッドは、それはほとんど一般的に使用されていない、基本的にグローバル関数と同じだありません
  あなたはこのクラスのプロパティの一部に@staticmethod方法で呼び出したい場合は、クラス名のみが直接属性名またはクラス名ことができます。メソッド名。
  @classmethod CLSパラメータ、クラス属性、クラスメソッド、インスタンスオブジェクトなどを呼び出すことができる（もちろん、「自己」の代わりに自己の間とCLSの唯一のクラスと区別することである個人が使用すること）を保持するのでハードコーディングを避けます。

例

class cs(object):
    def speak(self,name):
        print("can you speak english? %s"%name)
        
    @staticmethod
    def say(name):
        print("my name is %s "%(name))

    @classmethod
    def run(cls,name):
        print("running now, %s"%(name))

if __name__ == "__main__":    
    cs.say("hzj")
    cs.run("hzj")

---

Pythonのデコレータでチャット

https://blog.csdn.net/zhouchen1998/article/details/82933893
デコレータは一緒に共通の特徴の数の関数であります

Pythonは、豊富で強力な発現特性、デコレータとなっているものを持っているデコレータは、機能を変更することはできません、メソッド、クラス自体の場合にはその機能を充実します。
アプリケーションシナリオ：例えば、それはQQのメンバー、我々はFUNCを使用している普通のメンバーが、VIP会員のための方法のfunc_vipですが、重複がほとんどの機能の非常に高いとfunc_vip FUNCあり、func_vipメソッドを書き換える必要がない、唯一のFUNCそれを豊かにする必要が使用することができ、そして今回はデコレータを使用することができます

前提

1.関数は、変数として使用することができます

def func(name):
    print("my name is %s"%name)

func_other = func()
func_other("hzj")

関数に渡さ2.機能

def func1(name):
    return name
def func2(func):
    print(func)
func2(func1("hzj"))

3.ノー関数パラメータネストされた関数

def func_wrap():
    def prt_func():
        return 'hello,world'
    return prt_func

hlowld = func_wrap()
print(hlowld())

基準関数のネストされた機能を持つ4

def func_wrap():
    def prt_func(name):
        return 'hello,'+name   
    return prt_func

hlo = func_wrap()
print(hlo('crossin'))

関数は、ネストされた関数パラメータ

def func(name):
    return "hello %s"%(name)

def top_func(func):
    def sec_func(name):
        return "hello %s"%(func(name))
    return sec_func

tt = top_func(func)
print(tt("hzj"))

デコレータについての話

実際には、デコレータは、最初にすべての私たちは、最も一般的な機能を見て、私たちが見て、具体的方法を、メソッドのパラメータの一種として機能します

# 最简单的函数
def general():
    return "i am general func"

if __name__ == "__main__":
    print(general())
# 带参数的最简单的参数
def general_params(name):
    return "i am general %s"%name
if __name__ == "__main__":
    print(general())
    print(general_params("func"))

次は、変速機の機能 Pythonでパラメータは関数と関数の間の引数として渡すことができ、

# 函数作为变量
def bottom():
    return "i ma bottom func"
b = bottom
print(b())
# -----------------
# 函数之间传递
# 函数作为变量传递
def bottom():
    return "i am bottom func"

def top(func):
    return "%s,ok!i know!"%(func())

t = top(bottom)
print(t)

次は、ネストされた関数

# 不带参嵌套
def outer():
    def inner():
        return "ok!"
    return inner
out = outer()
print(out())
# 带参嵌套
def outer(name):
    def inner(name):
        return "ok!%s"%name
    return inner
out = outer("a")
print(out("b"))
# 结果ok!b

---

デコレーター

# 首先定义一个普通的函数
def print_text(name):
    return 'hello,'+ name
# 再定义一个嵌套函数，分别以函数和普通的字符串作为参数
def add_tag(func):
    def prt_func(name):
        return '<p>{0}</p>'.format(func(name))    
    return prt_func
    
# 将函数作为参数传递给 add_tag
hlo = add_tag(print_text)
# 将 'crossin' 作为参数传递给 hlo
print(hlo('crossin'))
# 结果 : <p>hello,crossin</p>

それは次のように記述することができます

def add_tag(func):
    def prt_func(name):
        return '<p>{0}</p>'.format(func(name))    
    return prt_func

@add_tag
def print_text(name):
    return 'hello,'+ name

print_text('crossin')

ソース

Pythonでは、この言語は、多くの魔法の方法がある、__new__この記事の導入に加えて、initの外__call__を魔法の他の方法があります

すべては、プロセスの終焉、プログラミング言語、オブジェクト指向プログラミングモデルに、使用されるように、作成から持っても同様の運命を持つオブジェクト：異なる方法で、初期化、使用、ガベージコレクション、異なるステージを作成する（役割）実装を担当。
あなたがクラスを定義するとき、私たちはほとんどを使用でのinitメソッドながら、新しいおよびコール未満の使用には、ヘルプには、この記事の試行では、それぞれについて説明し、適切な使用およびアプリケーションシナリオの3つのメソッドを置きます。
コンセプトPython2の昔ながらの一種であるとして、この記事の概要Pythonの新しいクラスと昔ながらのクラスは、あまりにも多くの議論をしない、今基本的に誰も昔ながらのクラスは、オブジェクトを明示的に継承する必要があり、昔ながらの種類を行くんだろう、とのpython3、唯一の新しいですクラスは、デフォルトで継承されたオブジェクト、指定されたが、このコードが表示されずに議論するのpython3に基づいています。

__init__方法
__init__方法は、そのオブジェクトが存在するオブジェクト指向言語であるため、当然のことながら、オブジェクトのプロパティもあり、そして模倣するために使用されるINIT方法は、システムは、実際には、方法を実施する初めて、オブジェクトのプロパティを初期化し、オブジェクトの初期化を担当してオブジェクトがすでに存在している、または他の初期化、それは何ですか？例を見てください

class A:
    def __init__(self, *args, **kwargs):
        print("__init__")
        super(A,self).__init__()
    def __new__(cls):
        print("__new__")
        print(cls)
        return super(A,cls).__new__(cls)
if __name__ == "__main__":
    A()

# -----------------
# result:
__new__
<class '__main__.A'>
__init__

__init__最初の実装よりもその__new__は、実行フローは、加算__init__に、実質的__new__、クラスの、すなわち現在のインスタンスをCLSを受信し、初期化セルフ、次に初期化初期化構造を生成します自己に加えて、他のパラメータの数に対して同じ__new__

class B:
    def __init__(self, *args, **kwargs):
        print("init", args, kwargs)

    def __new__(cls, *args, **kwargs):
        print("new", args, kwargs)
        print(cls)
        self = super().__new__(cls)
        print(self)
        return super().__new__(cls)
if __name__=="main":
    B()

__new__方法
実際には、代理店を開始する前に、その有用性を知るために、主に__new__の上に持っているにクラスのオブジェクトインスタンスを返しINIT。
あなたがする方法を正確に知っている限り一般的に我々は、このメソッドをオーバーライドしません。あなたはそれの世話をするとき、コンストラクタは、オブジェクトを作成するために使用されるように、そのオブジェクトの本番インスタンスに特化し、ファクトリ関数です。1つのよく知られた設計パターン、Singletonパターンは、この方法によって達成することができます。
シングルトン、ライブラリ内の列は、現在のブログのデザインパターンは、について話しています

__call__メソッド
現在のクラスが呼び出されたときに魔法のメソッドがトリガーされ、単純に言って利用できるコールバックオブジェクトでコールバックコールバック関数に関連した実際には__call__、

class C:
    def __init__(self):
        print("__init__")
    def __call__(self):
        print("__call__")

if __name__=="main":
    c = C()
    c()

# -----------
# result: 
__init__
__call__