2. 程式人生 > >python的單例模式

python的單例模式

阿新 • • 發佈：2017-11-18
__init__ ext ray 概念 port 程序 設計 eight 軟件設計

單例模式(Singleton Pattern)，是一種軟件設計模式，是類只能實例化一個對象，

　　　　目的是便於外界的訪問，節約系統資源，如果希望系統中 只有一個對象可以訪問，就用單例模式，

　　　　顯然單例模式的要點有三個；一是某個類只能有一個實例；二是它必須自行創建這個實例；三是它必須自行向整個系統提供這個實例。

在 Python 中，我們可以用多種方法來實現單例模式：

  • 使用模塊
  • 使用 __new__
  • 使用裝飾器（decorator）
  • 使用元類（metaclass）

概念

簡單說，單例模式（也叫單件模式）的作用就是保證在整個應用程序的生命周期中，任何一個時刻，單例類的實例都只存在一個（當然也可以不存在）

例子：

一臺計算機上可以連好幾個打印機，但是這個計算機上的打印程序只能有一個，這裏就可以通過單例模式來避免兩個打印作業同時輸出到打印機中，即在整個的打印過程中我只有一個打印程序的實例。

代碼

import threading

class Signleton(object):

def __init__(self):

print("__init__ method called")

def __new__(cls):

print("__new__ method called")

mutex=threading.Lock()

mutex.acquire() # 上鎖，防止多線程下出問題

if not hasattr(cls, ‘instance‘):

cls.instance = super(LogSignleton, cls).__new__(cls)

mutex.release()

return cls.instance

if __name__ == ‘__main__‘:

obj = Signleton()

輸出結果：

>>> ================================ RESTART ================================

>>>

__new__ method called

__init__ method called

>>>

說明

1.從輸出結果來看，最先調用 __new__ 方法，然後調用__init__方法

2. __new__ 通常用於控制生成一個新實例的過程，它是類級別的方法。

3. __init__ 通常用於初始化一個新實例，控制這個初始化的過程，比如添加一些屬性，做一些額外的操作，發生在類實例被創建完以後。它是實例級別的方法。

方法1;

　　__new__ 在__init__初始化前，就已經實例化對象，可以利用這個方法實現單例模式。

    1. print ‘----------------------方法1--------------------------‘
    2. #方法1,實現__new__方法
    3. #並在將一個類的實例綁定到類變量_instance上,
    4. #如果cls._instance為None說明該類還沒有實例化過,實例化該類,並返回
    5. #如果cls._instance不為None,直接返回cls._instance
    6. class Singleton(object):
    7. def __new__(cls, *args, **kw):
    8. if not hasattr(cls, ‘_instance‘):
    9. orig = super(Singleton, cls)
    10. cls._instance = orig.__new__(cls, *args, **kw)
    11. return cls._instance
    13. class MyClass(Singleton):
    14. a = 1
    16. one = MyClass()
    17. two = MyClass()
    19. two.a = 3
    20. print one.a
    21. #3
    22. #one和two完全相同,可以用id(), ==, is檢測
    23. print id(one)
    24. #29097904
    25. print id(two)
    26. #29097904
    27. print one == two
    28. #True
    29. print one is two
    30. #True
      1. print ‘----------------------方法2--------------------------‘
      2. #方法2,共享屬性;所謂單例就是所有引用(實例、對象)擁有相同的狀態(屬性)和行為(方法)
      3. #同一個類的所有實例天然擁有相同的行為(方法),
      4. #只需要保證同一個類的所有實例具有相同的狀態(屬性)即可
      5. #所有實例共享屬性的最簡單最直接的方法就是__dict__屬性指向(引用)同一個字典(dict)
      6. #可參看:http://code.activestate.com/recipes/66531/
      7. class Borg(object):
      8. _state = {}
      9. def __new__(cls, *args, **kw):
      10. ob = super(Borg, cls).__new__(cls, *args, **kw)
      11. ob.__dict__ = cls._state
      12. return ob
      14. class MyClass2(Borg):
      15. a = 1
      17. one = MyClass2()
      18. two = MyClass2()
      20. #one和two是兩個不同的對象,id, ==, is對比結果可看出
      21. two.a = 3
      22. print one.a
      23. #3
      24. print id(one)
      25. #28873680
      26. print id(two)
      27. #28873712
      28. print one == two
      29. #False
      30. print one is two
      31. #False
      32. #但是one和two具有相同的（同一個__dict__屬性）,見:
      33. print id(one.__dict__)
      34. #30104000
      35. print id(two.__dict__)
      36. #30104000
      38. print ‘----------------------方法3--------------------------‘
      39. #方法3:本質上是方法1的升級（或者說高級）版
      40. #使用__metaclass__（元類）的高級python用法
      41. class Singleton2(type):
      42. def __init__(cls, name, bases, dict):
      43. super(Singleton2, cls).__init__(name, bases, dict)
      44. cls._instance = None
      45. def __call__(cls, *args, **kw):
      46. if cls._instance is None:
      47. cls._instance = super(Singleton2, cls).__call__(*args, **kw)
      48. return cls._instance
      50. class MyClass3(object):
      51. __metaclass__ = Singleton2
      53. one = MyClass3()
      54. two = MyClass3()
      56. two.a = 3
      57. print one.a
      58. #3
      59. print id(one)
      60. #31495472
      61. print id(two)
      62. #31495472
      63. print one == two
      64. #True
      65. print one is two
      66. #True
      68. print ‘----------------------方法4--------------------------‘
      69. #方法4:也是方法1的升級（高級）版本,
      70. #使用裝飾器(decorator),
      71. #這是一種更pythonic,更elegant的方法,
      72. #單例類本身根本不知道自己是單例的,因為他本身(自己的代碼)並不是單例的
      73. def singleton(cls, *args, **kw):
      74. instances = {}
      75. def _singleton():
      76. if cls not in instances:
      77. instances[cls] = cls(*args, **kw)
      78. return instances[cls]
      79. return _singleton
      81. @singleton
      82. class MyClass4(object):
      83. a = 1
      84. def __init__(self, x=0):
      85. self.x = x
      87. one = MyClass4()
      88. two = MyClass4()
      90. two.a = 3
      91. print one.a
      92. #3
      93. print id(one)
      94. #29660784
      95. print id(two)
      96. #29660784
      97. print one == two
      98. #True
      99. print one is two
      100. #True
      101. one.x = 1
      102. print one.x
      103. #1
      104. print two.x

        ==========================================================

          1. 單例模式

            單例模式（Singleton Pattern）是一種常用的軟件設計模式，該模式的主要目的是確保某一個類只有一個實例存在。當你希望在整個系統中，某個類只能出現一個實例時，單例對象就能派上用場。

            比如，某個服務器程序的配置信息存放在一個文件中，客戶端通過一個 AppConfig 的類來讀取配置文件的信息。如果在程序運行期間，有很多地方都需要使用配置文件的內容，也就是說，很多地方都需要創建 AppConfig 對象的實例，這就導致系統中存在多個 AppConfig 的實例對象，而這樣會嚴重浪費內存資源，尤其是在配置文件內容很多的情況下。事實上，類似 AppConfig 這樣的類，我們希望在程序運行期間只存在一個實例對象。

            在 Python 中，我們可以用多種方法來實現單例模式：

            • 使用模塊
            • 使用 __new__
            • 使用裝飾器（decorator）
            • 使用元類（metaclass）

            使用模塊

            其實，Python 的模塊就是天然的單例模式，因為模塊在第一次導入時，會生成 .pyc 文件，當第二次導入時，就會直接加載 .pyc 文件，而不會再次執行模塊代碼。因此，我們只需把相關的函數和數據定義在一個模塊中，就可以獲得一個單例對象了。如果我們真的想要一個單例類，可以考慮這樣做：

            1 2 3 4 5 6 # mysingleton.py class My_Singleton(object): def foo(self): pass my_singleton = My_Singleton()

            將上面的代碼保存在文件 mysingleton.py 中，然後這樣使用：

            1 2 3 from mysingleton import my_singleton my_singleton.foo()

            使用 __new__

            為了使類只能出現一個實例，我們可以使用 __new__ 來控制實例的創建過程，代碼如下：

            1 2 3 4 5 6 7 8 9 class Singleton(object): _instance = None def __new__(cls, *args, **kw): if not cls._instance: cls._instance = super(Singleton, cls).__new__(cls, *args, **kw) return cls._instance class MyClass(Singleton): a = 1

            在上面的代碼中，我們將類的實例和一個類變量 _instance 關聯起來，如果 cls._instance 為 None 則創建實例，否則直接返回 cls._instance。

            執行情況如下：

            1 2 3 4 5 6 7 8 >>> one = MyClass() >>> two = MyClass() >>> one == two True >>> one is two True >>> id(one), id(two) (4303862608, 4303862608)

            使用裝飾器

            我們知道，裝飾器（decorator）可以動態地修改一個類或函數的功能。這裏，我們也可以使用裝飾器來裝飾某個類，使其只能生成一個實例，代碼如下：

            1 2 3 4 5 6 7 8 9 10 11 12 13 14 from functools import wraps def singleton(cls): instances = {} @wraps(cls) def getinstance(*args, **kw): if cls not in instances: instances[cls] = cls(*args, **kw) 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）可以控制類的創建過程，它主要做三件事：

            • 攔截類的創建
            • 修改類的定義
            • 返回修改後的類

            使用元類實現單例模式的代碼如下：

            1 2 3 4 5 6 7 8 9 10 11 12 13 14 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

python的單例模式

相關推薦

Python 單例模式

single 模式 ttr attr nbsp clas new bsp sat class Singleton(object): def __new__(cls, *args, **kw): if not hasattr(cls, ‘_insta

飄逸的python - 單例模式亂彈

trac obj single not def pop nbsp asa sel 方法一：裝飾器 利用“裝飾器只會執行一次”這個特點 1 def singleton(cls): 2 instances = []# 為什麽這裏不直接為None,因為內部函數沒法訪

Python單例模式

python sel 內存地址 turn obj 實例 **kwargs 一個 elf 因為最近的項目多次涉及到了單例模式，所以做個小筆記。 老師之前用到的只是在整個項目中的某一個文件自定義一個類，然後在該py文件中實例化一個對象，別的文件調用這只實例化過一次的類的對象

python-單例模式&工廠模式

**kwargs __new__ self. main ini name 實例 方法 not 1.單例模式 　　類外裝飾器實現單例模式，是攔截整個實例化過程。（__new__;__init__） def singleton(cls): _instance = {}

python單例模式控制成只初始化一次，常規型的python單例模式在新式類和經典類中的區別。

spa alt let __main__ python2 urn 時間 div 分享 單例模式的寫法非常多，但常規型的單例模式就是這樣寫的，各種代碼可能略有差異，但核心就是要搞清楚類屬性 實例屬性，就很容易寫出來，原理完全一模一樣。 如下： 源碼： class

python+單例模式

單例模式：　顧名思義，一個類，在整個專案的執行週期內只有一個例項 def singleton(cls,*args,**kwargs): instance = {} def _singleton(): if cls not in instance: instan

python單例模式淺談

單例模式 單例模式（Singleton Pattern）是一種常用的軟體設計模式，該模式的主要目的是確保某一個類只有一個例項存在。當你希望在整個系統中，某個類只能出現一個例項時，單例物件就能派上用場。 比如，某個伺服器程式的配置資訊存放在一個檔案中，客戶端通過一個 AppConf

python 單例模式下的super

最近協作搞了一個軟體，用到了super()，是在單繼承的境況下。 兒子繼承爸爸的故事 class Baba(object): def init(self): self.name = ‘baba’ print(self.name,‘才算開始’) def age(s

最簡單的Python單例模式程式碼

廢話不扯 直接上程式碼: # 例項化一個單例 class Singleton(object): __instance = None __first_init = True def __new__(cls, age, name):

python單例模式示例

# -*- coding: utf-8 -*- class SendMessage(object): """呼叫第三方介面傳送簡訊的功能""" def __new__(cls, *args

Python單例模式剖析

在聊這之前我們首先要明確的是，單例模式在實際中的意義以及在python中具有實現的價值？ 當前，相信有很多人支援單例模式，也有不少人反對，尤其是在python中，目前依舊具有很大的爭議性。我們要在評論之前首先要了解單例模式 什麼是單例模式？ 顧名思義：就是單個模式 單例模式是

Python:單例模式

轉載自 單例(Singleton)模式 也叫單態模式 概述：單例（Singleton）模式要求一個類有且僅有一個例項，並且提供了一個全域性的訪問點。這就提出了一個問題：如何繞過常規的構造器，提供一種機制來保證一個類只有一個例項？客戶程式在呼叫某一個類時，它是不會考慮這

Python-單例模式-只初始化一次

單例模式 只初始化一次 單例模式建立的原理就是借用了私有類屬性的性質，我們知道私有類屬性不能直接在類外被修改，所以用私有類屬性的狀態當做條件來控制類內方法的呼叫 下面程式碼中的__species負責控制__new__方法，保證例項物件只能被建立一次，建立多

python單例模式三種實現方法

1.方法1，程式執行過程中，某個類物件只有1個，該類物件的例項物件可以有無數個，根絕這點，讓類物件持有一個例項化物件，重寫類物件的__new__方法，始終返回持有的這個例項化物件，即可實現單例模式。 class Person1: _single = None

python 單例模式----裝飾器實現

1、閉包的實現 #coding:utf-8 def A(): s1=2 def B(): sum1=s1+2 return sum1 return B if __name__ == '__main__':

單例模式【python】

bsp zhong factory 單例 單例模式 返回 一個 判斷 模式 　　在python中，如需讓一個類只能創建一個實例對象，怎麽能才能做到呢? 　　思路：1.通過同一個類創建的不同對象，都讓他們指向同一個方向。 　　　　 2.讓個類只能創建唯一的實例對象。

Python設計模式之單例模式

定義 eat size 字典 con gin 自動 super pytho 單例模式單例模式需要註意的地方在於如何保證創建的實例是唯一的如何保證多線程情況下的訪問清晰明了目前有這麽幾種方法：modulemetaclass__new__decoratormodule其實，Py

Python 實現單例模式

python 單例模式 Python 實現單例模式 # 使用Python實現單例模式 # 方法一: 使用__new__方法 class SingleTon(object): def __new__(cls, *args, **kwargs): if not ha

Python中的單例模式

字典 否則 我們 方法 模塊 self ict 實現 meta 在python中，我們可以用多種方法來實現單例模式： 　　- 使用模塊 　　- 使用__new__ 　　- 使用裝飾器 　　- 使用元類（metaclass） 使用模塊 　　其實，python的模塊就是天然的單

python的單例模式

__init__ ext ray 概念 port 程序 設計 eight 軟件設計 單例模式(Singleton Pattern)，是一種軟件設計模式，是類只能實例化一個對象， 　　　　目的是便於外界的訪問，節約系統資源，如果希望系統中 只有一個對象可以訪問，就用單例模式，