这篇文章中总结了 Python 中面向对象的一些知识，在结尾处我们谈到了类对象和实例对象，实例对象是由类对象创建出来的，那么类对象是由什么创建出来的呢？这就是今天要总结的元类。

类对象的创建时机

类是什么时候创建的呢？我们可以进行一下验证：

class Test(object):
    print("我被创建啦！！")

运行代码：

我被创建啦！！

上例中，我们并没有做任何调用操作，Test 类内部的代码自动执行了，也就是说，当解释器执行到 class 关键字的时候，类就开始创建了。

动态创建类

我们也可以将类的创建放在条件判断中，以根据不同的条件创建类：

def createClass(flag):
    if flag:
        class Foo(object):
            print("Foo 被创建啦")
        return Foo
    else:
        class Boo(object):
            print("Boo 被创建啦")
        return Boo

createClass(True)

运行结果：

Foo 被创建啦

type

除了使用上面的条件判断，我们还可以使用 type 函数动态创建类。是的，除了判断变量的类型之外，我们还可以使用 type 函数动态创建类，使用方法如下：

类对象 = type("类名", 父类对象, 类属性)

其中父类对象是一个包含了父类的元组，类属性是一个包含了属性的字典。
看一下代码：

# 定义 __str__ 方法
def __str__(self):
    return "我是 Test 类"
# 动态创建 Test 类
Test = type("Test",(),{"__str__":__str__})
# 创建类实例
print(Test())

运行结果：

我是 Test 类

元类

上面我们使用 type 函数动态创建了一个类 Test，使用 type 可以创建类对象，我们称它为元类。所有类的元类都是 type（包括 type 自身）。

__class__

使用 __class__ 属性可以查看一个对象的创建者，类也是对象，因此我们也可以使用 __class__ 查看类的元类：

class Test(object):
    pass

print(Test().__class__)
print(Test.__class__)
print(type.__class__)
print(object.__class__)

运行效果：

<class '__main__.Test'>
<class 'type'>
<class 'type'>
<class 'type'>

可见，所有类的元类都是 type，包括 type 自身和 object。

metaclass

除了在外部使用 type 动态创建类之外，我们还可以在类的内部指定其的创建方式，这就需要使用
metaclass，metaclass 是一个函数，在类创建时传入。该函数接受三个参数：

• 类名
• 父类
• 类内部的属性

我们来看下实现代码：

def createClass(cls_name,cls_parent,cls_attr):
    attr = {}
    for k,v in cls_attr.items():
        if not k.startswith("__"):
            # 处理非私有属性
            # 将属性名转化为大写
            attr[k.upper()] = v
        else:
            # 处理非私有属性
            # 将属性名转化为大写
            attr["%s%s"%(cls_name,k.upper())] = v
    # 返回一个类，该类仍然由 type 创建
    return type(cls_name,cls_parent,attr)

class Test(object,metaclass = createClass):
    name = "Test"
    privateAttr = "10086"

# 创建类的实例
t = Test()

通过指定 metaclass，我们可以规定 Test 类的创建方法，在 createClass 方法中，我们对属性名进行大写转换，并进行了私有化的处理。最后返回一个使用 type 动态创建的类。
我们对类属性进行了大写转化，因此使用原始的属性名将获取不到数据：

...
# 创建类的实例
t = Test()
print(t.name)

运行结果：

Traceback (most recent call last):
  File "C:\Users\Charley\Desktop\py\py.py", line 21, in <module>
    print(t.name)
AttributeError: 'Test' object has no attribute 'name'

我们使用大写的属性名可以正常获取数据：

...
# 创建类的实例
t = Test()
print(t.NAME)

运行结果：

Test

Python2 中的 __metaclass__

上面的 metaclass 是 Python3 中的创建方式，在 Python2 中，需要改为 __metaclass__ 属性。
下面是 Python2 中的参考代码：

def createClass(cls_name,cls_parent,cls_attr):
    attr = {}
    for k,v in cls_attr.items():
        if not k.startswith("__"):
            # 处理非私有属性
            # 将属性名转化为大写
            attr[k.upper()] = v
        else:
            # 处理非私有属性
            # 将属性名转化为大写
            attr["%s%s"%(cls_name,k.upper())] = v
    # 返回一个类，该类仍然由 type 创建
    return type(cls_name,cls_parent,attr)

class Test:
    __metaclass__ = createClass()
    name = "Test"
    privateAttr = "10086"

# 创建类的实例
t = Test()
print(t.NAME)

总结

本文主要介绍了元类的知识点，下面是一些总结：

• 类也是对象，叫做类对象，创建类对象的类叫做元类
• 类可以动态创建
• type 是所有类包括其自身的元类
• 在类中可以使用 metaclass（Python3）和 __metaclass__（Python2）定义类的创建方式

完。