Pythonのオブジェクト指向プログラミング - メタクラス

Pythonのオブジェクト指向プログラミング - メタクラス

まず、ちょうど準備

exec：三个参数

参数一：字符串形式的命令

参数二：全局作用域（字典形式），如果不指定，默认为globals()

参数三：局部作用域（字典形式），如果不指定，默认为locals()

利用幹部

#可以把exec命令的执行当成是一个函数的执行，会将执行期间产生的名字存放于局部名称空间中
g={
'x':1,
'y':2
}
l={}

exec('''
global x,z
x=100
z=200

m=300
''',g,l)

print(g) #{'x': 100, 'y': 2,'z':200,......}
print(l) #{'m': 300}

第二のプライマー（クラスもオブジェクトです）

class Foo:
      pass

f1=Foo() #f1是通过Foo类实例化的对象

パイソン、すべてがこのようにして、（ここでオブジェクトを参照するクラスのインスタンスの代わりにクラスである）Pythonインタプリタがロードされたクラスの時間でオブジェクトを作成する、キーワードのクラスを使用する場合、クラス自体は、対象となるオブジェクトでありますファーストクラスのオブジェクトを満たすために同じ概念を使用するオブジェクトとして、我々はできるクラス、次のことができます。

変数へのクラスの割り当て

渡されたパラメータの関数としてのクラス

関数の戻り値としてクラス

実行時に動的にクラスを作成します。

例としては、フー・クラスによって生成されたオブジェクトf1で見ることができ、かつfooが順番にどのクラスを生成するために、オブジェクト自体、及びそれですか？

#type函数可以查看类型，也可以用来查看对象的类，二者是一样的
print(type(f1)) # 输出：<class '__main__.Foo'> 表示，obj 对象由Foo类创建
print(type(Foo)) # 输出：<type 'type'>

第三に、メタクラスは何ですか

元のクラスは、クラスのクラスはテンプレートクラスです。

クラスが同じのオブジェクトを作成することですが、主な目的は、メタクラスのクラスを制御することにある振る舞いを作成される元クラスは、テンプレートクラスを作成する方法を制御するために使用されます

オブジェクト・クラスのインスタンスとして、クラス定義を使用して、我々のメタクラスクラスの結果の一例（F1オブジェクトはFooクラスのインスタンスである、のFooクラスタイプのクラスのインスタンスです）

内蔵型は直接生成されたクラスを制御するために使用されるメタクラスパイソン、である、任意のクラスのPythonのクラス定義は、実際にクラスタイプのオブジェクトのインスタンスです。

第四に、クラスを作成するには、2つの方法が

方法1：クラスのキーワードを使用します

class Chinese(object):
    country='China'
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def talk(self):
        print('%s is talking' %self.name)

第二の方法：クラス）は、手動でアナログクラス・プロシージャを作成している：クラスを作成するステップは、手動で作成するために、オープン分割します

#准备工作：

#创建类主要分为三部分

　　1 类名

　　2 类的父类

　　3 类体


#类名
class_name='Chinese'
#类的父类
class_bases=(object,)
#类体
class_body="""
country='China'
def __init__(self,name,age):
    self.name=name
    self.age=age
def talk(self):
    print('%s is talking' %self.name)
"""

1（第一の処理クラス本体を - >名前空間）ステップ：クラス本体定義された名前は、空間クラス（ローカル名前空間）の名の下に寄託され、我々は空の辞書を事前に定義し、次に体のように実行するには、execすることができますコード（名前空間クラス実際のプロセスの間に生成Execは同様であるが、後者の変形特性は、__で始まります）ローカル名前空間生成されたクラス、すなわち充填辞書。

class_dic={}
exec(class_body,globals(),class_dic)


print(class_dic)
#{'country': 'China', 'talk': <function talk at 0x101a560c8>, '__init__': <function __init__ at 0x101a56668>}

ステップ2：メタクラスコールタイプは、クラスChinenseを生成する（また、カスタマイズすることができます）。

Foo=type(class_name,class_bases,class_dic) #实例化type得到对象Foo，即我们用class定义的类Foo


print(Foo)
print(type(Foo))
print(isinstance(Foo,type))
'''
<class '__main__.Chinese'>
<class 'type'>
True
'''

私たちは、タイプは3つのパラメータを受け入れ、以下を参照してください。

• 最初の引数は、クラス名が表す文字列「foo」であり、
• 第2のパラメータは、タプル（オブジェクト）、親の全てを表しています
• 3番目のパラメータは、これは空の辞書で、辞書であるプロパティを定義および方法は表しません

注：のFooクラスの継承の場合、すなわち、クラスはFoo（バー）：....タイプと同等である（ 'foo' で、（バー）、{}）

第五に、カスタムクラスの振る舞いを制御するメタクラス

#一个类没有声明自己的元类，默认他的元类就是type，除了使用元类type，用户也可以通过继承type来自定义元类（顺便我们也可以瞅一瞅元类如何控制类的行为，工作流程是什么）

5つの手順は、メタクラスを学ぶために取る（エゴンの先生から）

#知识储备：
    #产生的新对象 = object.__new__(继承object类的子类)

#步骤一：如果说People=type(类名,类的父类们,类的名称空间)，那么我们定义元类如下，来控制类的创建
class Mymeta(type):  # 继承默认元类的一堆属性
    def __init__(self, class_name, class_bases, class_dic):
        if '__doc__' not in class_dic or not class_dic.get('__doc__').strip():
            raise TypeError('必须为类指定文档注释')

        if not class_name.istitle():
            raise TypeError('类名首字母必须大写')

        super(Mymeta, self).__init__(class_name, class_bases, class_dic)


class People(object, metaclass=Mymeta):
    country = 'China'

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def talk(self):
        print('%s is talking' % self.name)

#步骤二：如果我们想控制类实例化的行为，那么需要先储备知识__call__方法的使用
class People(object,metaclass=type):
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def __call__(self, *args, **kwargs):
        print(self,args,kwargs)


# 调用类People，并不会出发__call__
obj=People('egon',18)

# 调用对象obj(1,2,3,a=1,b=2,c=3)，才会出发对象的绑定方法obj.__call__(1,2,3,a=1,b=2,c=3)
obj(1,2,3,a=1,b=2,c=3) #打印：<__main__.People object at 0x10076dd30> (1, 2, 3) {'a': 1, 'b': 2, 'c': 3}

#总结：如果说类People是元类type的实例，那么在元类type内肯定也有一个__call__，会在调用People('egon',18)时触发执行，然后返回一个初始化好了的对象obj

#步骤三：自定义元类，控制类的调用（即实例化）的过程
class Mymeta(type): #继承默认元类的一堆属性
    def __init__(self,class_name,class_bases,class_dic):
        if not class_name.istitle():
            raise TypeError('类名首字母必须大写')

        super(Mymeta,self).__init__(class_name,class_bases,class_dic)

    def __call__(self, *args, **kwargs):
        #self=People
        print(self,args,kwargs) #<class '__main__.People'> ('egon', 18) {}

        #1、实例化People，产生空对象obj
        obj=object.__new__(self)


        #2、调用People下的函数__init__，初始化obj
        self.__init__(obj,*args,**kwargs)


        #3、返回初始化好了的obj
        return obj

class People(object,metaclass=Mymeta):
    country='China'

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def talk(self):
        print('%s is talking' %self.name)

obj=People('egon',18)
print(obj.__dict__) #{'name': 'egon', 'age': 18}

#步骤四：
class Mymeta(type): #继承默认元类的一堆属性
    def __init__(self,class_name,class_bases,class_dic):
        if not class_name.istitle():
            raise TypeError('类名首字母必须大写')

        super(Mymeta,self).__init__(class_name,class_bases,class_dic)

    def __call__(self, *args, **kwargs):
        #self=People
        print(self,args,kwargs) #<class '__main__.People'> ('egon', 18) {}

        #1、调用self，即People下的函数__new__，在该函数内完成：1、产生空对象obj 2、初始化 3、返回obj
        obj=self.__new__(self,*args,**kwargs)

        #2、一定记得返回obj，因为实例化People(...)取得就是__call__的返回值
        return obj

class People(object,metaclass=Mymeta):
    country='China'

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def talk(self):
        print('%s is talking' %self.name)

    def __new__(cls, *args, **kwargs):
        obj=object.__new__(cls)
        cls.__init__(obj,*args,**kwargs)
        return obj

obj=People('egon',18)
print(obj.__dict__) #{'name': 'egon', 'age': 18}

#步骤五：基于元类实现单例模式,比如数据库对象,实例化时参数都一样,就没必要重复产生对象,浪费内存
class Mysql:
    __instance=None
    def __init__(self,host='127.0.0.1',port='3306'):
        self.host=host
        self.port=port

    @classmethod
    def singleton(cls,*args,**kwargs):
        if not cls.__instance:
            cls.__instance=cls(*args,**kwargs)
        return cls.__instance


obj1=Mysql()
obj2=Mysql()
print(obj1 is obj2) #False

obj3=Mysql.singleton()
obj4=Mysql.singleton()
print(obj3 is obj4) #True

#应用：定制元类实现单例模式
class Mymeta(type):
    def __init__(self,name,bases,dic): #定义类Mysql时就触发
        self.__instance=None
        super().__init__(name,bases,dic)

    def __call__(self, *args, **kwargs): #Mysql(...)时触发

        if not self.__instance:
            self.__instance=object.__new__(self) #产生对象
            self.__init__(self.__instance,*args,**kwargs) #初始化对象
            #上述两步可以合成下面一步
            # self.__instance=super().__call__(*args,**kwargs)

        return self.__instance
class Mysql(metaclass=Mymeta):
    def __init__(self,host='127.0.0.1',port='3306'):
        self.host=host
        self.port=port


obj1=Mysql()
obj2=Mysql()

print(obj1 is obj2)