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类实例化的对象

 

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.1  __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__属性，尝试之前操作。

来源：https://www.cnblogs.com/tu240302975/p/12447411.html