pythonlogging單例

① 怎麼理解python單例模式

在聊這之前我們首先要明確的是，單例模式在實際中的意義以及在python中具有實現的價值？

當前，相信有很多人支持單例模式，也有不少人反對，尤其是在python中，目前依舊具有很大的爭議性。我們要在評論之前首先要了解單例模式

什麼是單例模式？

顧名思義：就是單個模式

單例模式是一種常見的軟體設置模式，在它的核心結構中只包含一個被稱為單例類的特殊類，通過單例模式可以保證系統中的一個類只有一個實例而且該實例易於外界訪問，從而方便對實例個數的控制並節約系統資源。如果希望在系統中某個對象只能存在一個，單例模式是最好的解決方案。

單例模式的要點有三類

• 某個類只能有一個實例

• 它必須創建這個實例

• 它必須自行向整個系統提供這個實例

但是從具體角度實現來說的話，又可以分為三點

• 單例模式的類只能提供私有的構造函數

• 類定義中含有一個該類的靜態私有對象

• 該類提供了一個靜態的共有的函數用於創建或獲取它本身的靜態私有對象

一、實例控制

單例模式會阻止其他對象實例化其自己的單例對象的副本，從而確保所有對象都訪問唯一實例。

二、靈活性

因為類控制了實例化過程，所以類可以靈活更改實例化過程。

缺點：

一、開銷

雖然數量很少，但如果每次對象請求引用時都要檢查是否存在類的實例，將仍然需要一些開銷。可以通過使用靜態初始化解決此問題。

二、可能的開發混淆

使用單例對象（尤其在類庫中定義的對象）時，開發人員必須記住自己不能使用new關鍵字實例化對象。因為可能無法訪問庫源代碼，因此應用程序開發人員可能會意外發現自己無法直接實例化此類。

三、對象生存期

不能解決刪除單個對象的問題。在提供內存管理的語言中（例如基於.NET Framework的語言），只有單例類能夠導致實例被取消分配，因為它包含對該實例的私有引用。在某些語言中（如 C++），其他類可以刪除對象實例，但這樣會導致單例類中出現懸浮引用。

常用幾種方式

通過面向的特性，簡單的構造出單例模式

123456789101112131415
# ########### 單例類定義 ###########classFoo(object):__instance=None@staticmethoddefsingleton():ifFoo.__instance:returnFoo.__instanceelse:Foo.__instance=Foo()returnFoo.__instance# ########### 獲取實例 ###########obj=Foo.singleton()

當用於WEB界面時，單例模式的簡單運用

web 單例模式

不過我們需要注意的是：

特殊方法__new__是一個元構造程序，每當一個對象必須被factory類實例化時，就將調用它。__new__方法必須返回一個類的實例，因此它可以在對象創建之前或之後修改類。

因為__init__在子類中不會被隱式調用，所以__new__可以用來確定已經在整個類層次完成了初始化構造。__new__是對於對象狀態隱式初始化需求的回應，使得可以在比__init__更低的一個層次上定義一個初始化，這個初始化總是會被調用。

與__init__()相比__new__()方法更像一個真正的構造器。隨著類和類型的統一，用戶可以對內建類型進行派生，因此需要一種途徑來實例化不可變對象，比如派生字元串，在這種情況下解釋器則調用類的__new__（）方法，一個靜態方法，並且傳入的參數是在類實例化操作時生成的。__new__()會調用父類的__new__()來創建對象（向上代理）
·__new__必須返回一個合法的實例，這樣解釋器在調用__init__()時，就可以吧這個實例作為self傳給他。調用父類的__new__（）來創建對象，正向其他語言使用new關鍵字一樣

總結

單利模式存在的目的是保證當前內存中僅存在單個實例，避免內存浪費！！！

② python 單例

類的靜態變數要用classmethod來實現：
import os,sys
class A():
static_data = -1
@classmethod
def set_last(cls, newdata):
temp = cls.static_data
cls.static_data = newdata
return temp

o1=A()
print o1.static_data
A.set_last(12)
print A.static_data
o2=A()
print o2.static_data

輸出：
-1
12
12

③ python中使用logging模塊在控制台列印日誌的同時也列印log文件，但發現控制台的信息會出現重復列印

loggin模塊需要進行很多封裝才好用，你這種情況應該是初始化有問題，給你貼一段代碼你自己照抄下來用用試試。

#-*-coding:UTF8-*-
#

importos
importlogging

classLogger(object):
'''
@summary:日誌處理對象,對logging的封裝
'''
def__init__(self,name='Logger'):

self.logger=logging.getLogger(name)

self.init_logger()

definit_logger(self):

self.logger.setLevel(logging.DEBUG)

#屏幕輸出日誌
stream=logging.StreamHandler()
stream.setLevel(logging.INFO)
#日誌樣式
fm_stream=logging.Formatter("[33[1;%(colorcode)sm%(levelname)s33[0m%(asctime)s%(myfn)s:%(mylno)d:%(myfunc)s%(mymole)s]%(message)s","%m-%d%H:%M:%S")
stream.setFormatter(fm_stream)

self.logger.addHandler(stream)

defupdate_kwargs(self,kwargs,colorcode):
try:
fn,lno,func=self.logger.findCaller()
fn=os.path.basename(fn)
exceptExceptionasddd:
fn,lno,func="(unknownfile)",0,"(unknownfunction)"

ifnot"extra"inkwargs:
kwargs["extra"]={}

kwargs["extra"]["myfn"]=fn
kwargs["extra"]["mylno"]=lno
kwargs["extra"]["myfunc"]=func
kwargs["extra"]["colorcode"]=colorcode
kwargs["extra"]["mymole"]=""

defdebug(self,msg,*args,**kwargs):
self.update_kwargs(kwargs,"0")#原色
self.logger.debug(msg,*args,**kwargs)

definfo(self,msg,*args,**kwargs):
self.update_kwargs(kwargs,"32")#綠色
self.logger.info(msg,*args,**kwargs)

defwarning(self,msg,*args,**kwargs):
self.update_kwargs(kwargs,"33")#黃色
self.logger.warning(msg,*args,**kwargs)

deferror(self,msg,*args,**kwargs):
self.update_kwargs(kwargs,"31")#紅色
self.logger.error(msg,*args,**kwargs)

defcritical(self,msg,*args,**kwargs):
self.update_kwargs(kwargs,"31")#紅色
self.logger.critical(msg,*args,**kwargs)

使用方法：

fromloggerimportLogger


Logger().info('xxxxx')
Logger().warning('xxxxx')
Logger().error('xxxxx')

④ python程序中logging怎麼用

簡單將日誌列印到屏幕：

[python] view plain
import logging
logging.debug('debug message')
logging.info('info message')
logging.warning('warning message')
logging.error('error message')
logging.critical('critical message')

輸出：

WARNING:root:warning message
ERROR:root:error message
CRITICAL:root:critical message

可見，默認情況下Python的
logging模塊將日誌列印到了標准輸出中，且只顯示了大於等於WARNING級別的日誌，這說明默認的日誌級別設置為WARNING（日誌級別等級
CRITICAL > ERROR > WARNING > INFO > DEBUG >
NOTSET），默認的日誌格式為日誌級別：Logger名稱：用戶輸出消息。

靈活配置日誌級別，日誌格式，輸出位置

[python] view plain
import logging
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
datefmt='%a, %d %b %Y %H:%M:%S',
filename='/tmp/test.log',
filemode='w')

logging.debug('debug message')
logging.info('info message')
logging.warning('warning message')
logging.error('error message')
logging.critical('critical message')
查看輸出：
cat /tmp/test.log
Mon, 05 May 2014 16:29:53 test_logging.py[line:9] DEBUG debug message
Mon, 05 May 2014 16:29:53 test_logging.py[line:10] INFO info message
Mon, 05 May 2014 16:29:53 test_logging.py[line:11] WARNING warning message
Mon, 05 May 2014 16:29:53 test_logging.py[line:12] ERROR error message
Mon, 05 May 2014 16:29:53 test_logging.py[line:13] CRITICAL critical message

可見在logging.basicConfig()函數中可通過具體參數來更改logging模塊默認行為，可用參數有
filename：用指定的文件名創建FiledHandler（後邊會具體講解handler的概念），這樣日誌會被存儲在指定的文件中。
filemode：文件打開方式，在指定了filename時使用這個參數，默認值為「a」還可指定為「w」。
format：指定handler使用的日誌顯示格式。
datefmt：指定日期時間格式。
level：設置rootlogger（後邊會講解具體概念）的日誌級別
stream：用指定的stream創建StreamHandler。可以指定輸出到sys.stderr,sys.stdout或者文件，默認為sys.stderr。若同時列出了filename和stream兩個參數，則stream參數會被忽略。

format參數中可能用到的格式化串：
%(name)s Logger的名字
%(levelno)s 數字形式的日誌級別
%(levelname)s 文本形式的日誌級別
%(pathname)s 調用日誌輸出函數的模塊的完整路徑名，可能沒有
%(filename)s 調用日誌輸出函數的模塊的文件名
%(mole)s 調用日誌輸出函數的模塊名
%(funcName)s 調用日誌輸出函數的函數名
%(lineno)d 調用日誌輸出函數的語句所在的代碼行
%(created)f 當前時間，用UNIX標準的表示時間的浮 點數表示
%(relativeCreated)d 輸出日誌信息時的，自Logger創建以 來的毫秒數
%(asctime)s 字元串形式的當前時間。默認格式是 「2003-07-08 16:49:45,896」。逗號後面的是毫秒
%(thread)d 線程ID。可能沒有
%(threadName)s 線程名。可能沒有
%(process)d 進程ID。可能沒有
%(message)s用戶輸出的消息

⑤ Python中的單例模式的幾種實現方式的及優化

單例模式就是 ： 1、類的構造函數為private，即外部程序不能通過new關鍵字創建對象的實例 2、類中提供一個private static的 類變數引用 ； 3、單例類中提供靜態方法 定義為 public static 的方法獲取一個類的實例 ； 4、靜態方法返回 類的引用，...

⑥ python用logging模塊寫日誌文件無輸出

來個簡單點的

#-*-coding:utf-8-*-

importlogging

__author__='lpe234'
__date__='2015-04-30'

LOGGING_FILE='xx.log'

logging.basicConfig(
level=logging.INFO,
format='%(asctime)s%(filename)s[line:%(lineno)d]%(levelname)s%(message)s',
filename=LOGGING_FILE,
filemode='a+'
)

logging.debug('debug')
logging.info('info')
logging.exception('exception')
logging.error('error')
logging.critical('critical')

⑦ Python如何實現單例模式

有些時候你的項目中難免需要一些全局唯一的對象,這些對象大多是一些工具性的東西,在Python中實現單例模式並不是什麼難事。以下總結幾種方法:
使用類裝飾器
使用裝飾器實現單例類的時候,類本身並不知道自己是單例的,所以寫代碼的人可以不care這個,只要正常寫自己的類的實現就可以,類的單例有裝飾器保證。
def singleton(cls):
instances = {}
def _wrapper(*args, **kwargs):
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return _wrapper
你會發現singleton裝飾器內部使用了一個dict。當然你也可以用其他的方式,不過以下的實現是錯誤的:
def singleton(cls):
_instance = None #外部作用域的引用對於嵌套的內部作用域是只讀的
def _wrapper(*args, **kwargs):
if _instance is None: #解釋器會拋出"UnboundLocalError: ...referenced before assignment"
_instance = cls(*args, **kwargs) #賦值行為使解釋器將"_instance"看作局部變數
return _instance
return _wrapper
使用元類(__metaclass__)和可調用對象(__call__)
Python的對象系統中一些皆對象,類也不例外,可以稱之為」類型對象」,比較繞,但仔細思考也不難:類本身也是一種對象,只不過這種對象很特殊,它表示某一種類型。是對象,那必然是實例化來的,那麼誰實例化後是這種類型對象呢?也就是元類。
Python中,class關鍵字表示定義一個類對象,此時解釋器會按一定規則尋找__metaclass__,如果找到了,就調用對應的元類實現來實例化該類對象;沒找到,就會調用type元類來實例化該類對象。
__call__是Python的魔術方法,Python的面向對象是」Duck type」的,意味著對象的行為可以通過實現協議來實現,可以看作是一種特殊的介面形式。某個類實現了__call__方法意味著該類的對象是可調用的,可以想像函數調用的樣子。再考慮一下foo=Foo()這種實例化的形式,是不是很像啊。結合元類的概念,可以看出,Foo類是單例的,則在調用Foo()的時候每次都返回了同樣的對象。而Foo作為一個類對象是單例的,意味著它的類(即生成它的元類)是實現了__call__方法的。所以可以如下實現:
class Singleton(type):
def __init__(cls, name, bases, attrs):
super(Singleton, cls).__init__(name, bases, attrs)
cls._instance = None
def __call__(cls, *args, **kwargs):
if cls._instance is None
# 以下不要使用'cls._instance = cls(*args, **kwargs)', 防止死循環,
# cls的調用行為已經被當前'__call__'協議攔截了
# 使用super(Singleton, cls).__call__來生成cls的實例
cls._instance = super(Singleton, cls).__call__(*args, **kwargs)
return cls._instance

class Foo(object): #單例類
__metaclass__ = Singleton

>>>a = Foo()
>>>b = Foo()
>>>a is b
>>>True
>>>a.x = 1
>>>b.x
>>>1
使用__new__
__init__不是Python對象的構造方法,__init__只負責初始化實例對象,在調用__init__方法之前,會首先調用__new__方法生成對象,可以認為__new__方法充當了構造方法的角色。所以可以在__new__中加以控制,使得某個類只生成唯一對象。具體實現時可以實現一個父類,重載__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

class Foo(Singleton): #單例類
a = 1

⑧ Python中的單例模式與反彈機制

一。單例模式

一般情況下,類可以生成任意個實例,而單例模式只生成一個實例

我們先用單例模式設計一個Rectangle類

然後用__new__方法設計單例模式，代碼如下

然後我們來驗證下，單例模式下是否只能生成一個實例

單例模式在程序設計中比較典型的應用場景：多個用戶同時調用某個模塊時，會生成一些日誌，我們希望這些日誌存在同一個文件內，而不是多個文件。

在生成日誌模塊我們就可以採用單例模式進行設計。

二。反射

概念：簡單來說就是可以利用字元串來映射模塊中的相應方法然後可以操作模塊中相應的方法

我們以一個飯店點菜的實際場景來理解Python的反射機制

hasatter(對象,屬性或方法名)

判斷對象中是否有某個屬性或某個方法,返回值是布爾型

getattr(對象,屬性或方法名,預設值) 判斷對象中是否有某個屬性或某個方法，如果有返回方法本身，沒有則返回預設值

setattr(對象,屬性,新值)

將實例的屬性改為新的值,如果屬性不存在則新建

我們給實例guke1加個價格屬性

⑨ python logging 意圖：根據運行的不同時間來創建log文件，而不是固定命名，如：2013-06-13.log

原生loggging類+TimedRotatingFileHandler類實現按dayhoursecond切分
importlogging
fromlogging.
log=logging.getLogger(loggerName)
formatter=logging.Formatter('%(name)-12s%(asctime)slevel-%(levelname)-8sthread-%(thread)-8d%(message)s')#每行日誌的前綴設置
fileTimeHandler=TimedRotatingFileHandler(BASIC_LOG_PATH+filename,"S",1,10)
fileTimeHandler.suffix="%Y%m%d.log"#設置切分後日誌文件名的時間格式默認filename+"."+suffix如果需要更改需要改logging源碼
fileTimeHandler.setFormatter(formatter)
logging.basicConfig(level=logging.INFO)
fileTimeHandler.setFormatter(formatter)
log.addHandler(fileTimeHandler)
try:
log.error(msg)
exceptException,e:
print"writeLogerror"
finally:
log.removeHandler(fileTimeHandler)

值 interval的類型
S 秒
M 分鍾
H 小時
D 天
W 周
midnight 在午夜

⑩ logging python怎麼用

簡單使用
#!/usr/local/bin/python
# -*- coding:utf-8 -*-
import logging
logging.debug('debug message')
logging.info('info message')
logging.warn('warn message')
logging.error('error message')
logging.critical('critical message')
輸出：
WARNING:root:warn message
ERROR:root:error message
CRITICAL:root:critical message