Python의 메타클래스에 대한 깊은 이해

주석: 이 게시물은 스택 오버플로에 대해 매우 인기 있는 게시물입니다. 질문자는 Python OOP 프로그래밍의 다양한 개념을 마스터했다고 주장했지만 항상 메타클래스를 이해하기 어려웠습니다. 그는 이것이 자기 성찰과 관련이 있다는 것을 알고 있지만 여전히 그것을 잘 이해하지 못하고 있습니다. 그는 모든 사람이 이해하는 데 도움이 되는 몇 가지 실용적인 예와 코드 조각을 제공하고 어떤 상황에서 메타프로그래밍이 필요한지 알 수 있기를 바랍니다. 그래서 e-satis는 신과 같은 답변을 내놓았고, 985점을 받았습니다. 어떤 사람들은 이 답변을 파이썬 공식 문서에 추가해야 한다는 의견도 있었습니다. Stack Overflow에서 e-satis 학생의 평판 점수는 64,271점에 달합니다. 다음은 이 멋진 답변입니다(팁: 매우 길어요)

클래스도 객체입니다

메타클래스를 이해하기 전에 먼저 Python에서 클래스를 마스터해야 합니다. Python의 클래스 개념은 Smalltalk에서 빌려온 것인데, 조금 이상해 보입니다. 대부분의 프로그래밍 언어에서 클래스는 개체를 만드는 방법을 설명하는 코드 세그먼트 집합입니다. 이는 Python에서도 여전히 적용됩니다.

>>> class ObjectCreator(object):
…       pass
…
>>> my_object = ObjectCreator()
>>> print my_object

<__main__.ObjectCreator object at 0x8974f2c>

그러나 Python의 클래스는 그 이상입니다. 클래스도 객체입니다. 예, 맞습니다. 그게 바로 그 대상입니다. class 키워드를 사용하는 한 Python 인터프리터는 실행 중에 객체를 생성합니다. 다음 코드 조각:

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

은 ObjectCreator라는 이름의 객체를 메모리에 생성합니다. 이 객체(클래스) 자체가 객체(클래스 인스턴스)를 생성하는 능력을 갖고 있고, 그것이 바로 클래스인 이유입니다. 그러나 그 본질은 여전히 ​​객체이므로 다음 작업을 수행할 수 있습니다.

1) 변수에 할당할 수 있습니다

2) 복사할 수 있습니다

3) 속성을 추가할 수 있습니다

4) 함수 매개변수로 전달할 수 있습니다

예:

>>> print ObjectCreator

# 클래스는 실제로 객체이기 때문에 인쇄할 수 있습니다

>>> def echo(o):
…       print o
…
>>> echo(ObjectCreator)

# 클래스를 함수에 매개변수로 전달할 수 있습니다

>>> print hasattr(ObjectCreator, 'new_attribute')

Fasle

>>> ObjectCreator.new_attribute = 'foo'

# 클래스에 속성을 추가할 수 있습니다

>>> print hasattr(ObjectCreator, 'new_attribute' )

참

>>> print ObjectCreator.new_attribute

foo

>>> ObjectCreatorMirror = ObjectCreator

# 가능합니다. 클래스는 다음과 같습니다. 변수에 할당됨

>>> print ObjectCreatorMirror()

<__main__.ObjectCreator object at 0x8997b4c>

클래스를 동적으로 생성

객체이기도 하며 다른 객체와 마찬가지로 런타임에 동적으로 생성할 수 있습니다. 먼저, 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              
# 函数返回的是类，不是类的实例
<class &#39;__main__&#39;.Foo>
>>> print MyClass()            
# 你可以通过这个类创建类实例，也就是对象
   
<__main__.Foo object at 0x89c6d4c>

그러나 전체 클래스를 직접 코딩해야 하기 때문에 이는 충분히 동적이지 않습니다. 클래스도 객체이기 때문에 무언가로부터 생성되어야 합니다. Python 인터프리터는 class 키워드를 사용할 때 자동으로 이 객체를 생성합니다. 그러나 Python의 대부분과 마찬가지로 Python은 여전히 ​​수동 방법을 제공합니다. 내장 함수 유형을 기억하시나요? 오래되었지만 강력한 이 기능을 사용하면 다음과 같이 객체의 유형을 알 수 있습니다.

>>> print type(1)

>>> print 유형("1")

>>> 인쇄 유형(ObjectCreator)

>> > 인쇄 유형( ObjectCreator())

여기서 type은 완전히 다른 기능을 가지며 클래스를 동적으로 생성할 수도 있습니다. 유형은 클래스 설명을 매개변수로 받아들이고 클래스를 반환할 수 있습니다. (전달된 매개변수에 따라 동일한 함수를 두 가지 완전히 다른 용도로 사용하는 것은 어리석은 일이지만 이는 Python의 이전 버전과의 호환성을 위한 것입니다.)

type은 다음과 같이 작동합니다:

유형(클래스 이름, 상위 클래스의 튜플(상속을 위해 비어 있을 수 있음), 속성이 포함된 사전(이름 및 값))

예를 들어 다음 코드:

>>> class MyShinyClass(object):
…       pass

은 다음과 같이 수동으로 생성할 수 있습니다:

>>> MyShinyClass = type('MyShinyClass', (), { })

# 클래스 반환 object

>>> print MyShinyClass

>>> print MyShinyClass()

# 이 클래스의 인스턴스 생성

<__main__.MyShinyClass object at 0x8997cec>

"MyShinyClass"를 클래스 이름으로 사용하고 클래스에 대한 참조로 변수로 사용할 수도 있습니다. 클래스와 변수는 다르기 때문에 여기서 일을 복잡하게 만들 이유가 없습니다.

type은 클래스의 속성을 정의하기 위해 사전을 허용하므로

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

은 다음과 같이 번역될 수 있습니다.

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

Foo를 일반 클래스로 사용할 수 있습니다:

>>> print Foo

>>> print Foo.bar

True

>>> f = Foo()

>>> print f

<__main__.Foo object at 0x8a9b84c>

>>> print f.bar

True

当然，你可以向这个类继承，所以，如下的代码：

>>> class FooChild(Foo):

… pass

就可以写成：

>>> FooChild = type('FooChild', (Foo,),{})

>>> print 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

你可以看到，在Python中，类也是对象，你可以动态的创建类。这就是当你使用关键字class时Python在幕后做的事情，而这就是通过元类来实现的。

到底什么是元类（终于到主题了）

元类就是用来创建类的“东西”。你创建类就是为了创建类的实例对象，不是吗？但是我们已经学习到了Python中的类也是对象。好吧，元类就是用来创建这些类（对象）的，元类就是类的类，你可以这样理解 为：

MyClass = MetaClass()

MyObject = MyClass()

你已经看到了type可以让你像这样做：

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

这是因为函数type实际上是一个元类。type就是Python在背后用来创建所有类的元类。现在你想知道那为什么type会全部采用小写形式而不是Type呢？好吧，我猜这是为了和str保持一致性，str是用来创建字符串对象的类，而int是用来创建整数对象的类。type就是创建类对象的类。你可以通过检查__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__属性又是什么呢？

>>> a.__class__.__class__

>>> age.__class__.__class__

>>> foo.__class__.__class__

>>> b.__class__.__class__

因此，元类就是创建类这种对象的东西。如果你喜欢的话，可以把元类称为“类工厂”（不要和工厂类搞混了:D） type就是Python的内建元类，当然了，你也可以创建自己的元类。

__metaclass__属性

你可以在写一个类的时候为其添加__metaclass__属性。

class Foo(object):

__metaclass__ = something…

[…]

如果你这么做了，Python就会用元类来创建类Foo。小心点，这里面有些技巧。你首先写下class Foo(object)，但是类对象Foo还没有在内存中创建。Python会在类的定义中寻找__metaclass__属性，如果找到了，Python就会用它来创建类Foo，如果没有找到，就会用内建的type来创建这个类。把下面这段话反复读几次。当你写如下代码时 :

class Foo(Bar):

pass

Python做了如下的操作：

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

现在的问题就是，你可以在__metaclass__中放置些什么代码呢？答案就是：可以创建一个类的东西。那么什么可以用来创建一个类呢？type，或者任何使用到type或者子类化type的东东都可以。

自定义元类

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

幸运的是，__metaclass__实际上可以被任意调用，它并不需要是一个正式的类（我知道，某些名字里带有‘class’的东西并不需要是一个class，画画图理解下，这很有帮助）。所以，我们这里就先以一个简单的函数作为例子开始。

# 元类会自动将你通常传给‘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'
print hasattr(Foo, 'bar')
# 输出: False
print hasattr(Foo, 'BAR')
# 输出:True
  
f = Foo()
print f.BAR
# 输出:'bip'

现在让我们再做一次，这一次用一个真正的class来当做元类。

# 请记住，'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)
但是，这种方式其实不是OOP。我们直接调用了type，而且我们没有改写父类的__new__方法。现在让我们这样去处理:
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)

你可能已经注意到了有个额外的参数upperattr_metaclass，这并没有什么特别的。类方法的第一个参数总是表示当前的实例，就像在普通的类方法中的self参数一样。当然了，为了清晰起见，这里的名字我起的比较长。但是就像self一样，所有的参数都有它们的传统名称。因此，在真实的产品代码中一个元类应该是像这样的：

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)
如果使用super方法的话，我们还可以使它变得更清晰一些，这会缓解继承（是的，你可以拥有元类，从元类继承，从type继承）
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)

就是这样，除此之外，关于元类真的没有别的可说的了。使用到元类的代码比较复杂，这背后的原因倒并不是因为元类本身，而是因为你通常会使用元类去做一些晦涩的事情，依赖于自省，控制继承等等。确实，用元类来搞些“黑暗魔法”是特别有用的，因而会搞出些复杂的东西来。但就元类本身而言，它们其实是很简单的：

1) 拦截类的创建

2) 修改类

3) 返回修改之后的类

为什么要用metaclass类而不是函数?

由于__metaclass__可以接受任何可调用的对象，那为何还要使用类呢，因为很显然使用类会更加复杂啊？这里有好几个原因：

1） 意图会更加清晰。当你读到UpperAttrMetaclass(type)时，你知道接下来要发生什么。

2） 你可以使用OOP编程。元类可以从元类中继承而来，改写父类的方法。元类甚至还可以使用元类。

3） 你可以把代码组织的更好。当你使用元类的时候肯定不会是像我上面举的这种简单场景，通常都是针对比较复杂的问题。将多个方法归总到一个类中会很有帮助，也会使得代码更容易阅读。

4） 你可以使用__new__, __init__以及__call__这样的特殊方法。它们能帮你处理不同的任务。就算通常你可以把所有的东西都在__new__里处理掉，有些人还是觉得用__init__更舒服些。

5） 哇哦，这东西的名字是metaclass，肯定非善类，我要小心！

究竟为什么要使用元类？

现在回到我们的大主题上来，究竟是为什么你会去使用这样一种容易出错且晦涩的特性？好吧，一般来说，你根本就用不上它：

“元类就是深度的魔法，99%的用户应该根本不必为此操心。如果你想搞清楚究竟是否需要用到元类，那么你就不需要它。那些实际用到元类的人都非常清楚地知道他们需要做什么，而且根本不需要解释为什么要用元类。” —— Python界的领袖 Tim Peters

元类的主要用途是创建API。一个典型的例子是Django ORM。它允许你像这样定义：

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

但是如果你像这样做的话：

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

   

这并不会返回一个IntegerField对象，而是会返回一个int，甚至可以直接从数据库中取出数据。这是有可能的，因为models.Model定义了__metaclass__， 并且使用了一些魔法能够将你刚刚定义的简单的Person类转变成对数据库的一个复杂hook。Django框架将这些看起来很复杂的东西通过暴露出一个简单的使用元类的API将其化简，通过这个API重新创建代码，在背后完成真正的工作。

 

结语

우선, 클래스는 실제로 클래스 인스턴스를 생성할 수 있는 객체라는 것을 알고 있습니다. 사실 클래스 자체는 인스턴스이고, 물론 메타클래스의 인스턴스이기도 합니다.

>>>class Foo(object): pass

>>> id(Foo)

Python의 모든 것은 객체이며, 클래스의 인스턴스이거나, 유형을 제외한 메타클래스의 인스턴스입니다. type은 실제로 자체 메타클래스입니다. 이는 순수 Python 환경에서 수행할 수 있는 작업이 아닙니다. 이는 구현 수준에서 몇 가지 트릭을 사용하여 수행됩니다. 둘째, 메타클래스는 복잡합니다. 매우 간단한 클래스의 경우 메타클래스를 사용하여 클래스를 수정하고 싶지 않을 수도 있습니다. 두 가지 다른 기술을 통해 클래스를 수정할 수 있습니다:

1) Monkey Patching

2) 클래스 데코레이터

클래스를 동적으로 수정해야 하는 경우 99%의 경우 위의 두 가지 기술을 사용하는 것이 더 좋습니다. 물론 실제로는 99%의 경우 클래스를 동적으로 수정할 필요가 전혀 없습니다 :D