在看一些框架源代碼的過程中碰到很多元類的實例，看起來很吃力很晦澀；在看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='test@orm.org', password='my-pwd') # 保存到數據庫： u.save()
接下來我么來實現這么個功能：
ORM代碼
五、使用__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