https://www.cnblogs.com/tkqasn/p/6524879.html
在看一些框架源代碼的過程中碰到很多元類的實例，看起來很吃力很晦澀；在看python cookbook中關(guān)于元類創(chuàng)建單例模式的那一節(jié)有些疑惑。因此花了幾天時間研究下元類這個概念。通過學(xué)習(xí)元類，我對python的面向?qū)ο笥辛烁由钊氲牧私狻＿@里將一篇寫的非常好的文章基本照搬過來吧，這是一篇在Stack overflow上很熱的帖子，我看http://blog.jobbole.com/21351/這篇博客對其進(jìn)行了翻譯。

一、理解類也是對象

在理解元類之前，你需要先掌握Python中的類。Python中類的概念借鑒于Smalltalk，這顯得有些奇特。在大多數(shù)編程語言中，類就是一組用來描述如何生成一個對象的代碼段。在Python中這一點仍然成立：

class ObjectCreator(object):passmy_object = ObjectCreator() print my_object 輸出： <__main__.ObjectCreator object at 0x8974f2c>

但是，Python中的類還遠(yuǎn)不止如此。類同樣也是一種對象。只要你使用關(guān)鍵字class，Python解釋器在執(zhí)行的時候就會創(chuàng)建一個對象。下面的代碼段：

class ObjectCreator(object):pass

將在內(nèi)存中創(chuàng)建一個對象，名字就是ObjectCreator。這個對象（類）自身擁有創(chuàng)建對象（類實例）的能力，而這就是為什么它是一個類的原因。但是，它的本質(zhì)仍然是一個對象，于是你可以對它做如下的操作：
你可以將它賦值給一個變量， 你可以拷貝它， 你可以為它增加屬性， 你可以將它作為函數(shù)參數(shù)進(jìn)行傳遞。

下面是示例：

print ObjectCreator # 你可以打印一個類，因為它其實也是一個對象 輸出：<class '__main__.ObjectCreator'>def echo(o):print oecho(ObjectCreator) # 你可以將類做為參數(shù)傳給函數(shù) 輸出：<class '__main__.ObjectCreator'> print hasattr(ObjectCreator, 'new_attribute') 輸出：FalseObjectCreator.new_attribute = 'foo' # 你可以為類增加屬性 print hasattr(ObjectCreator, 'new_attribute') 輸出：True print ObjectCreator.new_attribute 輸出：fooObjectCreatorMirror = ObjectCreator # 你可以將類賦值給一個變量 print ObjectCreatorMirror() 輸出：<__main__.ObjectCreator object at 0x108551310>

二、動態(tài)地創(chuàng)建類

1、通過return class動態(tài)的構(gòu)建需要的類

因為類也是對象，你可以在運行時動態(tài)的創(chuàng)建它們，就像其他任何對象一樣。首先，你可以在函數(shù)中創(chuàng)建類，使用class關(guān)鍵字即可。

def choose_class(name):if name == 'foo':class Foo(object):passreturn Foo # 返回的是類，不是類的實例else:class Bar(object):passreturn Bar MyClass = choose_class('foo')print MyClass # 函數(shù)返回的是類，不是類的實例 輸出：<class '__main__.Foo'>print MyClass() # 你可以通過這個類創(chuàng)建類實例，也就是對象 輸出：<__main__.Foo object at 0x1085ed950

2、通過type函數(shù)構(gòu)造類

但這還不夠動態(tài)，因為你仍然需要自己編寫整個類的代碼。由于類也是對象，所以它們必須是通過什么東西來生成的才對。當(dāng)你使用class關(guān)鍵字時，Python解釋器自動創(chuàng)建這個對象。但就和Python中的大多數(shù)事情一樣，Python仍然提供給你手動處理的方法。還記得內(nèi)建函數(shù)type嗎？這個古老但強大的函數(shù)能夠讓你知道一個對象的類型是什么，就像這樣：

print type(1) 輸出：<type 'int'> print type("1") 輸出：<type 'str'> print type(ObjectCreator) 輸出：<type 'type'> print type(ObjectCreator()) 輸出：<class '__main__.ObjectCreator'>

這里，type有一種完全不同的能力，它也能動態(tài)的創(chuàng)建類。type可以接受一個類的描述作為參數(shù)，然后返回一個類。（我知道，根據(jù)傳入?yún)?shù)的不同，同一個函數(shù)擁有兩種完全不同的用法是一件很傻的事情，但這在Python中是為了保持向后兼容性）

type的語法：

type(類名, 父類的元組（針對繼承的情況，可以為空），包含屬性的字典（名稱和值）)
比如下面的代碼：

class MyShinyClass(object):pass

可以手動通過type創(chuàng)建，其實

MyShinyClass = type('MyShinyClass', (), {}) # 返回一個類對象 print MyShinyClass 輸出：<class '__main__.MyShinyClass'> print MyShinyClass() # 創(chuàng)建一個該類的實例 輸出：<__main__.MyShinyClass object at 0x1085cd810>

你會發(fā)現(xiàn)我們使用“MyShinyClass”作為類名，并且也可以把它當(dāng)做一個變量來作為類的引用。

接下來我們通過一個具體的例子看看type是如何創(chuàng)建類的，范例：

1.構(gòu)建Foo類

#構(gòu)建目標(biāo)代碼 class Foo(object):bar = True #使用type構(gòu)建 Foo = type('Foo', (), {'bar':True})

2.繼承Foo類

#構(gòu)建目標(biāo)代碼： class FooChild(Foo):pass #使用type構(gòu)建 FooChild = type('FooChild', (Foo,),{})print FooChild 輸出：<class '__main__.FooChild'> print FooChild.bar # bar屬性是由Foo繼承而來 輸出：True

3.為Foochild類增加方法

def echo_bar(self):print self.barFooChild = 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中，類也是對象，你可以動態(tài)的創(chuàng)建類。這就是當(dāng)我們使用關(guān)鍵字class時Python在幕后做的事情，而這就是通過元類來實現(xiàn)的。

三、元類

1、什么是元類

通過上文的描述，我們知道了Python中的類也是對象。元類就是用來創(chuàng)建這些類（對象）的，元類就是類的類，你可以這樣理解為：

MyClass = MetaClass() #元類創(chuàng)建 MyObject = MyClass() #類創(chuàng)建實例

實際上MyClass就是通過type()來創(chuàng)創(chuàng)建出MyClass類，它是type()類的一個實例；同時MyClass本身也是類，也可以創(chuàng)建出自己的實例，這里就是MyObject
函數(shù)type實際上是一個元類。type就是Python在背后用來創(chuàng)建所有類的元類。現(xiàn)在你想知道那為什么type會全部采用小寫形式而不是Type呢？好吧，我猜這是為了和str保持一致性，str是用來創(chuàng)建字符串對象的類，而int是用來創(chuàng)建整數(shù)對象的類。type就是創(chuàng)建類對象的類。你可以通過檢查__class__屬性來看到這一點。Python中所有的東西，注意，我是指所有的東西——都是對象。這包括整數(shù)、字符串、函數(shù)以及類。它們?nèi)慷际菍ο?#xff0c;而且它們都是從一個類創(chuàng)建而來。

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

因此，元類就是創(chuàng)建類這種對象的東西， type就是Python的內(nèi)建元類，當(dāng)然了，你也可以創(chuàng)建自己的元類。

2、__metaclass__屬性

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

class Foo(object): #py2__metaclass__ = something…class Foo(metaclass=something): #py3__metaclass__ = something…

例如：當(dāng)我們寫如下代碼時 :

class Foo(Bar):pass

在該類并定義的時候，它還沒有在內(nèi)存中生成，知道它被調(diào)用。Python做了如下的操作：

• 1）Foo中有__metaclass__這個屬性嗎？如果是，Python會在內(nèi)存中通過__metaclass__創(chuàng)建一個名字為Foo的類對象（我說的是類對象，請緊跟我的思路）。
• 2）如果Python沒有找到__metaclass__，它會繼續(xù)在父類中尋找__metaclass__屬性，并嘗試做和前面同樣的操作。
• 3）如果Python在任何父類中都找不到__metaclass__，它就會在模塊層次中去尋找__metaclass__，并嘗試做同樣的操作。
• 4）如果還是找不到__metaclass__,Python就會用內(nèi)置的type來創(chuàng)建這個類對象。

現(xiàn)在的問題就是，你可以在__metaclass__中放置些什么代碼呢？
答案就是：可以創(chuàng)建一個類的東西。那么什么可以用來創(chuàng)建一個類呢？type，或者任何使用到type或者子類化type的東西都可以。

三、自定義元類

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

__metaclass__實際上可以被任意調(diào)用，它并不需要是一個正式的類。所以，我們這里就先以一個簡單的函數(shù)作為例子開始。

1、使用函數(shù)當(dāng)做元類

# 元類會自動將你通常傳給‘type’的參數(shù)作為自己的參數(shù)傳入 def upper_attr(future_class_name, future_class_parents, future_class_attr):'''返回一個類對象，將屬性都轉(zhuǎn)為大寫形式'''#選擇所有不以'__'開頭的屬性attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__'))# 將它們轉(zhuǎn)為大寫形式uppercase_attr = dict((name.upper(), value) for name, value in attrs)#通過'type'來做類對象的創(chuàng)建return type(future_class_name, future_class_parents, uppercase_attr)#返回一個類class Foo(object):__metaclass__ = upper_attrbar = 'bip' print hasattr(Foo, 'bar') 輸出: False print hasattr(Foo, 'BAR') 輸出:Truef = Foo() print f.BAR 輸出:'bip'

2、使用class來當(dāng)做元類

由于__metaclass__必須返回一個類。

- 請記住，'type'實際上是一個類，就像'str'和'int'一樣。所以，你可以從type繼承 - __new__ 是在__init__之前被調(diào)用的特殊方法，__new__是用來創(chuàng)建對象并返回之的方法，__new_()是一個類方法 - 而__init__只是用來將傳入的參數(shù)初始化給對象，它是在對象創(chuàng)建之后執(zhí)行的方法。 - 你很少用到__new__，除非你希望能夠控制對象的創(chuàng)建。這里，創(chuàng)建的對象是類，我們希望能夠自定義它，所以我們這里改寫__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。我們直接調(diào)用了type，而且我們沒有改寫父類的__new__方法。現(xiàn)在讓我們這樣去處理:

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)# 復(fù)用type.__new__方法# 這就是基本的OOP編程，沒什么魔法。由于type是元類也就是類，因此它本身也是通過__new__方法生成其實例，只不過這個實例是一個類.return type.__new__(upperattr_metaclass, future_class_name, future_class_parents, uppercase_attr)

你可能已經(jīng)注意到了有個額外的參數(shù)upperattr_metaclass，這并沒有什么特別的。類方法的第一個參數(shù)總是表示當(dāng)前的實例，就像在普通的類方法中的self參數(shù)一樣。當(dāng)然了，為了清晰起見，這里的名字我起的比較長。但是就像self一樣，所有的參數(shù)都有它們的傳統(tǒng)名稱。因此，在真實的產(chǎn)品代碼中一個元類應(yīng)該是像這樣的：

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)

四、使用原來創(chuàng)建ORM的實例

我們通過創(chuàng)建一個類似Django中的ORM來熟悉一下元類的使用，通常元類用來創(chuàng)建API是非常好的選擇，使用元類的編寫很復(fù)雜但使用者可以非常簡潔的調(diào)用API。

- 我們想創(chuàng)建一個類似Django的ORM，只要定義字段就可以實現(xiàn)對數(shù)據(jù)庫表和字段的操作。 class User(Model):# 定義類的屬性到列的映射：id = IntegerField('id')name = StringField('username')email = StringField('email')password = StringField('password')

例如：

# 創(chuàng)建一個實例： u = User(id=12345, name='Michael', email='test@orm.org', password='my-pwd') # 保存到數(shù)據(jù)庫： u.save()

接下來我么來實現(xiàn)這么個功能：

一、首先來定義Field類，它負(fù)責(zé)保存數(shù)據(jù)庫表的字段名和字段類型：

#coding:utf-8 class Field(object):def __init__(self, name, column_type):self.name = nameself.column_type = column_typedef __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')

二、定義元類，控制Model對象的創(chuàng)建

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():# 保存類屬性和列的映射關(guān)系到mappings字典if isinstance(v, Field):print('Found mapping: %s==>%s' % (k, v))mappings[k] = vfor k in mappings.iterkeys():#將類屬性移除，使定義的類字段不污染User類屬性，只在實例中可以訪問這些keyattrs.pop(k)attrs['__table__'] = name.lower() # 假設(shè)表名和為類名的小寫,創(chuàng)建類時添加一個__table__類屬性attrs['__mappings__'] = mappings # 保存屬性和列的映射關(guān)系，創(chuàng)建類時添加一個__mappings__類屬性return super(ModelMetaclass,cls).__new__(cls, name, bases, attrs)

三、編寫Model基類

class Model(dict):__metaclass__ = ModelMetaclassdef __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] = valuedef 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')# 創(chuàng)建一個實例： u = User(id=12345, name='Michael', email='test@orm.org', password='my-pwd') # 保存到數(shù)據(jù)庫： 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]

五、使用__new__方法和元類方式分別實現(xiàn)單例模式

1、new、init、__call__的介紹

在講到使用元類創(chuàng)建單例模式之前，比需了解__new__這個內(nèi)置方法的作用，在上面講元類的時候我們用到了__new__方法來實現(xiàn)類的創(chuàng)建。然而我在那之前還是對__new__這個方法和__init__方法有一定的疑惑。因此這里花點時間對其概念做一次了解和區(qū)分。

__new__方法負(fù)責(zé)創(chuàng)建一個實例對象，在對象被創(chuàng)建的時候調(diào)用該方法它是一個類方法。__new__方法在返回一個實例之后，會自動的調(diào)用__init__方法，對實例進(jìn)行初始化。如果__new__方法不返回值，或者返回的不是實例，那么它就不會自動的去調(diào)用__init__方法。

init 方法負(fù)責(zé)將該實例對象進(jìn)行初始化，在對象被創(chuàng)建之后調(diào)用該方法，在__new__方法創(chuàng)建出一個實例后對實例屬性進(jìn)行初始化。__init__方法可以沒有返回值。

__call__方法其實和類的創(chuàng)建過程和實例化沒有多大關(guān)系了，定義了__call__方法才能被使用函數(shù)的方式執(zhí)行。

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

打個比方幫助理解：如果將創(chuàng)建實例的過程比作建一個房子。

那么class就是一個房屋的設(shè)計圖，他規(guī)定了這個房子有幾個房間，每個人房間的大小朝向等。這個設(shè)計圖就是累的結(jié)構(gòu)
__new__就是一個房屋的框架，每個具體的房屋都需要先搭好框架后才能進(jìn)行專修，當(dāng)然現(xiàn)有了房屋設(shè)計才能有具體的房屋框架出來。這個就是從類到類實例的創(chuàng)建。
__init__就是裝修房子的過程，對房屋的墻面和地板等顏色材質(zhì)的豐富就是它該做的事情，當(dāng)然先有具體的房子框架出來才能進(jìn)行裝飾了。這個就是實例屬性的初始化，它是在__new__出一個實例后才能初始化。
__call__就是房子的電話，有了固定電話，才能被打電話嘛（就是通過括號的方式像函數(shù)一樣執(zhí)行）。

#coding:utf-8 class Foo(object):def __new__(cls, *args, **kwargs):#__new__是一個類方法，在對象創(chuàng)建的時候調(diào)用print "excute __new__"return super(Foo,cls).__new__(cls,*args,**kwargs)def __init__(self,value):#__init__是一個實例方法，在對象創(chuàng)建后調(diào)用，對實例屬性做初始化print "excute __init"self.value = valuef1 = Foo(1) print f1.value f2 = Foo(2) print f2.value#輸出===： excute __new__ excute __init 1 excute __new__ excute __init 2- 可以看出new方法在init方法之前執(zhí)行

子類如果重寫__new__方法，一般依然要調(diào)用父類的__new__方法。

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

必須注意的是，類的__new__方法之后，必須生成本類的實例才能自動調(diào)用本類的__init__方法進(jìn)行初始化，否則不會自動調(diào)用__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 = namefoo = Foo("test") print type(foo) print foo.name 輸出： <class '__main__.Stranger'> AttributeError: 'Stranger' object has no attribute 'name'

• 說明：如果new方法返回的不是本類的實例，那么本類（Foo）的init和生成的類(Stranger)的init都不會被調(diào)用

2、實現(xiàn)單例模式：

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

簡單來說，單例模式的原理就是通過在類屬性中添加一個單例判定位ins_flag，通過這個flag判斷是否已經(jīng)被實例化過了,如果被實例化過了就返回該實例。

1)__new__方法實現(xiàn)單例：

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

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

2）元類實現(xiàn)單例

當(dāng)初我也很疑惑為什么我們是從寫使用元類的__init__方法，而不是使用__new__方法來初為元類增加一個屬性。其實我只是上面那一段關(guān)于元類中__new__方法迷惑了，它主要用于我們需要對類的結(jié)構(gòu)進(jìn)行改變的時候我們才要重寫這個方法。

class Singleton(type):def __init__(self, *args, **kwargs):print "__init__"self.__instance = Nonesuper(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.__instanceclass Foo(object):__metaclass__ = Singleton #在代碼執(zhí)行到這里的時候，元類中的__new__方法和__init__方法其實已經(jīng)被執(zhí)行了，而不是在Foo實例化的時候執(zhí)行。且僅會執(zhí)行一次。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)來判斷和保存生成的單例。想想也知道為一個類添加一個屬性當(dāng)然是在__init__中實現(xiàn)了。
• 關(guān)于__call__方法的調(diào)用，因為Foo是Singleton的一個實例。所以Foo()這樣的方式就調(diào)用了Singleton的__call__方法。不明白就回頭看看上一節(jié)中的__call__方法介紹。

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

class Singleton(type):def __new__(cls, name,bases,attrs):print "__new__"attrs["_instance"] = Nonereturn 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._instanceclass Foo(object):__metaclass__ = Singletonfoo1 = 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

連接

《深刻理解Python中的元類(metaclass)以及元類實現(xiàn)單例模式》

總結(jié)

以上是生活随笔為你收集整理的Python中的元类及元类实现的单例模式的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。