Python中的元类 -- metaclass

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Python中的元类 -- metaclass相关的知识,希望对你有一定的参考价值。

python从语法层面来看的难点就这么几个:

装饰器 decorator,

描述符 descripter,

元类 metaclass,

属性搜索优先级,

特殊方法,

 

类也是对象

当你使用class关键字时,Python解释器自动创建这个对象。

 

>>> class ObjectCreator(object):
...     pass
...     
>>> ObjectCreator
<class ObjectCreator>
>>> ObjectCreator()
<ObjectCreator object at 0x0414B590>

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

ObjectCreator,一个类对象

ObjectCreator(),返回一个实例对象

动态创建类对象

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

但就和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可以接受一个类的描述作为参数,然后返回一个类。(我知道,根据传入参数的不同,同一个函数拥有两种完全不同的用法是一件很傻的事情,但这在Python中是为了保持向后兼容性)

type的另一种用法:

 

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

 下面二者是等价的:

class Foo(object):
    bar = True

class FooChild(Foo):
    def echo_bar(self):
        print self.bar

>>>defecho_bar(self):
       printself.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

元类是什么

type实际上就是一个元类。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>


>>> a.__class__.__class__ <type ‘type‘> >>> age.__class__.__class__ <type ‘type‘> >>> foo.__class__.__class__ <type ‘type‘> >>> b.__class__.__class__ <type ‘type‘>

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

 __metaclass__属性

class Foo(object):
    __metaclass__ = something

Python做了如下的操作:

Foo中有__metaclass__这个属性吗?如果是,Python会在内存中通过__metaclass__创建一个名字为Foo的类对象(我说的是类对象,请紧跟我的思路)。如果Python没有找到__metaclass__,它会继续在Bar(父类)中寻找__metaclass__属性,并尝试做和前面同样的操作。如果Python在任何父类中都找不到__metaclass__,它就会在模块层次中去寻找__metaclass__,并尝试做同样的操作。如果还是找不到__metaclass__,Python就会用内置的type来创建这个类对象。

自定义元类

元类的主要目的就是为了当创建类时能够自动地改变类。通常,你会为API做这样的事情,你希望可以创建符合当前上下文的类。假想一个很傻的例子,你决定在你的模块里所有的类的属性都应该是大写形式。有好几种方法可以办到,但其中一种就是通过在模块级别设定__metaclass__。采用这种方法,这个模块中的所有类都会通过这个元类来创建,我们只需要告诉元类把所有的属性都改成大写形式就万事大吉了。

# 元类会自动将你通常传给‘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, uppercase_attr)
__metaclass__ = upper_attr # 这会作用到这个模块中的所有类
class Foo(object):
# 我们也可以只在这里定义__metaclass__,这样就只会作用于这个类中
bar = ‘bip‘
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)
        # return type(future_class_name, future_class_parents, uppercase_attr)
# return type.__new__(upperattr_metaclass, future_class_name, future_class_parents, uppercase_attr)
     return super(UpperAttrMetaclass, cls).__new__(cls, name, bases, uppercase_attr) 

这里还有一个实际的例子:来自于Odoo

class Meta(type):
    """ Metaclass that automatically decorates traditional-style methods by
        guessing their API. It also implements the inheritance of the
        :func:`returns` decorators.
    """

    def __new__(meta, name, bases, attrs):
        # dummy parent class to catch overridden methods decorated with ‘returns‘
        parent = type.__new__(meta, name, bases, {})

        for key, value in attrs.items():
            if not key.startswith(__) and callable(value):
                # make the method inherit from decorators
                value = propagate(getattr(parent, key, None), value)

                # guess calling convention if none is given
                if not hasattr(value, _api):
                    try:
                        value = guess(value)
                    except TypeError:
                        pass

                attrs[key] = value

        return type.__new__(meta, name, bases, attrs)

 guess()动态的修改了方法的参数(通过im_func.func_code.co_varnames)

 
















以上是关于Python中的元类 -- metaclass的主要内容,如果未能解决你的问题,请参考以下文章

深刻理解Python中的元类(metaclass)以及元类实现单例模式

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

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

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

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

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