深入理解 Python 元类

>>> class ObjectCreator(object):
...     pass
...
>>> my_object = ObjectCreator()
>>> print my_object
<__main__.objectcreator object at>

>>> class ObjectCreator(object):
...     pass
...

>>> print ObjectCreator  # 你可以打印一个类，因为它其实也是一个对象
'__main__.ObjectCreator'>
>>> def echo(o):
...     print o
...
>>> echo(ObjectCreator)                 # 你可以将类做为参数传给函数
'__main__.ObjectCreator'>
>>> print hasattr(ObjectCreator, 'new_attribute')
False
>>> ObjectCreator.new_attribute = 'foo'  #  你可以为类增加属性
>>> print hasattr(ObjectCreator, 'new_attribute')
True
>>> print ObjectCreator.new_attribute
foo
>>> ObjectCreatorMirror = ObjectCreator  # 你可以将类赋值给一个变量
>>> print ObjectCreatorMirror()
<__main__.objectcreator object at>

>>> def choose_class(name):
...     if name == 'foo':
...         class Foo(object):
...             pass
...         return Foo    # 返回的是类，不是类的实例
...     else:
...         class Bar(object):
...             pass
...         return Bar
...
>>> MyClass = choose_class('foo')
>>> print MyClass  # 函数返回的是类，不是类的实例
'__main__.Foo'>
>>> print MyClass()            # 你可以通过这个类创建类实例，也就是对象
<__main__.foo object at>

>>> print type(1)
type 'int'>
>>> print type("1")
type 'str'>
>>> print type(ObjectCreator)
type 'type'>
>>> print type(ObjectCreator())
'__main__.ObjectCreator'>

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

>>> class MyShinyClass(object):
…       pass

>>> MyShinyClass = type('MyShinyClass', (), {})  # 返回一个类对象
>>> print MyShinyClass
'__main__.MyShinyClass'>
>>> print MyShinyClass()  # 创建一个该类的实例
<__main__.myshinyclass object at>

>>> class Foo(object):
…       bar = True

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

>>> print Foo
'__main__.Foo'>
>>> print Foo.bar
True
>>> f = Foo()
>>> print f
<__main__.foo object at>
>>> print f.bar
True

>>> class FooChild(Foo):
...     pass

>>> FooChild = type('FooChild', (Foo,), {})
>>> print FooChild
'__main__.FooChild'>
>>> print FooChild.bar  # bar属性是由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

MyClass = MetaClass()
MyObject = MyClass()

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

>>> age = 30
>>> 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__
'__main__.Bar'>

>>> age.__class__.__class__
type 'type'>
>>> foo.__class__.__class__
type 'type'>
>>> b.__class__.__class__
type 'type'>

class Foo(object):
    __metaclass__ = something...

class Foo(Bar):
    pass

# 元类会自动将你通常传给 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)
    # 通过 type 来做类对象的创建
    return type(future_class_name, future_class_parents, upper_attr)

# 这会作用到这个模块中的所有类
__metaclass__ = upper_attr

class Foo(object):
    # 我们也可以在这里定义__metaclass__，这样就只会作用于这个类中
    bar = 'bip'

print hasattr(Foo, 'bar')
# 输出: False
print hasattr(Foo, 'BAR')
# 输出：True

f = Foo()
print f.BAR
# 输出：'bip'

# 记住，type 实际上是一个类，就想 str 和 int 一样
# 所以，你可以从 type 继承
class UpperAttrMetaClass(type):
    # __new__ 是在 __init__ 之前被调用的特殊方法
    # __new__ 是用来创建对象并返回的方法
    # 而 __init__ 只是用来将传入的参数初始化给对象
    # 你很少用到 __new__，除非你希望能够控制对象的创建
    # 这里，创建的对象是类，我们希望能够自定义它，所以我们这里重写 __new__
    # 如果你希望的话，也可以在 __init__ 中做一些事情
    # 还有一些高级的用法会涉及到改写 __call__ 特殊方法
    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)

        # 复用type.__new__方法，这就是基本的OOP编程，没什么魔法
        return type.__new__(upperattr_metaclass, future_class_name, future_class_parents, uppercase_attr)

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)

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)

class Person(models.Model):
    name = models.CharField(max_length=30)
    age = models.IntegerField()

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

>>> class Foo(object): pass
...
>>> id(Foo)
140263822460752