原文：https://www.cnblogs.com/tkqasn/p/6524879.html

在看一些框架原始碼的過程中碰到很多元類的例項，看起來很吃力很晦澀；在看python cookbook中關於元類建立單例模式的那一節有些疑惑。因此花了幾天時間研究下元類這個概念。通過學習元類，我對python的面向物件有了更加深入的瞭解。這裡將一篇寫的非常好的文章基本照搬過來吧，這是一篇在Stack overflow上很熱的帖子，我看http://blog.jobbole.com/21351/這篇部落格對其進行了翻譯。

一、理解類也是物件

在理解元類之前，你需要先掌握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。這個物件（類）自身擁有建立物件（類例項）的能力，而這就是為什麼它是一個類的原因。但是，它的本質仍然是一個物件，於是你可以對它做如下的操作：
你可以將它賦值給一個變數， 你可以拷貝它， 你可以為它增加屬性， 你可以將它作為函式引數進行傳遞。

下面是示例：

print ObjectCreator     # 你可以列印一個類，因為它其實也是一個物件
#輸出：<class '__main__.ObjectCreator'>

Idef echo(o):
     print o

echo(ObjectCreator)                 # 你可以將類做為引數傳給函式
#輸出：<class '__main__.ObjectCreator'>
print hasattr(ObjectCreator, 'new_attribute')
#輸出：False

ObjectCreator.new_attribute = 'foo' #  你可以為類增加屬性
print hasattr(ObjectCreator, 'new_attribute')
#輸出：True
print ObjectCreator.new_attribute
#輸出：foo

ObjectCreatorMirror = ObjectCreator # 你可以將類賦值給一個變數
print ObjectCreatorMirror()
#輸出：<__main__.ObjectCreator object at 0x108551310>

二、動態地建立類

1、通過return class動態的構建需要的類

因為類也是物件，你可以在執行時動態的建立它們，就像其他任何物件一樣。首先，你可以在函式中建立類，使用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 '__main__.Foo'>

print MyClass()            # 你可以通過這個類建立類例項，也就是物件
#輸出：<__main__.Foo object at 0x1085ed950

2、通過type函式構造類

但這還不夠動態，因為你仍然需要自己編寫整個類的程式碼。由於類也是物件，所以它們必須是通過什麼東西來生成的才對。當你使用class關鍵字時，Python直譯器自動建立這個物件。但就和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 MyShinyClass(object):
    pass

可以手動通過type建立，其實

MyShinyClass = type('MyShinyClass', (), {})  # 返回一個類物件
print MyShinyClass
#輸出：<class '__main__.MyShinyClass'>
print MyShinyClass()  #  建立一個該類的例項
#輸出：<__main__.MyShinyClass object at 0x1085cd810>

你會發現我們使用“MyShinyClass”作為類名，並且也可以把它當做一個變數來作為類的引用。

接下來我們通過一個具體的例子看看type是如何建立類的，範例：

1、構建Foo類
#構建目的碼
class Foo(object):
    bar = True
#使用type構建
Foo = type('Foo', (), {'bar':True})

2.繼承Foo類
#構建目的碼：
class FooChild(Foo):
    pass
#使用type構建
FooChild = type('FooChild', (Foo,),{})

print FooChild
#輸出：<class '__main__.FooChild'>
print FooChild.bar   # bar屬性是由Foo繼承而來
#輸出：True

3.為Foochild類增加方法
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在幕後做的事情，而這就是通過元類來實現的。

三、元類

1、什麼是元類

通過上文的描述，我們知道了Python中的類也是物件。元類就是用來建立這些類（物件）的，元類就是類的類，你可以這樣理解為：

MyClass = MetaClass()    #元類建立
MyObject = MyClass()     #類建立例項
實際上MyClass就是通過type()來創創建出MyClass類，它是type()類的一個例項；同時MyClass本身也是類，也可以創建出自己的例項，這裡就是MyObject

函式type實際上是一個元類。type就是Python在背後用來建立所有類的元類。現在你想知道那為什麼type會全部採用小寫形式而不是Type呢？好吧，我猜這是為了和str保持一致性，str是用來建立字串物件的類，而int是用來建立整數物件的類。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'>

對於任何一個__class__的__class__屬性又是什麼呢？
a.__class__.__class__
#輸出：<type 'type'>
age.__class__.__class__
#輸出：<type 'type'>
foo.__class__.__class__
#輸出：<type 'type'>
b.__class__.__class__
#輸出：<type 'type'>

因此，元類就是建立類這種物件的東西，type就是Python的內建元類，當然了，你也可以建立自己的元類。

2、__metaclass__屬性

你可以在寫一個類的時候為其新增__metaclass__屬性,定義了__metaclass__就定義了這個類的元類。

class Foo(object):   #py2
    __metaclass__ = something…


class Foo(metaclass=something):   #py3
    __metaclass__ = something…

例如：當我們寫如下程式碼時 :

class Foo(Bar):
    pass

在該類並定義的時候，它還沒有在記憶體中生成，知道它被呼叫。Python做了如下的操作：
1）Foo中有__metaclass__這個屬性嗎？如果是，Python會在記憶體中通過__metaclass__建立一個名字為Foo的類物件（我說的是類物件，請緊跟我的思路）。
2）如果Python沒有找到__metaclass__，它會繼續在父類中尋找__metaclass__屬性，並嘗試做和前面同樣的操作。
3）如果Python在任何父類中都找不到__metaclass__，它就會在模組層次中去尋找__metaclass__，並嘗試做同樣的操作。
4）如果還是找不到__metaclass__,Python就會用內建的type來建立這個類物件。

現在的問題就是，你可以在__metaclass__中放置些什麼程式碼呢？
答案就是：可以建立一個類的東西。那麼什麼可以用來建立一個類呢？type，或者任何使用到type或者子類化type的東西都可以。

三、自定義元類

元類的主要目的就是為了當建立類時能夠自動地改變類。通常，你會為API做這樣的事情，你希望可以建立符合當前上下文的類。假想一個很傻的例子，你決定在你的模組裡所有的類的屬性都應該是大寫形式。有好幾種方法可以辦到，但其中一種就是通過設定__metaclass__。採用這種方法，這個模組中的所有類都會通過這個元類來建立，我們只需要告訴元類把所有的屬性都改成大寫形式就萬事大吉了。

__metaclass__實際上可以被任意呼叫，它並不需要是一個正式的類。所以，我們這裡就先以一個簡單的函式作為例子開始。

1、使用函式當做元類

# 元類會自動將你通常傳給‘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)#返回一個類

class Foo(object):
    __metaclass__ = upper_attr
    bar = 'bip'

print hasattr(Foo, 'bar')
# 輸出: False
print hasattr(Foo, 'BAR')
# 輸出:True
 
f = Foo()
print f.BAR
# 輸出:'bip'

2、使用class來當做元類

由於__metaclass__必須返回一個類。

# 請記住，'type'實際上是一個類，就像'str'和'int'一樣。所以，你可以從type繼承
# __new__ 是在__init__之前被呼叫的特殊方法，__new__是用來建立物件並返回之的方法，__new_()是一個類方法
# 而__init__只是用來將傳入的引數初始化給物件，它是在物件建立之後執行的方法。
# 你很少用到__new__，除非你希望能夠控制物件的建立。這裡，建立的物件是類，我們希望能夠自定義它，所以我們這裡改寫__new__
# 如果你希望的話，你也可以在__init__中做些事情。還有一些高階的用法會涉及到改寫__call__特殊方法，但是我們這裡不用，下面我們可以單獨的討論這個使用

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)#返回一個物件，但同時這個物件是一個類

但是，這種方式其實不是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程式設計，沒什麼魔法。由於type是元類也就是類，因此它本身也是通過__new__方法生成其例項，只不過這個例項是一個類.
        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方法的話，我們還可以使它變得更清晰一些。

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)

四、使用原來建立ORM的例項

我們通過建立一個類似Django中的ORM來熟悉一下元類的使用，通常元類用來建立API是非常好的選擇，使用元類的編寫很複雜但使用者可以非常簡潔的呼叫API。

#我們想建立一個類似Django的ORM，只要定義欄位就可以實現對資料庫表和欄位的操作。
class User(Model):
    # 定義類的屬性到列的對映：
    id = IntegerField('id')
    name = StringField('username')
    email = StringField('email')
    password = StringField('password')

例如：

# 建立一個例項：
u = User(id=12345, name='Michael', email='[email protected]', password='my-pwd')
# 儲存到資料庫：
u.save()

接下來我麼來實現這麼個功能：

五、使用__new__方法和元類方式分別實現單例模式

1、__new__、__init__、__call__的介紹

在講到使用元類建立單例模式之前，比需瞭解__new__這個內建方法的作用，在上面講元類的時候我們用到了__new__方法來實現類的建立。然而我在那之前還是對__new__這個方法和__init__方法有一定的疑惑。因此這裡花點時間對其概念做一次瞭解和區分。

__new__方法負責建立一個例項物件，在物件被建立的時候呼叫該方法它是一個類方法。__new__方法在返回一個例項之後，會自動的呼叫__init__方法，對例項進行初始化。如果__new__方法不返回值，或者返回的不是例項，那麼它就不會自動的去呼叫__init__方法。

__init__ 方法負責將該例項物件進行初始化，在物件被建立之後呼叫該方法，在__new__方法創建出一個例項後對例項屬性進行初始化。__init__方法可以沒有返回值。

__call__方法其實和類的建立過程和例項化沒有多大關係了，定義了__call__方法才能被使用函式的方式執行。

例如：
class A(object):
    def __call__(self):
        print "__call__ be called"

a = A()
a()
#輸出
#__call__ be called

打個比方幫助理解：如果將建立例項的過程比作建一個房子。

• 那麼class就是一個房屋的設計圖，他規定了這個房子有幾個房間，每個人房間的大小朝向等。這個設計圖就是累的結構
• __new__就是一個房屋的框架，每個具體的房屋都需要先搭好框架後才能進行專修，當然現有了房屋設計才能有具體的房屋框架出來。這個就是從類到類例項的建立。
• __init__就是裝修房子的過程，對房屋的牆面和地板等顏色材質的豐富就是它該做的事情，當然先有具體的房子框架出來才能進行裝飾了。這個就是例項屬性的初始化，它是在__new__出一個例項後才能初始化。
• __call__就是房子的電話，有了固定電話，才能被打電話嘛（就是通過括號的方式像函式一樣執行）。

#coding:utf-8
class Foo(object):
    def __new__(cls, *args, **kwargs):
        #__new__是一個類方法，在物件建立的時候呼叫
        print "excute __new__"
        return super(Foo,cls).__new__(cls,*args,**kwargs)


    def __init__(self,value):
        #__init__是一個例項方法，在物件建立後呼叫，對例項屬性做初始化
        print "excute __init"
        self.value = value


f1 = Foo(1)
print f1.value
f2 = Foo(2)
print f2.value

#輸出===：
excute __new__
excute __init
1
excute __new__
excute __init
2
#====可以看出new方法在init方法之前執行

子類如果重寫__new__方法，一般依然要呼叫父類的__new__方法。

class Child(Foo):
    def __new__(cls, *args, **kwargs):        
        return suyper(Child, cls).__new__(cls, *args, **kwargs)

必須注意的是，類的__new__方法之後，必須生成本類的例項才能自動呼叫本類的__init__方法進行初始化，否則不會自動呼叫__init__.

class Foo(object):
    def __init__(self, *args, **kwargs):
        print "Foo __init__"
    def __new__(cls, *args, **kwargs):
        return object.__new__(Stranger, *args, **kwargs)

class Stranger(object):
    def __init__(self,name):
        print "class Stranger's __init__ be called"
        self.name = name

foo = Foo("test")
print type(foo) #<class '__main__.Stranger'>
print foo.name #AttributeError: 'Stranger' object has no attribute 'name'

#說明：如果new方法返回的不是本類的例項，那麼本類（Foo）的init和生成的類(Stranger)的init都不會被呼叫

2.實現單例模式：

依照Python官方文件的說法，__new__方法主要是當你繼承一些不可變的class時(比如int, str, tuple)， 提供給你一個自定義這些類的例項化過程的途徑。還有就是實現自定義的metaclass。接下來我們分別通過這兩種方式來實現單例模式。當初在看到cookbook中的元類來實現單例模式的時候對其相當疑惑，因此才有了上面這些對元類的總結。

簡單來說，單例模式的原理就是通過在類屬性中新增一個單例判定位ins_flag，通過這個flag判斷是否已經被例項化過了,如果被例項化過了就返回該例項。

1)__new__方法實現單例：

class Singleton(object):
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls,"_instance"):
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
        return cls._instance


s1 = Singleton()
s2 = Singleton()

print s1 is s2

因為重寫__new__方法，所以繼承至Singleton的類，在不重寫__new__的情況下都將是單例模式。

2）元類實現單例

當初我也很疑惑為什麼我們是從寫使用元類的__init__方法，而不是使用__new__方法來初為元類增加一個屬性。其實我只是上面那一段關於元類中__new__方法迷惑了，它主要用於我們需要對類的結構進行改變的時候我們才要重寫這個方法。

class Singleton(type):
    def __init__(self, *args, **kwargs):
        print "__init__"
        self.__instance = None
        super(Singleton,self).__init__(*args, **kwargs)

    def __call__(self, *args, **kwargs):
        print "__call__"
        if self.__instance is None:
            self.__instance = super(Singleton,self).__call__(*args, **kwargs)
        return self.__instance


class Foo(object):
    __metaclass__ = Singleton #在程式碼執行到這裡的時候，元類中的__new__方法和__init__方法其實已經被執行了，而不是在Foo例項化的時候執行。且僅會執行一次。


foo1 = Foo()
foo2 = Foo()
print Foo.__dict__  #_Singleton__instance': <__main__.Foo object at 0x100c52f10> 存在一個私有屬性來儲存屬性，而不會汙染Foo類（其實還是會汙染，只是無法直接通過__instance屬性訪問）

print foo1 is foo2  # True

# 輸出
# __init__
# __call__
# __call__
# {'__module__': '__main__', '__metaclass__': <class '__main__.Singleton'>, '_Singleton__instance': <__main__.Foo object at 0x100c52f10>, '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None}
# True

基於這個例子：

• 我們知道元類(Singleton)生成的例項是一個類(Foo),而這裡我們僅僅需要對這個例項(Foo)增加一個屬性(__instance)來判斷和儲存生成的單例。想想也知道為一個類新增一個屬性當然是在__init__中實現了。
• 關於__call__方法的呼叫，因為Foo是Singleton的一個例項。所以Foo()這樣的方式就呼叫了Singleton的__call__方法。不明白就回頭看看上一節中的__call__方法介紹。

假如我們通過元類的__new__方法來也可以實現，但顯然沒有通過__init__來實現優雅，因為我們不會為了為例項增加一個屬性而重寫__new__方法。所以這個形式不推薦。

class Singleton(type):
    def __new__(cls, name,bases,attrs):
        print "__new__"
        attrs["_instance"] = None
        return  super(Singleton,cls).__new__(cls,name,bases,attrs)

    def __call__(self, *args, **kwargs):
        print "__call__"
        if self._instance is None:
            self._instance = super(Singleton,self).__call__(*args, **kwargs)
        return self._instance

class Foo(object):
    __metaclass__ = Singleton

foo1 = Foo()
foo2 = Foo()
print Foo.__dict__ 
print foo1 is foo2  # True

# 輸出
# __new__
# __call__
# __call__
# {'__module__': '__main__', '__metaclass__': <class '__main__.Singleton'>, '_instance': <__main__.Foo object at 0x103e07ed0>, '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None}
# True