在看一些框架源代碼的過程當中碰到不少元類的實例，看起來很吃力很晦澀；在看python cookbook中關於元類建立單例模式的那一節有些疑惑。所以花了幾天時間研究下元類這個概念。經過學習元類，我對python的面向對象有了更加深刻的瞭解。這裏將一篇寫的很是好的文章基本照搬過來吧，這是一篇在Stack overflow上很熱的帖子，我看http://blog.jobbole.com/21351/這篇博客對其進行了翻譯。javascript
1、理解類也是對象
在理解元類以前，你須要先掌握Python中的類。Python中類的概念借鑑於Smalltalk，這顯得有些奇特。在大多數編程語言中，類就是一組用來描述如何生成一個對象的代碼段。在Python中這一點仍然成立：java
class ObjectCreator(object): pass my_object = ObjectCreator() print my_object #輸出：<__main__.ObjectCreator object at 0x8974f2c>
可是，Python中的類還遠不止如此。類一樣也是一種對象。只要你使用關鍵字class，Python解釋器在執行的時候就會建立一個對象。下面的代碼段：python
class ObjectCreator(object): pass
將在內存中建立一個對象，名字就是ObjectCreator。這個對象（類）自身擁有建立對象（類實例）的能力，而這就是爲何它是一個類的緣由。可是，它的本質仍然是一個對象，因而你能夠對它作以下的操做：
你能夠將它賦值給一個變量， 你能夠拷貝它， 你能夠爲它增長屬性， 你能夠將它做爲函數參數進行傳遞。sql
下面是示例：數據庫
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>
2、動態地建立類
一、經過return class動態的構建須要的類編程
由於類也是對象，你能夠在運行時動態的建立它們，就像其餘任何對象同樣。首先，你能夠在函數中建立類，使用class關鍵字便可。 app
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
二、經過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中是爲了保持向後兼容性）ide
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在幕後作的事情，而這就是經過元類來實現的。
3、元類
一、什麼是元類
經過上文的描述，咱們知道了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的內建元類，固然了，你也能夠建立本身的元類。
二、__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的東西均可以。
3、自定義元類
元類的主要目的就是爲了當建立類時可以自動地改變類。一般，你會爲API作這樣的事情，你但願能夠建立符合當前上下文的類。假想一個很傻的例子，你決定在你的模塊裏全部的類的屬性都應該是大寫形式。有好幾種方法能夠辦到，但其中一種就是經過設定__metaclass__。採用這種方法，這個模塊中的全部類都會經過這個元類來建立，咱們只須要告訴元類把全部的屬性都改爲大寫形式就萬事大吉了。
__metaclass__實際上能夠被任意調用，它並不須要是一個正式的類。因此，咱們這裏就先以一個簡單的函數做爲例子開始。
一、使用函數當作元類
# 元類會自動將你一般傳給‘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'
二、使用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)
4、使用原來建立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()
接下來我麼來實現這麼個功能：
#coding:utf-8 #1、首先來定義Field類，它負責保存數據庫表的字段名和字段類型： class Field(object): def __init__(self, name, column_type): self.name = name self.column_type = column_type def __str__(self): return '<%s:%s>' % (self.__class__.__name__, self.name) class StringField(Field): def __init__(self, name): super(StringField, self).__init__(name, 'varchar(100)') class IntegerField(Field): def __init__(self, name): super(IntegerField, self).__init__(name, 'bigint') #2、定義元類，控制Model對象的建立 class ModelMetaclass(type): '''定義元類''' def __new__(cls, name, bases, attrs): if name=='Model': return super(ModelMetaclass,cls).__new__(cls, name, bases, attrs) mappings = dict() for k, v in attrs.iteritems(): # 保存類屬性和列的映射關係到mappings字典 if isinstance(v, Field): print('Found mapping: %s==>%s' % (k, v)) mappings[k] = v for k in mappings.iterkeys(): #將類屬性移除，使定義的類字段不污染User類屬性，只在實例中能夠訪問這些key attrs.pop(k) attrs['__table__'] = name.lower() # 假設表名和爲類名的小寫,建立類時添加一個__table__類屬性 attrs['__mappings__'] = mappings # 保存屬性和列的映射關係，建立類時添加一個__mappings__類屬性 return super(ModelMetaclass,cls).__new__(cls, name, bases, attrs) #3、編寫Model基類 class Model(dict): __metaclass__ = ModelMetaclass def __init__(self, **kw): super(Model, self).__init__(**kw) def __getattr__(self, key): try: return self[key] except KeyError: raise AttributeError(r"'Model' object has no attribute '%s'" % key) def __setattr__(self, key, value): self[key] = value def save(self): fields = [] params = [] args = [] for k, v in self.__mappings__.iteritems(): fields.append(v.name) params.append('?') args.append(getattr(self, k, None)) sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join(params)) print('SQL: %s' % sql) print('ARGS: %s' % str(args)) #最後，咱們使用定義好的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() #輸出 # Found mapping: email==><StringField:email> # Found mapping: password==><StringField:password> # Found mapping: id==><IntegerField:id> # Found mapping: name==><StringField:username> # SQL: insert into User (password,email,username,id) values (?,?,?,?) # ARGS: ['my-pwd', 'test@orm.org', 'Michael', 12345]
5、使用__new__方法和元類方式分別實現單例模式
一、__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