python中元类(metaclass)的理解

原文地址：http://www.cnblogs.com/tkqasn/p/6524879.html

一：类也是对象

  类就是一组用来描述如何生成一个对象的代码。

 类也是一个对象，只要你使用关键字class，python解释器在执行的时候就会创建一个对象。

 下面这段代码：

class ObjectCreator(object):
    pass

会在内存中创建一个对象，名字就是ObjectCreator，这个对象（类）自身拥有创建对象（类实例）的能力。

类的本质是一个对象，你可以拷贝它，可以将它赋给一个变量，将它作为参数传递给函数，可以为它增加属性。

以下为实例：

class ObjectCreator(object):
    pass

print(ObjectCreator) #打印一个类

def echo(data):
    print(data)

echo(ObjectCreator) #将类作为参数传递给函数

ObjectCreator.newAttribute = 'new attr'  #为类添加新属性
print(hasattr(ObjectCreator,'newAttribute'))
print(ObjectCreator.newAttribute)

ObjectCreatorCopy = ObjectCreator #将类复制给一个变量
print(ObjectCreatorCopy)
print(ObjectCreatorCopy())

'''
输出：
<class '__main__.ObjectCreator'>
<class '__main__.ObjectCreator'>
True
new attr
<class '__main__.ObjectCreator'>
<__main__.ObjectCreator object at 0x0000000001EA9860>
'''

二：动态的创建类

1 通过return class 动态的构建需要的类

类也是对象，所以我们再运行的时候动态的创建它们。在函数体中创建类：

def create_class(name):
    if name == 'foo':
        class Foo(object):
            pass
        return Foo
    else:
        class Berry(object):
            pass
        return Berry
my_class = create_class('foo')
print(my_class)#返回类
print(my_class())#返回类的实例
    
'''输出：
<class '__main__.create_class.<locals>.Foo'>
<__main__.create_class.<locals>

2 通过type函数构造类

 上述方法需要你自己编写整个类的代码。由于类也是对象，所以也必须是通过什么东西来生成才对。

内置函数type可以让知道一个对象的类型是什么，like：

class Demo(object):
    pass
print(type(100))
print(type('str'))
print(type(Demo))
print(type(Demo()))
'''
输出：
<class 'int'>
<class 'str'>
<class 'type'>
<class '__main__.Demo'>
''' 

另外，type还可以动态的创建类。type可以接收一个类的描述作为参数，然后返回一个类。

type的语法：

type(类名，父类的元组（针对继承的情况，可以为空）， 包含属性的字典（名称和值）)

比如下面的代码：

class MyclassDemo(object):
    pass
#可以手动通过type创建

MyclassDemo = type('MyclassDemo',(),{}) #返回一个类对象
print(MyclassDemo)
print(MyclassDemo())
'''
输出：
<class '__main__.MyclassDemo'>
<__main__.MyclassDemo object at 0x000000000213A3C8>
'''

下面通过一个例子看看type是如何创建类的：

#1 构建Foo类
class Foo(object):
    bar = True
# 使用type构建Foo
Foo = type('Foo', (), {'bar': True})
print(Foo)

# 2继承Foo类
class FooChild(Foo):
    pass
# 使用type构建FooChild
FooChild = type('Foochild',(Foo,), {})
print(FooChild)
print(FooChild.bar)

# 3为FooChild类增加方法
def echo_bar(self):
    print(self.bar)
FooChild = type('FooChild',(Foo,),{'echo_bar': echo_bar})
print(hasattr(Foo,'echo_bar'))
print(hasattr(FooChild, 'echo_bar'))
my_foo = FooChild()
my_foo.echo_bar()
'''
输出：
<class '__main__.Foo'>
<class '__main__.Foochild'>
True
False
True
True
'''

可以看到，在python中，类也是对象，你可以动态的创建类。这就是当我们使用关键字class时python在幕后做的事，而这就是通过元类来实现的。

三：元类

1 什么是元类？

python中类也是对象，元类就是用来创建这些类（对象）的，元类是类的类，你可以这样理解：

MyClass = MetaClass() #元类创建类
MyObject = MyClass() #类创建对象

#MyClass通过type（）来创建出MyClass类，它就是type（）类的一个实例

函数type实际上是一个元类，type就是python在背后创建所有类的元类。现在想知道type为什么会全部采用小写形式而不是Type呢？好吧，我猜这是为了和str保持一致性，str是用来创建字符串对象的类，int是用来创建整数对象的类。type就是创建类对象的类。

你可以通过检查__class__属性来看到这一点。python中所有的东西 都是对象。这包括整数，字符串，函数以及类。它们全都是对象，而且是从一个类创建而来。

age = 33
print(age.__class__)

name = 'alice'
print(name.__class__)

def foo():
    pass
print(foo.__class__)

class Bar(object):
    pass
b = Bar()
print(b.__class__)

# 那么任何一个__class__的__class__属性又是什么呢？？
print(age.__class__.__class__)
print(foo.__class__.__class__)
print(b.__class__.__class__)

'''
输出：
<class 'int'>
<class 'str'>
<class 'function'>
<class '__main__.Bar'>
<class 'type'>
<class 'type'>
<class 'type'>
'''

因此，元类就是创建类这种对象的东西，type就是python的内建元类，当然了，你也可以创建自己的元类。

2 __metaclass__属性

你可以在写一个类的时候为其添加__metaclass__属性，定义了__metaclass__就定义了这个类的元类。

class Foo(object): #py2
    __metaclass__ = something
    
class Foo(metaclass=something): #py3
    __metaclass__ = something

例如：当我们在编写如下代码时：

class Foo(Bar):
    pass

在该类定义的时候，它在内存中还没有生成，直到它被调用，python做了如下的操作：

 1） Foo中有__metaclass__这个属性吗？如果有，python会在内存中通过__metaclass__创建一个名字为Foo的类对象。

 2） 如果没有__metaclass__这个属性，它会继续在父类中寻找__metaclass__属性，并尝试做和前面同样的操作。

 3）如果python在任何父类中都找不到__metaclass__，它就会在模块层次中去寻找__metaclass__，并尝试做同样的事情

 4）如果还是找不到__metaclass__，python就会用内置的type来创建这个类对象。

现在的问题就是，你可以在__metaclass__中放置些什么代码呢？

答案就是：可以创建一个类的东西。那么什么可以用来创建一个类呢？type，或者任何使用到type或者子类化type的东西都可以。

 三 自定义元类

元类的主要目的就是为了在创建类时能够自动的改变类。通常，你会为API做这样的事，你希望可以通过创建符合当前上下文的类。

假想一个很傻的例子，你决定在你的模块里所有类的属性都应该是大写形式。有好几种方法可以办到，但其中一种就是通过设定__metaclass__。采用这种方法，这个模块里所有类都会通过这个元类来创建，我们只需要告诉元类把所有的属性都改成大写形式就万事大吉了。

__metaclass__实际上可以被任意调用，它并不需要是一个正式的类。所以，我们这里就先以一个简单的函数作为例子开始。

1 使用函数当做元类

#元类会自动将你通常传给type的参数作为自己的参数传入
def upper_attr(future_class_name,future_class_parents,future_class_attr):
    '''返回一个类对象，将属性都转为大写形式'''
    attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__'))
    uppercase_attr = dict((name.upper(),value) for name,value in attrs)
    return type(future_class_name,future_class_parents,uppercase_attr)

class Foo(metaclass=upper_attr):
    __metaclass__ = upper_attr
    bar = 'bip'

print(hasattr(Foo,'bar'))
print(hasattr(Foo,'BAR'))
print(Foo.BAR)
'''
输出：
False
True
bip
'''

2 使用class来当做元类

__metaclass__必须返回一个类

'''
请记住，type实际上是一个类，就像str和int一样，所以，你可以从type继承
__new__ 是在__init__之前被调用的特殊方法。 __new__是用来创建对象并返回之的方法，__new__（）是一个类方法
而__init__只是用来将传入的参数初始化给对象，它是在类创建之后执行的方法。
你很少用到__new__，除非你希望能够控制对象的创建。这里创建的对象是类，我们希望能够自定义它，所以我们这里改写__new__
如果你希望的话，你也可以在__init__中做些事情。还有一些高级的用法会涉及到改写__call__特殊方法。但是我们这里不用，下面我们可以单独讨论这个使用
'''
class UpperAttrMetaClass(type):
    def __new__(uppersttr_metaclass, future_class_name, future_class_parents, future_class_attr):
        attrs = ((name,value) for name,value in future_class_attr.items()if not name.startswith('__'))
        uppercase_attr = dict((name.upper(),value) for name, value in attrs)
        return type(future_class_name,future_class_parents,uppercase_attr)

但是，这种方式其实不是OOP。我们直接调用了type，而且我们没有改写父类的__new__方法。现在让我们这样去处理：

class UpperAttrMetaclass(type):
    def __new__(upperattr_metaclass, future_class_name, future_class_parents, future_class_attr):
        attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__'))
        uppercase_attr = dict((name.upper(), value) for name, value in attrs)
        # 复用type.__new__方法
        # 这就是基本的OOP编程，没什么魔法。由于type是元类也就是类，因此它本身也是通过__new__方法生成其实例，只不过这个实例是一个类.
        return type.__new__(upperattr_metaclass,future_class_name,future_class_parents,uppercase_attr)

你可能已经注意到了有个额外的参数upperattr_metaclass，这并没有什么特别的。类方法的第一个参数总是表示当前的实例，就像在普通的类方法中的self参数一样。当然了，为了清晰起见，这里的名字我起的比较长。但是就像self一样，所有的参数都有它们的传统名称。因此，在真实的产品代码中一个元类应该是像这样的：

class UpperAttrMetaClass(type):
    def __new__(cls, name,bases,dct):
        attrs = ((name,value) for name,value in dct.items() if not name.startswith('__'))
        uppercase_attr = dict((name.upper(),value)for name, value in attrs)
        return type.__new__(cls,name,bases,uppercase_attr)

如果使用super方法的话，我们还可以使它变得更清晰一些。

class UpperAttrMetaClass(type):
    def __new__(cls, name,bases,dct):
        attrs = ((name,value) for name,value in dct.items() if not name.startswith('__'))
        uppercase_attr = dict((name.upper(),value)for name, value in attrs)
        return super(UpperAttrMetaClass,cls).__new__(cls,name,bases,uppercase_attr)

四：使用原来创建ORM的实例

我们通过创建一个类似Django中的ORM来熟悉一下元类的使用，通常元类用来创建API是非常好得选择，使用元类编写很复杂，但是使用者可以非常简洁的调用API

class User(Model):
    #定义类的属性到列的映射：
    id = IntegerField('id')
    name = StringField('name')
    email = StringField('email')
    password = StringField('password')

例如：

#创建一个实例：
u = User(id=12345, name='Alice', email='test@orm.org', password='my-pwd')
#保存到数据库
u.save()

接下来我们来实现这么个功能：

#coding:utf-8
# 一：首先来定义Field类，它负责保存数据库的字段名和字段类型：
class Field(object):
    def __init__(self,name,column_type):
        self.name = name
        self.column_type = column_type
    def __str__(self):
        return '<%s:%s>' %(self.__class__.__name__,self.name)
    
class StringField(Field):
    def __init__(self,name):
        super(StringField,self).__init__(name,'varchar(100)')
        
class IntegerField(Field):
    def __init__(self,name):
        super(IntegerField, self).__init__(name,'bigint')
        
# 二 定义元类，控制Model对象的创建
class ModelMetaClass(type):
    #定义元类
    def __new__(cls, name, bases, attrs):
        if name == 'Model':
            return super(ModelMetaClass, cls).__new__(cls,name,bases,attrs)
        mappings = dict()
        for k,v in attrs.items():
            if isinstance(v,Field):
                #保存类属性和列的映射关系到mappings字典
                print('found mappings:%s==>%s' %(k, v))
                mappings[k] = v

            '''# 保存类属性和列的映射关系到mappings字典
            print('found mappings:%s==>%s' % (k, v))
            mappings[k] = v'''
        for k in mappings.keys():
            #将类属性移除，使定义的类字段不污染User类属性，只在实例中可以访问这些key
            attrs.pop(k)
        attrs['__table__'] = name.lower()#假设表名和类名的小写一样，创建类时添加一个__table__类属性
        attrs['__mappings__'] = mappings #保存属性和列的映射关系，创建类时添加一个__mappings__属性
        return super(ModelMetaClass, cls).__new__(cls,name,bases,attrs)

# 三 编写Model类
class Model(dict,metaclass=ModelMetaClass):
    __metaclass__ = ModelMetaClass

    def __init__(self, **kw):
        super(Model, self).__init__(**kw)

    def __getattr__(self, key):
        try:
            return self[key]
        except KeyError:
            raise AttributeError(r"'Model' object has no attribute'%s'" %key)

    def __setattr__(self, key, value):
        self[key] = value

    def save(self):
        fields = []
        params = []
        args = []
        for k, v in self.__mappings__.items():
            fields.append(v.name)
            params.append('?')
            args.append(getattr(self,k,None))
        sql = 'insert into %s (%s) values (%s)' %(self.__table__,','.join(fields), ','.join(params))
        print('SQL: %s' %sql)
        print('SRGS: %s' % str(args))

# 最后，我们使用定义好的ORM接口，使用起来非常的简单。
class User(Model):
    # 定义类的属性到列的映射：
    id = IntegerField('id')
    name = StringField('username')
    email = StringField('email')
    password = StringField('password')

# 创建一个实例：
u = User(id=12345, name='Michael', email='test@orm.org', password='my-pwd')
# 保存到数据库：
u.save()

'''
输出：
found mappings:id==><IntegerField:id>
found mappings:name==><StringField:username>
found mappings:email==><StringField:email>
found mappings:password==><StringField:password>
SQL: insert into user (id,username,email,password) values (?,?,?,?)
SRGS: [12345, 'Michael', 'test@orm.org', 'my-pwd']
'''

五：使用__new__ 方法和元类方式分别实现单例模式

1、__new__、__init__、__call__的介绍

__new__方法负责创建一个实例对象，在对象被创建的时候调用该方法它是一个类方法。__new__方法返回一个实例之后，会自动的调用__init__方法，对实例进行初始化。如果__new__方法不返回值，或者返回的不是实例，那么它就不会自动的去调用__init__方法。

__init__方法负责将该实例对象进行初始化，在对象被创建之后调用该方法，在__new__方法创建出一个实例之后对实例属性进行初始化。__init__方法可以没有返回值。

 

__call__方法其实和类的创建过程和实例化没有多大关系了，定义了__call__方法才能以函数的方式被执行。例如：

class A(object):
    def __call__(self):
        print('__call__ be called')

a = A()
a()
#输出为：__call__ be called

#coding:utf-8
class Foo(object):
    def __new__(cls, *args, **kwargs):
        #__new__是一个类方法，在对象创建的时候调用
        print("excute __new__")
        return super(Foo,cls).__new__(cls,*args,**kwargs)

    def __init__(self):
        #__init__是一个实例方法，在对象创建后调用，对实例属性做初始化
        print("excute __init")

f1 = Foo()
'''
输出：
excute __new__
excute __init
'''
#可以看出new方法在init方法之前执行

子类如果重写__new__方法，一般依然要调用父类的__new__方法

class Child(Foo):
    def __new__(cls, *args, **kwargs):        
        return super(Child, cls).__new__(cls, *args, **kwargs)

必须注意的是，类的__new__方法之后，必须生成本类的实例才能自动调用本类的__init__方法进行初始化，否则不会自动调用__init__.

class Foo(object):
    def __init__(self, *args, **kwargs):
        print('Foo __init__')
    def __new__(cls, *args, **kwargs):
        return object.__new__(Stranger, *args, **kwargs)

class Stranger(object):
    def __init__(self,name):
        print("class Stranger's __init__ be called" )
        self.name = name

foo = Foo('test')
print(type(foo))
print(foo.name)

'''
输出：
<class '__main__.Stranger'>
Traceback (most recent call last):
  File "E:/py/awesome-python3-webapp/test/singleClass_demo.py", line 38, in <module>
    print(foo.name)
AttributeError: 'Stranger' object has no attribute 'name'
'''
# 说明：如果new方法返回的不是本类的实例，那么本类（Foo）的init和
# 生成的类(Stranger)的init都不会被调用

2 实现单例模式：

 依照python官方文档的说法，__new__方法主要是当你继承一些不可变的class时（比如int，str，tuple）时，提供给你一个自定义这些类的实例化过程的途径。还有就是实现自定义的metaclass。接下来我们分别通过这两种方式来实现单例模式。

简单来说，单例模式的原理就是通过在类属性中添加一个判定为ins_flag，通过这个flag判断是否已经被实例化过了，如果被实例化过了就返回该实例。

1）__new__方法实现单例实例

class Singleton(object):
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls,"_instance"):
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
        return cls._instance
s1 = Singleton()
s2 = Singleton()
print(s1 is s2)

# True

因为重写__new__方法，所以继承至Singleton的类，在不重写__new__的情况下都将是单例模式。

2）元类实现单例

class Singleton(type):
    def __init__(self, *args, **kwargs):
        print('__init__')
        self.__instance = None
        super(Singleton,self).__init__(*args, **kwargs)

    def __call__(self, *args, **kwargs):
        print('__call__')
        if self.__instance is None:
            self.__instance = super(Singleton,self).__call__(*args, **kwargs)
        return self.__instance

class Foo(metaclass=Singleton):
    __metaclass__ = Singleton #在代码执行到这里的时候，元类中的__new__方法和__init__方法其实已经被执行了，而不是在Foo实例化的时候执行。且仅会执行一次。

foo1 = Foo()
foo2 = Foo()
print(Foo.__dict__)#'_Singleton__instance': <__main__.Foo object at 0x0000000002238B00>

#存在一个私有属性来保存属性，而不会污染Foo类（其实还是会污染，只是无法直接通过__instance属性访问）

 print(foo1 is foo2) ''' 输出： __init__ __call__ __call__ {'__module__': '__main__', '__metaclass__': <class '__main__.Singleton'>, '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None, '_Singleton__instance': <__main__.Foo object at 0x0000000002238B00>} True '''

基于这个例子：

• 我们知道元类(Singleton)生成的实例是一个类(Foo),而这里我们仅仅需要对这个实例(Foo)增加一个属性(__instance)来判断和保存生成的单例。想想也知道为一个类添加一个属性当然是在__init__中实现了。
• 关于__call__方法的调用，因为Foo是Singleton的一个实例。所以Foo()这样的方式就调用了Singleton的__call__方法。不明白就回头看看上一节中的__call__方法介绍。

假如我们通过元类的__new__方法来也可以实现，但显然没有通过__init__来实现优雅，因为我们不会为了为实例增加一个属性而重写__new__方法。所以这个形式不推荐。

class Singleton(type):
    def __new__(cls, name, bases, attrs):
        print('__new__')
        attrs["_instance"] = None
        return super(Singleton, cls).__new__(cls, name, bases, attrs)
    def __call__(self, *args, **kwargs):
        print('__call__')
        if self._instance is None:
            self._instance = super(Singleton, self).__call__(*args, **kwargs)
        return self._instance

class Foo(metaclass=Singleton):
    __metaclass__ = Singleton

foo1 = Foo()
foo2 = Foo()
print(Foo.__dict__)
print(foo1 is foo2)

'''
输出：
__new__
__call__
__call__
{'__module__': '__main__', '__metaclass__': <class '__main__.Singleton'>, '_instance': <__main__.Foo object at 0x00000000021F8C88>, '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None}
True
'''

python 类和元类(metaclass)的理解和简单运用

深刻理解Python中的元类(metaclass)