Python中的类
在理解元类之前，你需要了解Python中的类。Python中的类借鉴自Smalltalk。
在大多数编程语言中，类只是描述对象生成方式的一段代码，在Python里面看起来也是这样。比如下面的代码
>>> class ObjectCreator(object):pass
...
>>> my_object = ObjectCreator()
>>> print(my_object)
<__main__.ObjectCreator object at 0x1008e4a90>
但在Python中，类也是对象。是的，类是对象
class关键字声明了一个类，Python会执行class这一段代码，生成一个对象，下面的操作在内存中创建一个对象，取名为"ObjectCreator"。
>>> class ObjectCreator(object): pass
这个类可以创建自己的对象，这也是类的功能。
但是它本身也是一个对象，因此
可以将它赋值给一个变量
可以复制
可以往里边添加属性
也可以将其作为参数传入一个函数
举个例子
>>> class ObjectCreator(object): pass
...
>>> print(ObjectCreator)
>>> def echo(o): print(o)
...
>>> echo(ObjectCreator)
>>> ObjectCreator.new_attribute = 'foo'
>>> print(hasattr(ObjectCreator, 'new_attribute'))
True
>>> print(ObjectCreator.new_attribute)
foo
>>> ObjectCreatorMirror = ObjectCreator
>>> print(ObjectCreatorMirror.new_attribute)
foo
>>> id(ObjectCreatorMirror)
140433925632016
>>> id(ObjectCreator)
140433925632016
>>> print(ObjectCreatorMirror())
<__main__.ObjectCreator object at 0x1072342d0>
动态生成类
就像对象一样，类也可以动态生成，因为它本身就是对象。
可以在函数中用class来创建一个类
>>> 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)
>>> print(MyClass())
<__main__.Foo object at 0x107234290>
上面的函数这也并不是那么智能，因为还是要完成得定义一个类。
既然类也是对象，那么一定有办法可以生成类。
当使用class关键字时，Python会自动创建类。和其他特性一样，Python也提供了手动创建类的方式。
还记得type这个函数吗？这个函数可以让你知道一个对象的类型：
>>> print(type(1))
>>> print(type("1"))
>>> print(type(ObjectCreator))
>>> print(type(ObjectCreator()))
这个函数还有另外的功能，就是动态创建类，它通过传入类的描述作为参数来做到这一点。
(同一个函数根据不同的参数有完全不同的两个共同，这看起来确实有点奇怪。这是Python为了向后兼容而引入的一个问题)。
可以这样使用type
type(name of the class,
tuple of the parent class (for inheritance, can be empty),
dictionary containing attributes names and values)
举个例子
>>> class MyShinyClass(object): pass
可以这样被创建
>>> MyShinyClass = type('MyShinyClass', (), {})
>>> print(MyShinyClass)
>>> print(MyShinyClass())
<__main__.MyShinyClass object at 0x109250ad0>
>>>
可以看到，类的名称被当作是参数传给了type。type通过字典来定义类的属性，比如
>>> class Foo(object): bar = True
等同于
>>> Foo = type('Foo', (), {'bar': True})
通过type定义的类可以像用class定义的类一样使用
>>> print(Foo)
>>> print(Foo.bar)
True
>>> f = Foo()
>>> print(f)
<__main__.Foo object at 0x109250b50>
>>> print(f.bar)
True
>>>
当然也可以编写子类类继承它
>>> class FooChild(Foo): pass
等同于
>>> FooChild = type('FooChild', (Foo,), {})
>>> print(FooChild)
>>> print(FooChild.bar)
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
在动态创建类之后，也可以添加方法，效果和在创建的时候添加方法一样。
>>> def echo_bar_more(self): print('yet another method')
...
>>> FooChild.echo_bar_more = echo_bar_more
>>> hasattr(FooChild, 'echo_bar_more')
True
可以看到Python中的类也是对象，可以随时，动态地创建类。
在使用class关键字后，Python也是通过这样的方法，使用元类创建类的。
元类
一般定义一个类，是为了创建对象，对吧？
但是我们已经知道在Python中类也是对象。
元类就是类的类，它用来创建类。大概像下面这样
MyClass = MetaClass()
MyObject = MyClass()
之前讲过，可以这样用type
MyClass = type('MyClass', (), {})
可以这样用，是因为type函数实际上是一个元类，Python就是用type来创建类。
也许你会问，那为什么type不写成Type呢？
我只能猜测这是为了和str，int这样能创建对象的关键词保持一致，所以首字母用了小写。
通过查看__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__
>>> type.__class__
所以元类就是类的类，它创建的对象是类。
也可以叫它“工厂类”。
type是Python内置的元类，但是你也可以创建自己的元类。
__metaclass__属性
在创建一个类的时候可以加上__metaclass__属性，比如下面这样
class Foo(object):
__metaclass__ = something ...
[...]
如果这样写，Python会用自定义的元类来创建Foo。
小心，这样可能会带来风险。
在写class Foo(object)的时候，Foo这个类并没有在内存中创建这个类的实例。
Python会在类的定义中寻找__metaclass__这个属性，如果找到了，就用这个元类创建Foo，如果找不到，就用type来创建这个类。
所以在下面的代码中
class Foo(Bar): pass
Python会执行下面的逻辑
Foo中有__metaclass__这个属性吗？
如果有，就用__metaclass__定义的元类来创建Foo这个类；
如果找不到__metaclass__这个属性，Python会在模块中寻找__metaclass__，如果找到了，就用它来创建Foo这个类；
如果还是找不到，Python会用Bar的元类（应该是type）来创建Foo这个类。
注意，子类不会继承__metaclass__这个属性，但是会继承父类的元类。就是说，如果Bar使用__metaclass__这个属性来创建Bar这个类，子类不会继承这个行为。
现在问题来了，__metaclass__里面的内容可以是什么呢？
答案是：可以创建类的内容
什么可以创建一个类呢？type，type的子类，或者用到了type的类
自定义元类
元类的主要作用是在创建类的时候改变这个类。
根据当前的上下文创建类，这个特性可以用来开发API。
举个简单例子，现在你想要模块中所有的类中的属性都是大写开头的。有很多种方式来实现这一点，现在我们通过使用修改模版中的__metaclass__属性来做到这一点。
这样，这个模块中所有的类都会用自定义的元类来创建，我们只需要在元类中将类中的所有属性首字母改成大写。
幸运的是，__metaclass__是可以被调用的，所以不必是“类”。
下面来看看例子吧
def upper_attr(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)
__metaclass__ = upper_attr
class Foo():
bar = 'bip'
print(hasattr(Foo, 'bar'))
# 输出: False
print(hasattr(Foo, 'BAR'))
# 输出: True
f = Foo()
print(f.BAR)
# 输出：bip
现在我们用类来实现一个元类
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(future_class_name, future_class_parents, uppercase_attr)
但是上面的方法没有用到type类中的方法，我们可以通过调用type中的__new__方法来实现
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)
可能你注意到了上面代码中的upperattr_metaclass参数，这没有什么特别的，__new__方法总是会将定义它的类作为第一个参数传入，这就和self一样，上面的例子中，把
upperattr_metaclass打印出来，可以看到类似的结果。
当然，这里的取名只是为了说清明这些变量，但就和self一样，这些参数都有固定的取名，比如下面这样
class UpperAttrMetaclass(type):
def __new__(cls, clsname, bases, dct):
uppercase_attr = {}
for name, val in dct.items():
if not name.startswith('__'):
uppercase_attr[name.upper()] = val
else:
uppercase_attr[name] = val
return type.__new__(cls, clsname, bases, uppercase_attr)
为了让UpperAttrMetaclass继承自type这一特性表现的更清楚，可以使用super
class UpperAttrMetaclass(type):
def __new__(cls, clsname, bases, dct):
uppercase_attr = {}
for name, val in dct.items():
if not name.startswith('__'):
uppercase_attr[name.upper()] = val
else:
uppercase_attr[name] = val
return super(UpperAttrMetaclass, cls).__new__(cls, clsname, bases, uppercase_attr)
代码中使用元类，可以实现一些黑科技。而元类本身只实现下面的功能。
中断类的创建
修改类
返回修改后的类
元类实现的取舍
既然__metaclass__可以是任意可调用的对象，为什么要用类而不是函数来实现它呢？
主要考虑到下面几个原因
语义上更清晰。
面向对象。元类可以继承自元类，元类甚至可以使用元类。
代码结构更清晰。
可以根据不同想法，在__new__,__init__,__call__不同的函数中实现不同的功能
既然都叫元类了，那肯定就是类嘛！
为什么要使用元类
现在还有一个问题，为什么要使用这样一个令人费解的功能呢？
当然，一般情况下，这个功能不会被用到
99%的人都不会用到元类，如果你还在想是否要用它，那么你就不需要用到它（真正有需求用它的人不会问这个问题） Python Guru Tim Peters
元类的主要功能是用来开发API。一个典型的例子就是Django ORM，它可以这样定义一个model
class Person(models.Model):
name = models.CharField(max_length=30)
age = models.IntegerField()
但是下面的代码却不会返回一个IntegerField的对象，而是返回一个int，甚至可以从数据库中去取这个值。
guy = Person(name='bob', age='35')
print(guy.age)
之所以能这样实现，是因为model.Model中定义了__metaclass__，通过定义的元类将Person类转换成一条SQL语句。
Django通过元类将代码改写，这样就可以只暴露简单的API，而实现复杂的功能。
结语
类可以用来创建对象。
而事实上，类本身也是对象，元类的对象。
>>> class Foo(object): pass
>>> id(Foo)
>>> 140257261595760
Python中万物都是对象，它们要么是类的实例，要么是元类的实例。
除了type。
type是它自己的元类，Python在实现层面，做了一些工作来实现这一点。
元类是很复杂的。比较简单的场景不一定要用到它，要改变一个类，可以通过下面两种技术实现
如果需要改变类的行为，99%情况下应该使用上面的两种方法。
但是99%情况下，根本就不需要改变类的行为
“本译文仅供个人研习、欣赏语言之用，谢绝任何转载及用于任何商业用途。本译文所涉法律后果均由本人承担。本人同意简书平台在接获有关著作权人的通知后，删除文章。”
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
