python 面向对象进阶之元类metaclass

一：知识储备

exec

exec：三个参数

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

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

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

exec的应用：

#可以把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}

__call__方法：对象后面加括号，触发执行。

注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者类()()

class Foo:

 

    def __init__(self):

        pass

 

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

 

        print('__call__')

 

 

obj = Foo() # 执行 __init__

obj()       # 执行 __call__

__call__的应用：

# 知识储备__call__方法

class Foo:

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

        print(self)

        print(args)

        print(kwargs)

obj = Foo()

obj(1,2,3,a=1,b=2,c=3)

# 结果：

# <__main__.Foo object at 0x000002AFE077B160>

# (1, 2, 3)

# {'a': 1, 'b': 2, 'c': 3}

__new__方法：

　知识储备：

    产生的新对象 = object.__new__(继承object类的子类)

obj.__new__(cls)

二：引子（类也是对象）

　　在理解元类之前，我们需要掌握Python中的类（class）。对于类是什么，Python有独特的看法，这借鉴于Smalktalk。

　　在大部分语言中，类仅仅是描述如何去产生一个对象的代码片段，在Python中也一样。

>>> class ObjectCreator(object):

...       pass

...

>>> my_object = ObjectCreator()

>>> print(my_object)

<__main__.ObjectCreator object at 0x8974f2c>

　　但是类在Python不仅仅是这样，类也是对象。

　　当你使用关键字class时，Python执行它并创建了一个对象，如下：

class Foo:

    pass

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

　　python中一切皆是对象，类本身也是一个对象，当使用关键字class的时候，python解释器在加载class的时候就会创建一个对象(这里的对象指的是类而非类的实例)，因而我们可以将类当作一个对象去使用，同样满足第一类对象的概念，可以：

把类赋值给一个变量
您能复制类
把类作为函数参数进行传递
把类作为函数的返回值
在运行时动态地创建类

上例可以看出f1是由Foo这个类产生的对象，而Foo本身也是对象，那它又是由哪个类产生的呢？

#type函数可以查看类型，也可以用来查看对象的类，二者是一样的

print(type(f1)) # 输出：<class '__main__.Foo'> 表示，obj 对象由Foo类创建

print(type(Foo)) # 输出：<type 'type'>

　　例如：

>>> print(ObjectCreator) # you can print a class because it's an object

<class '__main__.ObjectCreator'>

>>> def echo(o):

...       print(o)

...

>>> echo(ObjectCreator) # you can pass a class as a parameter

<class '__main__.ObjectCreator'>

>>> print(hasattr(ObjectCreator, 'new_attribute'))

False

>>> ObjectCreator.new_attribute = 'foo' # you can add attributes to a class

>>> print(hasattr(ObjectCreator, 'new_attribute'))

True

>>> print(ObjectCreator.new_attribute)

foo

>>> ObjectCreatorMirror = ObjectCreator # you can assign a class to a variable

>>> print(ObjectCreatorMirror.new_attribute)

foo

>>> print(ObjectCreatorMirror())

<__main__.ObjectCreator object at 0x8997b4c>

2.1 动态的创建类

　　因为类是对象，你能动态的创建他们，就像其他对象一样。

　　首先，你可以在函数中使用class创建一个类，如下：

>>> def choose_class(name):

...     if name == 'foo':

...         class Foo(object):

...             pass

...         return Foo # return the class, not an instance

...     else:

...         class Bar(object):

...             pass

...         return Bar

...

>>> MyClass = choose_class('foo')

>>> print(MyClass) # the function returns a class, not an instance

<class '__main__.Foo'>

>>> print(MyClass()) # you can create an object from this class

<__main__.Foo object at 0x89c6d4c>

　　但是这不够动态，因为你仍然需要去完整的定义这个类。

　　因为类是对象，他们肯定能用其他方式生成。

　　当你使用class这个关键字的时候，Python自动创建了这个对象，但是正如在Python中做的大部分事情一样，Python同时提供了手动触发的方式。

　　还记得函数type吗？一个古老而又有用的函数，一个能够让我们知道一个对象的类型是什么/

>>> print(type(1))

<type 'int'>

>>> print(type("1"))

<type 'str'>

>>> print(type(ObjectCreator))

<type 'type'>

>>> print(type(ObjectCreator()))

<class '__main__.ObjectCreator'>

　　type 还有一个完全不同的功能，它也动态的创建对象，type能够接受一个类的描述作为参数，然后返回一个类。

　　type还可以这样用

type(name of the class,

     tuple of the parent class (for inheritance, can be empty),

     dictionary containing attributes names and values)

　　例如：

>>> class MyShinyClass(object):

...       pass

　　能用这种方式手动创建，

>>> MyShinyClass = type('MyShinyClass', (), {}) # returns a class object

>>> print(MyShinyClass)

<class '__main__.MyShinyClass'>

>>> print(MyShinyClass()) # create an instance with the class

<__main__.MyShinyClass object at 0x8997cec>

　　你将注意到，我们使用”MyShinyClass“作为这个类的名称，同样作为变量的名称，并将类引用赋值给它。它们可能有点区别，但是没必要把事情搞复杂。

　　type接受一个字典去定义类的属性，因此：

>>> class Foo(object):

...       bar = True

　　能这样表达：

>>> Foo = type('Foo', (), {'bar':True})

　　而且被用来作为一个普通的类。

>>> print(Foo)

<class '__main__.Foo'>

>>> print(Foo.bar)

True

>>> f = Foo()

>>> print(f)

<__main__.Foo object at 0x8a9b84c>

>>> print(f.bar)

True

　　当然，你也能继承他，因此：

>>>   class FooChild(Foo):

...         pass

　　等价于

>>> FooChild = type('FooChild', (Foo,), {})

>>> print(FooChild)

<class '__main__.FooChild'>

>>> print(FooChild.bar) # bar is inherited from Foo

True

　　最终，你需要添加给这个类添加一些方法。仅需要定义好函数，并将它赋值给一个属性即可。

>>> def echo_bar(self):

...       print(self.bar)

...

>>> FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar})

>>> hasattr(Foo, 'echo_bar')

False

>>> hasattr(FooChild, 'echo_bar')

True

>>> my_foo = FooChild()

>>> my_foo.echo_bar()

True

　　而且，甚至在类动态创建之后，你也能添加更多的方法，就像给一个普通创建的类对象添加方法一样。

>>> def echo_bar_more(self):

...       print('yet another method')

...

>>> FooChild.echo_bar_more = echo_bar_more

>>> hasattr(FooChild, 'echo_bar_more')

True

　　如你所见：在Python中，类也是对象，而且你能动态地创建一个类。

　　这就是当你使用class这个关键字时Python所做的，Python使用元类来完成这项工作。

三：什么是元类？

　　元类是类的类，是类的模板，也是我们创建对象的东西。

　　元类是用来控制如何创建类的，正如类是创建对象的模板一样，而元类的主要目的是为了控制类的创建行为

　　元类的实例化的结果为我们用class定义的类，正如类的实例为对象(f1对象是Foo类的一个实例，Foo类是 type 类的一个实例)

　　type是python的一个内建元类，用来直接控制生成类，python中任何class定义的类其实都是type类实例化的对象

python 面向对象进阶之元类metaclass

class Mymeta(type):

    def __init__(self,class_name,class_bases,class_dic):

        if not class_name.istitle():

            raise TypeError('类名的首字母必须大写')

        if '__doc__' not in class_dic or not class_dic['__doc__'].strip():

            raise TypeError('必须有注释，且注释不能为空')

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

class Chinese(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)

#实例化

# chinese = mymeta(class_name,class_bases,class_dic)

　　元类是创建这些对象的东西，他们是类的类，我们可以用下面这种方式描述

MyClass = MetaClass()

my_object = MyClass()

　　我们已经看到type能让我们这样做

MyClass = type('MyClass', (), {})

　　这是因为type这个函数事实上是一个元类。type是Python在背后用来创建所有类的元类。

　　现在你可能想知道，为什么type首字母要小写，而不是写成Type

　　我猜，这与语言一致性有关，例如str是创建字符串对象的类，int是创建整数对象d的类，type就是用来创建类对象的类。

　　你可以检查__class__属性看到。

　　在Python中一切皆对象。包括整数、字符串、函数和类。它们都是对象，而且它们都是由类产生的。

>>> age = 35

>>> age.__class__

<type 'int'>

>>> name = 'bob'

>>> name.__class__

<type 'str'>

>>> def foo(): pass

>>> foo.__class__

<type 'function'>

>>> class Bar(object): pass

>>> b = Bar()

>>> b.__class__

<class '__main__.Bar'>

　　现在，如何__class__的__class__是什么呢？

>>> age.__class__.__class__

<type 'type'>

>>> name.__class__.__class__

<type 'type'>

>>> foo.__class__.__class__

<type 'type'>

>>> b.__class__.__class__

<type 'type'>

　　因此，元类就是创建类对象的东东。

　　如果你愿意，可以称它为"类工厂"。

　　type是Python使用的内置的元类，当然，你也能创建自己的元类。

四：创建类的两种方式

方式一：使用class关键字

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)

方式二：手动模拟class创建类的过程：将创建类的步骤拆开，手动去创建

#准备工作：

#创建类主要分为三部分

类名

类的父类

类体

#类名

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)

"""

　　步骤一（先处理类体->名称空间）：类体定义的名字都会存放于类的名称空间中（一个局部的名称空间），我们可以事先定义一个空字典，然后用exec去执行类体的代码（exec产生名称空间的过程与真正的class过程类似，只是后者会将__开头的属性变形），生成类的局部名称空间，即填充字典

class_dic={}

exec(class_body,globals(),class_dic)

print(class_dic)

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

　　步骤二：调用元类type（也可以自定义）来产生类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

我们看到，type 接收三个参数：

第 1 个参数是字符串 ‘Foo’，表示类名
第 2 个参数是元组 (object, )，表示所有的父类
第 3 个参数是字典，这里是一个空字典，表示没有定义属性和方法

补充：若Foo类有继承，即class Foo(Bar):.... 则等同于type('Foo',(Bar,),{})

4.3 metaclass 属性

　　当你定义一个类时，可以添加一个__metaclass__属性。

class Foo(object):

    __metaclass__ = something...

    [...]

　　如果你这样做的话，Python将使用这个元类去创建类Foo

　　小心，这有陷阱。

　　你首先写了class Foo(object)，但是这个类对象Foo在内存中并没有被创建。

　　Python将在类定义中寻找__metaclass__如果Python发现了它，Python将使用它去创建类对象Foo，如果没有，Python将使用type去创建这个类。

重温几次。

当你定义：

class Foo(Bar):

    pass

　　Python将做以下事情：在Foo中有__metaclass__属性吗？

　　如果有，就使用__mataclass__中定义的东东在内存中创建类对象，类名为Foo。

　　如果Python没有找到__metaclass__属性，它将在MODULE层寻找一个__metaclass__，去做相同的事情（对于类，不继承任何东西，基础的老式类）。

　　然后如果Python不能找到任何的__metaclass__，它将使用Bar（第一个父类）自己的元类（可能是type）去创建类对象。

　　这里小心__metaclass__属性将不会被继承，父类的元类（Bar.__class__）会被继承。如果Bar使用了一个用type（不是type.__new__()）创建Bar的__metaclass__属性，那么它的子类将会继承这个行为。

　　现在最大的问题是，你能在__metaclass__中定义什么？

　　答案就是，能够创建类的东东。

　　什么能创建类呢？type，或者它的子类，或者用了它的任何东西。

五：自定义元类控制类的行为

5.1 自定义元类

　　元类的主要目的是为了创建时自动地改变类。

　　经常为了API这么做，API中需要创建类去匹配当前的上下文。

　　想象一个非常蠢的例子，你决定你的模块中的所有类它们的属性应该大写。有好几种方式可以完成这件事，其中一种方式就是在模块层设置__metaclass__。

　　使用这种方式，模块内所有的类都会使用这个元类创建，而且我们必须告诉元类要将所有的属性转为大写。

　　幸运的是，__metaclass__确实是可调用的，它不需要是一个正式的类（在名字中带有类，但是不必要是一个类，区分一下，但是这很有用）。

　　接下来我们使用函数写个简单的例子。

# coding=utf-8

# 适用于python2

# 元类将自动获取到相同的你经常传给`type`的参数。

# 即参数列表与`type`的一致。

def upper_attr(future_class_name, future_class_parents, future_class_attr):

    """

      将属性名转为大写后，返回一个类对象。

    """

    # 筛选出所有不以__开头的属性，转为大写。

    uppercase_attr = {}

    for name, val in future_class_attr.items():

        if not name.startswith('__'):

            uppercase_attr[name.upper()] = val

        else:

            uppercase_attr[name] = val

    # 使用type创建类

    return type(future_class_name, future_class_parents, uppercase_attr)

__metaclass__ = upper_attr # 这将影响这个模块内的所有类。

class Foo(): # 虽然全局的 __metaclass__ 对 “object”无效

    # 但是我们可以在这里定义 __metaclass__ 而不是仅仅影响这个类。

    # 这将影响“object”的children

    bar = 'bip'

print(hasattr(Foo, 'bar'))

# Out: False

print(hasattr(Foo, 'BAR'))

# Out: True

f = Foo()

print(f.BAR)

# Out: 'bip'

　　现在，我们用一个真实的类作为元类去做相同的事情。

# coding=utf-8

# 记住`type`事实上是一个类似于`str`和`int`的类

# 所以你能继承它

class UpperAttrMetaclass(type):

    # __new__ 方法在 __init__ 前执行，这个方法创建对象并返回。

    # __init__方法仅仅初始化作为参数传入的对象。

    # 你很少使用__new__方法，除非你想控制类是如何创建的。

    # 这里创建的对象是一个类，我们想自定义它，因此需要覆盖 __new__。

    # 你也能在__init__中做一些事情，如果愿意的话。

    # 一些高级用法还包括覆盖__call__方法，这里不使用。

    def __new__(upperattr_metaclass, future_class_name,

                future_class_parents, future_class_attr):

        uppercase_attr = {}

        for name, val in future_class_attr.items():

            if not name.startswith('__'):

                uppercase_attr[name.upper()] = val

            else:

                uppercase_attr[name] = val

        return type(future_class_name, future_class_parents, uppercase_attr)

　　事实上这并不OOP，我们直接调用了type函数，没有覆盖或者是调用父类的__new__，改一下：

# coding=utf-8

class UpperAttrMetaclass(type):

    def __new__(upperattr_metaclass, future_class_name,

                future_class_parents, future_class_attr):

        uppercase_attr = {}

        for name, val in future_class_attr.items():

            if not name.startswith('__'):

                uppercase_attr[name.upper()] = val

            else:

                uppercase_attr[name] = val

        # 重用了type.__new__方法，这种写法是OOP的

        return type.__new__(upperattr_metaclass, future_class_name,

                            future_class_parents, uppercase_attr)

　　你可能注意到额外的参数upperattr_metaclass，这没什么特别的：__new__方法总是接受定义的类作为第一个参数，就像普通方法接受实例作为第一个参数传入self，类方法传入定义类一样。

　　当然，为了可读性，我在这里使用的名字太长了。但是就如self一样，所有的参数都有约定俗成的名字，因此一个真实的正式的metaclass应该像这样写：

class UpperAttrMetaclass(type):

    def __new__(cls, clsname, bases, dct):

        uppercase_attr = {}

        for name, val in dct.items():

            if not name.startswith('__'):

                uppercase_attr[name.upper()] = val

            else:

                uppercase_attr[name] = val

        return type.__new__(cls, clsname, bases, uppercase_attr)

　　我们使用super让代码看上去更清晰一些，

class UpperAttrMetaclass(type):

    def __new__(cls, clsname, bases, dct):

        uppercase_attr = {}

        for name, val in dct.items():

            if not name.startswith('__'):

                uppercase_attr[name.upper()] = val

            else:

                uppercase_attr[name] = val

        return super(UpperAttrMetaclass, cls).__new__(cls, clsname, bases, uppercase_attr)

以上就是全部了，关于元类已经没有什么内容了。

使用元类的代码复杂的原因并不在于元类本身，而是因为你经常使用元类去做一些扭曲的事情，操纵继承，遍历属性（vars）例如__dict__等等。

事实上，元类在做一些黑科技时非常有用，因此往往是一些复杂的东西。但是就元类本身而言，是简单的。

拦截类的创建。
修改类。
返回修改后的类。

5.2 自定义元类控制类的行为

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

步骤一：如果说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)

#单例模式

class MySQL:

    __instance = None  #__instance = obj1

    def __init__(self):

        self.host = '127.0.0.1'

        self.port = 3306

    @classmethod

    def singleton(cls):

        if not cls.__instance:

            obj =cls()

            cls.__instance = obj

        return cls.__instance

    def conn(self):

        pass

    def execute(self):

        pass

#obj1和obj2的内存地址是一样的，

# obj1 = MySQL()

# obj2 = MySQL()

# print(obj1)

# print(obj2)

# obj1 = MySQL.singleton()

# obj2 = MySQL.singleton()

# print(obj1)

# print(obj2)

# 结果：

# <__main__.MySQL object at 0x000002A1EF60CA58>

# <__main__.MySQL object at 0x000002A1EF60CA58>

#实现方式二，元类的方式

class Mymeta(type):

    def __init__(self,class_name,class_bases,class_dic):

        if not class_name.istitle():

            raise TypeError('类名的首字母必须大写')

        if '__doc__' not in class_dic or not class_dic['__doc__'].strip():

            raise TypeError('必须有注释，且注释不能为空')

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

        self.__instance =None

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

        if not self.__instance:

            obj = object.__new__(self)

            self.__init__(obj)

            self.__instance = obj

        return self.__instance

class Mysql(object,metaclass=Mymeta):

    '''必须有注释'''

    def __init__(self):

        self.host = '127.0.0.1'

        self.port = 3306

    def conn(self):

        pass

    def execute(self):

        pass

obj1 =Mysql()

obj2 =Mysql()

obj3 =Mysql()

print(obj1 is obj2 is obj3)

# True

5.3 为什么使用元类时用类不要函数？

　　因为__metaclass__能够接受任何可调用的东西，为什么要去使用明显更为复杂的类呢？

这么做有几个原因：

目的更明确，当你阅读UpperAttrMetaclass(type)，你知道接下来会发生什么。
更OOP。元类能够继承元类，覆盖父类的方法。元类甚至能使用元类。
一个类的子类可以是它的元类的实例如果你指定了一个元类类（metaclass-class），而不是一个元类函数（metaclass-function）。
能更好地组织代码。你从来没有像上面的例子这样试验性地使用元类。元类经常用于一些复杂场景。为了代码可读性，将好几个方法组织在一个类中的能力是非常重要的。
你能覆盖__new__，__init__和__call__，这些方法将允许你做不同的事情。即时即经常只需要修改__new__，一些人觉得使用__init__更舒服。
它们被称为元类，实际就应该和它的名称一致。

5.4 为什么使用元类

　　现在最大的问题，为什么要使用这么晦涩的容易出错的特性？

　　通常不要用：

    元类是深魔法，99%的用户都不需要关心它。如果你在想是否需要它们，

就不要用（需要元类的人确切地知道需要它，无需解释）。

Python Guru Tim Peters

　　元类主要的使用场景是创建API，一个典型的例子是Django的ORM。

　　它允许你去这样定义：

class Person(models.Model):

    name = models.CharField(max_length=30)

    age = models.IntegerField()

　　但是如果你这样做：

guy = Person(name='bob', age='35')

print(guy.age)

　　它将不会返回一个IntegerFiled对象，它将返回一个int，而且甚至直接传给数据库。

　　这是可能的，因为models.Model定义了__metaclass__而且进行了一些特殊处理，将你刚刚简单几句话定义的Person转变为数据库字段的复杂钩子。

　　Django通过使用元类暴露简单的API，让一些复杂的事情看上去简单，通过这些API背后重新创建代码去做真实的事情。

5.5 最后一点

　　首先，你知道类是能够创建实例的对象。

　　事实上，类本身就是对象，元类也是。

>>> class Foo(object): pass

>>> id(Foo)

142630324

　　Python中一切皆对象，而且他们也是类的实例或类的实例。

　　除了type

　　type确实是自己的元类，这只用Python是产生不了的，这是在实现层面做的。

　　第二，元类是复杂的。你可能想去使用他们去做简单的类修改。你能使用2种其他的技术去做这件事。

猴子补丁（monkey patching）
类装饰器（class decorators）

　　类修改99%的场景适合以上方式。

　　但是98%的场景，根本不需要去修改类。

5.6 Python3补充

　　Python3和Python2中元类使用有区别。

　　以下是使用元类实现追踪类定义顺序的例子。

class MyMeta(type):

    counter = 0

    def __init__(cls, name, bases, dic):

        type.__init__(cls, name, bases, dic)

        cls._order = MyMeta.counter

        MyMeta.counter += 1

class MyType(object):              # Python 2

    __metaclass__ = MyMeta

class MyType(metaclass=MyMeta):    # Python 3

    pass

　　Python3中元类有2个关键的方法。

__prepare__
__new__

__prepare__让你提供一个自定义的字典（例如OrderedDict）作为元类创建时的命名空间。无论选择什么命名空间，都必须返回一个实例。如果没有实现__prepare__，将会使用一个普通的dict。

class Meta(type):

    def __prepare__(metaclass, cls, bases):

        return dict()

    def __new__(metacls, cls, bases, clsdict):

        return super().__new__(metacls, cls, bases, clsdict)

六：练习题

练习题一：在元类中控制把自定义类的数据属性都变成大写

class Mymetaclass(type):

    def __new__(cls,name,bases,attrs):

        update_attrs={}

        for k,v in attrs.items():

            if not callable(v) and not k.startswith('__'):

                update_attrs[k.upper()]=v

            else:

                update_attrs[k]=v

        return type.__new__(cls,name,bases,update_attrs)

class Chinese(metaclass=Mymetaclass):

    country='China'

    tag='Legend of the Dragon' #龙的传人

    def walk(self):

        print('%s is walking' %self.name)

print(Chinese.__dict__)

'''

{'__module__': '__main__',

 'COUNTRY': 'China',

 'TAG': 'Legend of the Dragon',

 'walk': <function Chinese.walk at 0x0000000001E7B950>,

 '__dict__': <attribute '__dict__' of 'Chinese' objects>,

 '__weakref__': <attribute '__weakref__' of 'Chinese' objects>,

 '__doc__': None}

'''

练习题二：在元类中控制自定义的类无需__init__方法

　　1.元类帮其完成创建对象，以及初始化操作；

　　2.要求实例化时传参必须为关键字形式，否则抛出异常TypeError: must use keyword argument

　　3.key作为用户自定义类产生对象的属性，且所有属性变成大写

class Mymetaclass(type):

    # def __new__(cls,name,bases,attrs):

    #     update_attrs={}

    #     for k,v in attrs.items():

    #         if not callable(v) and not k.startswith('__'):

    #             update_attrs[k.upper()]=v

    #         else:

    #             update_attrs[k]=v

    #     return type.__new__(cls,name,bases,update_attrs)

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

        if args:

            raise TypeError('must use keyword argument for key function')

        obj = object.__new__(self) #创建对象，self为类Foo

        for k,v in kwargs.items():

            obj.__dict__[k.upper()]=v

        return obj

class Chinese(metaclass=Mymetaclass):

    country='China'

    tag='Legend of the Dragon' #龙的传人

    def walk(self):

        print('%s is walking' %self.name)

p=Chinese(name='egon',age=18,sex='male')

print(p.__dict__)

　　在大多数编程语言中，类就是用来描述如何生成一个对象的代码块，在python中类也是一个对象，这个（类）对象自身拥有创建对象（类实例）的能力。

因为他的本质是一个对象：

可以将它赋值给一个变量
可以拷贝他
可以增加属性
可以作为参数进行传递
可以在运行时动态的创建他们
可以在函数中创建类，只需要使用class关键字即可

　　当使用class关键字的时候，Python解释器会自动的创建这个对象，Python还提供了手动处理的方法：type()。

　　type是一个生成类对象的类工厂，实际上也是一个类，专门构建对象的类称为元类：

metaclass属性

　　可以为类添加一个__metaclass__属性，通过在基类的列表中指定metaclass关键字，例如：

class Foo(object):

    __metaclass__=something

　　当解释器解析后class Foo(object)，类对象Foo并没有创建，Python会在类定义中寻找__metaclass__属性，用它创建，如果找到了，Python就会用它来创建Foo，没有就会使用type来创建。

class  Foo(Bar)：

    pass

　　如果Foo没有__metaclass__属性，会继续父类Bar中递归地继续寻找__metaclass__属性，尝试之前操作。

秒客网

python 面向对象进阶之元类metaclass

一：知识储备

二：引子（类也是对象）

把类赋值给一个变量

您能复制类

把类作为函数参数进行传递

把类作为函数的返回值

在运行时动态地创建类

2.1 动态的创建类

三：什么是元类？

四：创建类的两种方式

方式一：使用class关键字

方式二：手动模拟class创建类的过程：将创建类的步骤拆开，手动去创建

4.3 metaclass 属性

五：自定义元类控制类的行为

5.1 自定义元类

5.2 自定义元类控制类的行为

步骤一：如果说People=type(类名,类的父类们,类的名称空间)，那么我们定义元类如下，来控制类的创建

步骤二：如果我们想控制类实例化的行为，那么需要先储备知识call方法的使用

步骤三：自定义元类，控制类的调用（即实例化）的过程

步骤四：

步骤五：基于元类实现单例模式,比如数据库对象,实例化时参数都一样,就没必要重复产生对象,浪费内存

应用：定制元类实现单例模式

5.3 为什么使用元类时用类不要函数？

5.4 为什么使用元类

5.5 最后一点

5.6 Python3补充

六：练习题

metaclass属性

相关文章

python 面向对象进阶之元类metaclass

一：知识储备

二：引子（类也是对象）

把类赋值给一个变量

您能复制类

把类作为函数参数进行传递

把类作为函数的返回值

在运行时动态地创建类

2.1 动态的创建类

三：什么是元类？

四：创建类的两种方式

方式一：使用class关键字

方式二：手动模拟class创建类的过程：将创建类的步骤拆开，手动去创建

4.3 __metaclass__ 属性

五：自定义元类控制类的行为

5.1 自定义元类

5.2 自定义元类控制类的行为

步骤一：如果说People=type(类名,类的父类们,类的名称空间)，那么我们定义元类如下，来控制类的创建

步骤二：如果我们想控制类实例化的行为，那么需要先储备知识__call__方法的使用

步骤三：自定义元类，控制类的调用（即实例化）的过程

步骤四：

步骤五：基于元类实现单例模式,比如数据库对象,实例化时参数都一样,就没必要重复产生对象,浪费内存

应用：定制元类实现单例模式

5.3 为什么使用元类时用类不要函数？

5.4 为什么使用元类

5.5 最后一点

5.6 Python3补充

六：练习题

__metaclass__属性

相关文章

4.3 metaclass 属性

步骤二：如果我们想控制类实例化的行为，那么需要先储备知识call方法的使用

metaclass属性