python metaclass

学习python这么久对python的metaclass还是一知半解，网上找了找，发现stackoverflow太强大了： 
http://stackoverflow.com/questions/100003/what-is-a-metaclass-in-python
这个回答很详细，太厉害了，这里自己总结一下，免的忘记。

1. 类也是对象（class are object), 类在内存中也占有一段空间，所以

 

 

class Foo(object):pass  
id(Foo) #有值  
Foo.bar = 'bar'  #给类添加一个属性

 

2. 可以动态的创建类

type(class_name, class_parents, class_dict), 比如  
def echo_bar(self): print self.bar  
Foo = type('Foo', (object, ), {'bar':'bar', 'echo_bar', echo_bar})

3. metaclass是创建类的'stuff'，一般也可以理解成对象是类创建的， 类是metaclass创建的。
type is the metaclass Python uses to create all classes behind the scenes.
Everything, and I mean everything, is an object in Python. That includes ints, strings, functions and classes. All of them are objects. And all of them have been created from a class.
You can call it a 'class factory' if you wish.
4. __metaclass__属性
可以给类添加__metaclass__属性，在创建类时， python会查找(在自身，子类，模块中)是否定义了__metaclass__,有则用之来创建类， 否则用type来创建类
所以可以通过定义__metaclass__来改变类的创建方式，__metaclass__可以是任何可执行的东西，所以不一定需要是类。 这里就直接引用他的例子了。

# the metaclass will automatically get passed the same argument  
# that you usually pass to `type`  
def upper_attr(future_class_name, future_class_parents, future_class_attr):  
  """ 
    Return a class object, with the list of its attribute turned  
    into uppercase. 
  """  
  
  # pick up any attribute that doesn't start with '__'  
  attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__'))  
  # turn them into uppercase  
  uppercase_attr = dict((name.upper(), value) for name, value in attrs)  
  
  # let `type` do the class creation  
  return type(future_class_name, future_class_parents, uppercase_attr)  
  
__metaclass__ = upper_attr # this will affect all classes in the module  
  
class Foo(object):   
  # we can define __metaclass__ here instead to affect only this class  
  bar = 'bip'  
  
print hasattr(Foo, 'bar')  
# Out: False  
print hasattr(Foo, 'BAR')  
# Out: True  
  
f = Foo()  
print f.BAR  
# Out: 'bip' 

 

# remember that `type` is actually a class like `str` and `int`  
# so you can inherit from it  
class UpperAttrMetaclass(type):   
    # __new__ is the method called before __init__  
    # it's the method that creates the object and returns it  
    # while __init__ just initializes the object passed as parameter  
    # you rarely use __new__, except when you want to control how the object  
    # is created.  
    # here the created object is the class, and we want to customize it  
    # so we override __new__  
    # you can do some stuff in __init__ too if you wish  
    # some advanced use involves overriding __call__ as well, but we won't  
    # see this  
    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)  
  
        return type(future_class_name, future_class_parents, uppercase_attr) 

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)  
  
        # reuse the type.__new__ method  
        # this is basic OOP, nothing magic in there  
        return type.__new__(upperattr_metaclass, future_class_name,   
                            future_class_parents, uppercase_attr)  

Django中Model使用__metaclass__的例子

class Model(object):  
     __metaclass__ = ModelBase  
     _deferred = False  
.....