这期内容当中小编将会给大家带来有关python中metaclass的作用是什么，文章内容丰富且以专业的角度为大家分析和叙述，阅读完这篇文章希望大家可以有所收获。
创新互联是一家专注网站建设、网络营销策划、微信平台小程序开发、电子商务建设、网络推广、移动互联开发、研究、服务为一体的技术型公司。公司成立10多年以来，已经为上千三轮搅拌车各业的企业公司提供互联网服务。现在，服务的上千客户与我们一路同行，见证我们的成长；未来，我们一起分享成功的喜悦。
类也是对象
在理解metaclass之前，我们先要掌握python中的类(class)是什么。
python中类的概念，是借鉴自smalltalk语言。
在大部分语言中，类指的是"描述如何产生一个对象(object)"的一段代码,这对于python也是如此。
>>> class ObjectCreator(object): ... pass ... >>> my_object = ObjectCreator() >>> print(my_object) <__main__.ObjectCreator object at 0x8974f2c>
但是,在python中,类远不止如此，类同时也是对象。当你遇到关键词class的时候，python就会自动执行产生一个对象。下面的代码段中:
>>> class ObjectCreator(object): ... pass ...
python在内存中产生了一个名叫做"ObjectCreator"的对象。这个对象(类)自身拥有产生对象(实例instance)的能力。 这就是为什么称呼这东西(后面遇到容易混淆的地方,我们称之为:类对象)也是类的原因。同时，它也是一个对象，因此你可以对它做如下操作:
赋值给变量
复制它
为它增加属性(attribute)
作为参数传值给函数
举例：
>>> print(ObjectCreator) # 你可以打印一个类,因为它同时也是对象 >>> def echo(o): ... print(o) ... >>> echo(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 # 将类赋值给变量 >>> print(ObjectCreatorMirror.new_attribute) foo >>> print(ObjectCreatorMirror()) <__main__.ObjectCreator object at 0x8997b4c>
动态创建类
既然类也是对象，那么我们就可以在运行的时候创建它，跟创建对象一样自然。
首先，我们使用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 >>> print(MyClass()) # you can create an object from this class <__main__.Foo object at 0x89c6d4c>这很容易理解吧。但是，这并不那么动态啊。我们还是需要自己来写这个类的代码。
既然类也是对象，那就应该有用来产生它的东西。这东西就是type。
先来说说你所认识的type。这个古老而好用的函数，可以让我们知道一个对象的类型是什么。
>>> print(type(1)) >>> print(type("1")) >>> print(type(ObjectCreator)) >>> print(type(ObjectCreator()))
实际上，type还有一个完全不同的功能，它可以在运行时产生类。type可以传入一些参数，然后返回一个类。(好吧，必须承认，根据不同的传入参数，一个相同的函数type居然会有两个完全不同的作用，这很愚蠢。不过python这样做是为了保持向后兼容性。)
下面举例type创建类的用法。首先，对于类一般是这么定义的:
>>> class MyShinyClass(object): ... pass
在下面，MyShinyClass也可以这样子被创建出来,并且跟上面的创建方法有一样的表现:
>>> MyShinyClass = type('MyShinyClass', (), {}) # returns a class object >>> print(MyShinyClass) >>> print(MyShinyClass()) # create an instance with the class <__main__.MyShinyClass object at 0x8997cec>type创建类需要传入三个参数,分别为:
类的名字
一组"类的父类"的元组(tuple) (这个会实现继承,也可以为空)
字典 (类的属性名与值,key-value的形式，不传相当于为空，如一般写法中的pass).
下面来点复杂的，来更好的理解type传入的三个参数:
class Foo(object): bar = True def echo_bar(self): print(self.bar)
等价于:
def echo_bar(self): print(self.bar) Foo = type('Foo', (), {'bar':True, 'echo_bar': echo_bar})想要看点有继承关系的类的实现,来:
class FooChild(Foo): pass
等价于:
FooChild = type('FooChild', (Foo, ), {})回顾一下我们学到哪了: 在python中，类就是对象，并且你可以在运行的时候动态创建类.
那到底什么是metaclass(元类)
metaclass 就是创建类的那家伙。(事实上,type就是一个metaclass)
我们知道,我们定义了class就是为了能够创建object的，没错吧?
我们也学习了，python中类也是对象。
那么，metaclass就是用来创造“类对象”的类.它是“类对象”的“类”。
可以这样子来理解:
MyClass = MetaClass() MyObject = MyClass()
也可以用我们上面学到的type来表示:
MyClass = type('MyClass', (), {})说白了,函数type就是一个特殊的metaclass.
python在背后使用type创造了所有的类。type是所有类的metaclass.
我们可以使用__class__属性来验证这个说法.
在python中，一切皆为对象：整数、字符串、函数、类.所有这些对象，都是通过类来创造的.
>>> age = 35 >>> age.__class__ >>> name = 'bob' >>> name.__class__ >>> def foo(): pass >>> foo.__class__ >>> class Bar(object): pass >>> b = Bar() >>> b.__class__
那么，__class__的__class__又是什么呢?
>>> age.__class__.__class__ >>> name.__class__.__class__ >>> foo.__class__.__class__ >>> b.__class__.__class__
metaclass就是创造类对象的工具.如果你喜欢，你也可以称之为"类的工厂".
type是python內置的metaclass。不过，你也可以编写自己的metaclass.
__metaclass__ 属性
我们可以在一个类中加入 __metaclass__ 属性.
class Foo(object): __metaclass__ = something... [...]
当你这么做了，python就会使用metaclass来创造类:Foo。
注意啦，这里有些技巧的。
当你写下class Foo(object)的时候，类对象Foo还没有在内存中生成。
python会在类定义中寻找__metaclass__ 。如果找到了，python就会使用这个__metaclass__ 来创造类对象: Foo。如果没找到，python就使用type来创造Foo。
请把下面的几段话重复几遍：
当你写如下代码的时候:
class Foo(Bar): pass
python做了以下事情:
Foo中有__metaclass__这个属性吗?
如果有，python会在内存中通过__metaclass__创建一个名字为Foo的类对象。
如果python没有在Foo中找到__metaclass__，它会继续在Bar(父类)中寻找__metaclass__，并尝试做和前面同样的操作。
如果python由下往上遍历父类也都没有找不到__metaclass__，它就会在模块(module)中去寻找__metaclass__，并尝试做同样的操作。
如果还是没有找不到__metaclass__， python才会用内置的type(这也是一个metaclass)来创建这个类对象。
现在问题来了,我们要怎么用代码来实现__metaclass__呢? 写一些可以用来产生类(class)的东西就行。
那什么可以产生类?无疑就是type，或者type的任何子类,或者任何使用到type的东西都行.
自定义metaclass
使用metaclass的主要目的，是为了能够在创建类的时候，自动地修改类。
一个很傻的需求，我们决定要将该模块中的所有类的属性，改为大写。
有几种方法可以做到，这里使用__metaclass__来实现.
在模块的层次定义metaclass,模块中的所有类都会使用它来创造类。我们只需要告诉metaclass,将所有的属性转化为大写。
# 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): 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,而不是改写父类的__type__方法.
所以我们也可以这样子处理:
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 return type.__new__(upperattr_metaclass, future_class_name, future_class_parents, uppercase_attr)这样子看,我们只是复用了 type.__new__方法,这就是我们熟悉的基本的OOP编程，没什么魔法可言.
你可能注意到,__new__方法相比于
type(future_class_name, future_class_parents, future_class_attr)
多了一个参数: upperattr_metaclass, 请别在意,这没什么特别的: __new__总是将"它要定义的类"作为***个参数。
这就好比是 self 在类的一般方法(method)中一样,也是被作为***个参数传入。
当然啦，这里的名字的确是我起的太长了。就像self一样，所有的参数都有它们传统的名称。因此，在实际的代码中,一个metaclass应该是写成下面样子的:
(我们同时使用常见的super来让代码更清晰)
class UpperAttrMetaclass(type): def __new__(cls, clsname, bases, attrs): uppercase_attr = {} for name, val in attrs.items(): if not name.startswith('__'): uppercase_attr[name.upper()] = val else: uppercase_attr[name] = val return super(UpperAttrMetaclass, cls).__new__(cls, clsname, bases, attrs)使用了 metaclass 的代码是比较复杂，但我们使用它的原因并不是为了复杂, 而是因为我们通常会使用 metaclass 去做一些晦涩的事情,比如, 依赖于自省，控制继承等等。
确实，用 metaclass 来搞些“黑魔法”是特别有用的，因而会复杂化代码。
但就metaclass本身而言，它们其实是很简单的：中断类的默认创建、修改类、***返回修改后的类.
到底为什么要使用metaclass
现在我们面临一个问题: 为什么要使用metaclass? 它容易出错且晦涩难懂.
好吧，一般来说，我们根本就用不上它, 99%的用户应该根本不必为此操心。
实际用到metaclass的人，很清楚他们到底需要做什么,根本不用解释为什么要用.
metaclass 的一个主要用途就是构建API。Django(一个python实现的web框架)的ORM 就是一个例子。
用Django先定义了以下Model:
class Person(models.Model): name = models.CharField(max_length=30) age = models.IntegerField()
然后执行下面代码:
guy = Person.objects.get(name='bob') print guy.age # result is 35
这里打印的输出并不是IntegerField，而是一个int，int是从数据库中获取的.
这是因为 models.Model 使用 __metaclass__来实现了复杂的数据库查询。但对于你看来,这就是简单的API而已,不用关心背后的复杂工作。
上述就是小编为大家分享的python中metaclass的作用是什么了，如果刚好有类似的疑惑，不妨参照上述分析进行理解。如果想知道更多相关知识，欢迎关注创新互联行业资讯频道。
本文名称：python中metaclass的作用是什么
文章地址：
http://cdxtjz.cn/article/jchdic.html
