單例模式
單例模式（Singleton Pattern）是一種常用的軟件設計模式，該模式的主要目的是確保某一個類只有一個實例存在。當你希望在整個系統中，某個類只能出現一個實例時，單例對象就能派上用場。
比如，某個服務器程序的配置信息存放在一個文件中，客戶端通過一個 AppConfig 的類來讀取配置文件的信息。如果在程序運行期間，有很多地方都需要使用配置文件的內容，也就是說，很多地方都需要創建 AppConfig 對象的實例，這就導致系統中存在多個 AppConfig 的實例對象，而這樣會嚴重浪費內存資源，尤其是在配置文件內容很多的情況下。事實上，類似 AppConfig 這樣的類，我們希望在程序運行期間只存在一個實例對象。
單例模式的要點有三個；一是某個類只能有一個實例；二是它必須自行創建這個實例；三是它必須自行向整個系統提供這個實例。
在 Python 中，我們可以用多種方法來實現單例模式：
- 使用模塊
- 使用
__new__ - 使用裝飾器（decorator）
- 使用元類（metaclass）
使用模塊
其實，Python 的模塊就是天然的單例模式。
因為模塊在第一次導入時，會生成 .pyc 文件，當第二次導入時，就會直接加載 .pyc 文件，而不會再次執行模塊代碼。因此，我們只需把相關的函數和數據定義在一個模塊中，就可以獲得一個單例對象了。
如果我們真的想要一個單例類，可以考慮這樣做：
#tests1.py
class MyClass(object):
def foo(self):
print('MyClass.foo')
my_class_obj=MyClass()
將上面的代碼保存在文件 tests1.py 中，然后這樣使用：
from .tests1 import my_class_obj my_class_obj.foo()
使用 __new__
為了使類只能出現一個實例，我們可以使用 __new__ 來控制實例的創建過程，代碼如下：
class MyClass(object):
_instance = None
def __new__(cls, *args, **kwargs):
if not cls._instance:
cls._instance = super(MyClass, cls).__new__(cls, *args, **kwargs)
return cls._instance
class HerClass(MyClass):
a = 1
在上面的代碼中，我們將類的實例和一個類變量 _instance 關聯起來，如果 cls._instance 為 None 則創建實例，否則直接返回 cls._instance。
執行情況如下：
one = HerClass() two = HerClass() print(one == two) #True print(one is two) #True print(id(one), id(two)) #42818864 42818864
使用裝飾器
我們知道，裝飾器（decorator）可以動態地修改一個類或函數的功能。這里，我們也可以使用裝飾器來裝飾某個類，使其只能生成一個實例，代碼如下：
from functools import wraps
def singleton(cls):
instances = {}
@wraps(cls)
def getinstance(*args, **kwargs):
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return getinstance
@singleton
class MyClass(object):
a = 1
在上面，我們定義了一個裝飾器 singleton，它返回了一個內部函數 getinstance，該函數會判斷某個類是否在字典 instances 中，如果不存在，則會將 cls 作為 key，cls(*args, **kw) 作為 value 存到 instances 中，否則，直接返回 instances[cls]。
使用 metaclass
元類（metaclass）可以控制類的創建過程，它主要做三件事：
- 攔截類的創建
- 修改類的定義
- 返回修改后的類
使用元類實現單例模式的代碼如下：
class Singleton(type):
_instances = {}
def __call__(cls, *args, **kwargs):
if cls not in cls._instances:
cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
return cls._instances[cls]
# Python2
# class MyClass(object):
# __metaclass__ = Singleton
# Python3
class MyClass(metaclass=Singleton):
pass
優點：
補充：元類(metaclass)
類也是對象
只要你使用關鍵字class，Python解釋器在執行的時候就會創建一個對象。
下面的代碼段：
class MyClass(object):
pass
將在內存中創建一個對象，名字就是MyClass。這個對象（類）自身擁有創建對象（類實例）的能力，而這就是為什么它是一個類的原因。但是，它的本質仍然是一個對象，於是乎你可以對它做如下的操作：
1) 你可以將它賦值給一個變量
2) 你可以拷貝它
3) 你可以為它增加屬性
4) 你可以將它作為函數參數進行傳遞
class MyClass(object):
pass
print(MyClass) # 你可以打印一個類，因為它其實也是一個對象
# <class '__main__.MyClass'>
def echo(o):
print(o)
echo(MyClass) # 你可以將類做為參數傳給函數
# <class '__main__.MyClass'>
MyClass.new_attribute = 'foo' # 你可以為類增加屬性
print(hasattr(MyClass,'new_attribute')) #True
print(MyClass.new_attribute) #foo
MyClassMirror=MyClass # 你可以將類賦值給一個變量
print(MyClassMirror())
# <__main__.MyClass object at 0x00000000028CDE10>
動態地創建類
因為類也是對象，你可以在運行時動態的創建它們，就像其他任何對象一樣。首先，你可以在函數中創建類，使用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__.choose_class.<locals>.Foo'>
print(MyClass()) # 你可以通過這個類創建類實例，也就是對象
# <__main__.choose_class.<locals>.Foo object at 0x00000000021E5CF8>
但這還不夠動態。
由於類也是對象，所以它們必須是通過什么東西來生成的才對。
還記得內建函數type嗎？這個古老但強大的函數能夠讓你知道一個對象的類型是什么，就像這樣：
print(type(1)) #<class 'int'>
print(type('1')) #<class 'str'>
print(type(MyClass)) #<class 'type'>
print(type(MyClass())) #<class '__main__.MyClass'>
type也能動態的創建類。
type可以像這樣工作：
type(類名, 父類的元組（針對繼承的情況，可以為空），包含屬性的字典（名稱和值）)
比如下面的代碼：
class MyShinyClass(object):
pass
可以手動像這樣創建：
MyShinyClass=type('MyShinyClass',(),{}) # 返回一個類對象
print(MyShinyClass)
# <class '__main__.MyShinyClass'>
print(MyShinyClass()) # 創建一個該類的實例
# <__main__.MyShinyClass object at 0x0000000002737D68>
type 接受一個字典來為類定義屬性，因此：
class Foo(object):
bar=True
可以翻譯為：
Foo = type('Foo', (), {'bar':True})
並且可以將Foo當成一個普通的類一樣使用：
class Foo(object):
bar=True
print(Foo) #<class '__main__.Foo'>
print(Foo.bar) #True
f=Foo()
print(f) #<__main__.Foo object at 0x0000000001F7DE10>
print(f.bar) #True
當然，你可以向這個類繼承，所以，如下的代碼：
class FooChild(Foo):
pass
就可以寫成：
class Foo(object):
bar=True
FooChild = type('FooChild', (Foo,),{})
print(FooChild)
# <class '__main__.FooChild'>
print(FooChild.bar) # bar屬性是由Foo繼承而來
# True
最終你會希望為你的類增加方法。只需要定義一個有着恰當簽名的函數並將其作為屬性賦值就可以了。
class Foo(object):
bar=True
def echo_bar(self):
print(self.bar)
FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar})
print(hasattr(Foo, 'echo_bar')) #False
print(hasattr(FooChild, 'echo_bar')) #True
my_foo = FooChild()
my_foo.echo_bar() #True
你可以看到，在Python中，類也是對象，你可以動態的創建類。這就是當你使用關鍵字class時Python在幕后做的事情，而這就是通過元類來實現的。
到底什么是元類
元類就是用來創建類的“東西”。元類就是類的類。
函數type實際上是一個元類。type就是Python在背后用來創建所有類的元類。
type就是創建類對象的類。你可以通過檢查__class__屬性來看到這一點。
Python中所有的東西，注意，我是指所有的東西——都是對象。這包括整數、字符串、函數以及類。它們全部都是對象，而且它們都是從一個類創建而來。
age = 35
print(age.__class__) #<class 'int'>
name = 'bob'
print(name.__class__) #<class 'str'>
def foo():
pass
print(foo.__class__) #<class 'function'>
class Bar(object):
pass
b = Bar()
print(b.__class__) #<class '__main__.Bar'>
現在，對於任何一個__class__的__class__屬性又是什么呢？
print(age.__class__.__class__) #<class 'type'> print(name.__class__.__class__) #<class 'type'> print(foo.__class__.__class__) #<class 'type'> print(b.__class__.__class__) #<class 'type'>
因此，元類就是創建類這種對象的東西。
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的東東都可以。
內容：自定義元類、為什么要用metaclass類而不是函數?、究竟為什么要使用元類？
參考博文：http://blog.jobbole.com/21351/