當前位置:首頁 » 編程語言 » python的syslog

python的syslog

發布時間: 2022-11-30 07:05:50

1. import syslog 怎麼導入的python

不過shell支持的腳本很多已被python代替。所以在linux的系統初始化,運維管理中大量可以看到python腳本。 對於一個python老手來說,用shell腳本編程不如直接寫個python腳本。完全 沒有必要學習兩套編程方式。

至我python用了10幾年了,一直覺著寫一個超過50行的shell腳本沒有必要。有python足夠了。偶爾寫個十幾行的shell比較常用。再多就要用python了。

在有些特殊的操作系統里,GUI被重新設計過,其中某個操作系統甚至沒有什麼命令行,幾乎完全 圖形化。 這些操作系統里沒有shell的地位。它被取代了。

同樣,如果我們用python寫一個操作系統,顯然shell不需要了。

2. 如何釋放Python佔用的內存

在上文的優化中,對每500個用戶,會進行一些計算並記錄結果在磁碟文件中。原本以為這么做,這些結果就在磁碟文件中了,而不會再繼續佔用內存;但實際上,python的大坑就是Python不會自動清理這些內存。這是由其本身實現決定的。具體原因網上多有文章介紹,這里就不了。
本篇博客將貼一個筆者的實驗腳本,用以說明Python確實存在這么一個不釋放內存的現象,另外也提出一個解決方案,即:先del,再顯式調用gc.collect(). 腳本和具體效果見下。

實驗環境一:Win 7, Python 2.7

[python] view plain
from time import sleep, time
import gc

def mem(way=1):
print time()
for i in range(10000000):
if way == 1:
pass
else: # way 2, 3
del i

print time()
if way == 1 or way == 2:
pass
else: # way 3
gc.collect()
print time()

if __name__ == "__main__":
print "Test way 1: just pass"
mem(way=1)
sleep(20)
print "Test way 2: just del"
mem(way=2)
sleep(20)
print "Test way 3: del, and then gc.collect()"
mem(way=3)
sleep(20)

運行結果如下:

[plain] view plain
Test way 1: just pass
1426688589.47
1426688590.25
1426688590.25
Test way 2: just del
1426688610.25
1426688611.05
1426688611.05
Test way 3: del, and then gc.collect()
1426688631.05
1426688631.85
1426688631.95

對於way 1和way 2,結果是完全一樣的,程序內存消耗峰值是326772KB,在sleep 20秒時,內存實時消耗是244820KB;
對於way 3,程序內存消耗峰值同上,但是sleep時內存實時消耗就只有6336KB了。

實驗環境二: Ubuntu 14.10, Python 2.7.3

運行結果:

[plain] view plain
Test way 1: just pass
1426689577.46
1426689579.41
1426689579.41
Test way 2: just del
1426689599.43
1426689601.1
1426689601.1
Test way 3: del, and then gc.collect()
1426689621.12
1426689622.8
1426689623.11

[plain] view plain
[email protected]_machine:~$ ps -aux | grep test_mem
Warning: bad ps syntax, perhaps a bogus '-'? See
ubuntu 9122 10.0 6.0 270916 245564 pts/1 S+ 14:39 0:03 python test_mem.py
ubuntu 9134 0.0 0.0 8104 924 pts/2 S+ 14:40 0:00 grep --color=auto test_mem
[email protected]_machine:~$ ps -aux | grep test_mem
Warning: bad ps syntax, perhaps a bogus '-'? See
ubuntu 9122 10.0 6.0 270916 245564 pts/1 S+ 14:39 0:03 python test_mem.py
ubuntu 9134 0.0 0.0 8104 924 pts/2 S+ 14:40 0:00 grep --color=auto test_mem
[email protected]_machine:~$ ps -aux | grep test_mem
Warning: bad ps syntax, perhaps a bogus '-'? See
ubuntu 9122 11.6 0.1 30956 5608 pts/1 S+ 14:39 0:05 python test_mem.py

結論:
以上說明,當調用del時,其實Python並不會真正release內存,而是將其繼續放在其內存池中;只有在顯式調用gc.collect()時,才會真正release內存。

進一步:
其實回到上一篇博客的腳本中,也讓其引入gc.collect(),然後寫個監控腳本監測內存消耗情況:

[plain] view plain
while ((1)); do ps -aux | sort -n -k5,6 | grep my_script; free; sleep 5; done

結果發現:內存並不會在每500個用戶一組執行完後恢復,而是一直持續消耗到僅存約70MB時,gc才好像起作用。本環境中,機器使用的是Cloud instance,總內存2G,可用內存約為1G,本腳本內存常用消耗是900M - 1G。換句話說,對於這個腳本來說,gc並沒有立即起作用,而是在系統可用內存從1 - 1.2G下降到只剩70M左右時,gc才開始發揮作用。這點確實比較奇怪,不知道和該腳本是在Thread中使用的gc.collect()是否有關,或者是gc發揮作用原本就不是可控的。筆者尚未做相關實驗,可能在下篇博客中繼續探討。

但是,可以肯定的是,若不使用gc.collect(), 原腳本將會將系統內存耗盡而被殺死。這一點從syslog中可以明顯看出。

3. python出錯,請問是什麼問題

要把代碼發現來才知道,以下是常見的錯誤
下面終於要講到當你用到更多的Python的功能(數據類型,函數,模塊,類等等)時可能碰到的問題了。由於篇幅有限,這里盡量精簡,尤其是對一些高級的概念。要想了解更多的細節,敬請閱讀Learning Python, 2nd Edition的「小貼士」以及「Gotchas」章節。

打開文件的調用不使用模塊搜索路徑
當你在Python中調用open()來訪問一個外部的文件時,Python不會使用模塊搜索路徑來定位這個目標文件。它會使用你提供的絕對路徑,或者假定這個文件是在當前工作目錄中。模塊搜索路徑僅僅為模塊載入服務的。
不同的類型對應的方法也不同
列表的方法是不能用在字元串上的,反之亦然。通常情況下,方法的調用是和數據類型有關的,但是內部函數通常在很多類型上都可以使用。舉個例子來說,列表的reverse方法僅僅對列表有用,但是len函數對任何具有長度的對象都適用
不能直接改變不可變數據類型
記住你沒法直接的改變一個不可變的對象(例如,元組,字元串):

T = (1, 2, 3)
T[2] = 4 # 錯誤

用切片,聯接等構建一個新的對象,並根據需求將原來變數的值賦給它。因為Python會自動回收沒有用的內存,因此這沒有看起來那麼浪費:

T = T[:2] + (4,) # 沒問題了: T 變成了 (1, 2, 4)

使用簡單的for循環而不是while或者range
當你要從左到右遍歷一個有序的對象的所有元素時,用簡單的for循環(例如,for x in seq:)相比於基於while-或者range-的計數循環而言會更容易寫,通常運行起來也更快。除非你一定需要,盡量避免在一個for循環里使用range:讓Python來替你解決標號的問題。在下面的例子中三個循環結構都沒有問題,但是第一個通常來說更好;在Python里,簡單至上。

S = "lumberjack"

for c in S: print c # 最簡單

for i in range(len(S)): print S[i] # 太多了

i = 0 # 太多了
while i < len(S): print S[i]; i += 1

不要試圖從那些會改變對象的函數得到結果
諸如像方法list.append()和list.sort()一類的直接改變操作會改變一個對象,但不會將它們改變的對象返回出來(它們會返回None);正確的做法是直接調用它們而不要將結果賦值。經常會看見初學者會寫諸如此類的代碼:

mylist = mylist.append(X)

目的是要得到append的結果,但是事實上這樣做會將None賦值給mylist,而不是改變後的列表。更加特別的一個例子是想通過用排序後的鍵值來遍歷一個字典里的各個元素,請看下面的例子:

D = {...}
for k in D.keys().sort(): print D[k]

差一點兒就成功了——keys方法會創建一個keys的列表,然後用sort方法來將這個列表排序——但是因為sort方法會返回None,這個循環會失敗,因為它實際上是要遍歷None(這可不是一個序列)。要改正這段代碼,將方法的調用分離出來,放在不同的語句中,如下:

Ks = D.keys()
Ks.sort()
for k in Ks: print D[k]

只有在數字類型中才存在類型轉換
在Python中,一個諸如123+3.145的表達式是可以工作的——它會自動將整數型轉換為浮點型,然後用浮點運算。但是下面的代碼就會出錯了:

S = "42"
I = 1
X = S + I # 類型錯誤

這同樣也是有意而為的,因為這是不明確的:究竟是將字元串轉換為數字(進行相加)呢,還是將數字轉換為字元串(進行聯接)呢?在Python中,我們認為「明確比含糊好」(即,EIBTI(Explicit is better than implicit)),因此你得手動轉換類型:

X = int(S) + I # 做加法: 43
X = S + str(I) # 字元串聯接: "421"

循環的數據結構會導致循環
盡管這在實際情況中很少見,但是如果一個對象的集合包含了到它自己的引用,這被稱為循環對象(cyclic object)。如果在一個對象中發現一個循環,Python會輸出一個[…],以避免在無限循環中卡住:

>>> L = ['grail'] # 在 L中又引用L自身會
>>> L.append(L) # 在對象中創造一個循環
>>> L
['grail', [...]]

除了知道這三個點在對象中表示循環以外,這個例子也是很值得借鑒的。因為你可能無意間在你的代碼中出現這樣的循環的結構而導致你的代碼出錯。如果有必要的話,維護一個列表或者字典來表示已經訪問過的對象,然後通過檢查它來確認你是否碰到了循環。
賦值語句不會創建對象的副本,僅僅創建引用
這是Python的一個核心理念,有時候當行為不對時會帶來錯誤。在下面的例子中,一個列表對象被賦給了名為L的變數,然後L又在列表M中被引用。內部改變L的話,同時也會改變M所引用的對象,因為它們倆都指向同一個對象。

>>> L = [1, 2, 3] # 共用的列表對象
>>> M = ['X', L, 'Y'] # 嵌入一個到L的引用
>>> M
['X', [1, 2, 3], 'Y']

>>> L[1] = 0 # 也改變了M
>>> M
['X', [1, 0, 3], 'Y']

通常情況下只有在稍大一點的程序里這就顯得很重要了,而且這些共用的引用通常確實是你需要的。如果不是的話,你可以明確的給他們創建一個副本來避免共用的引用;對於列表來說,你可以通過使用一個空列表的切片來創建一個頂層的副本:

>>> L = [1, 2, 3]
>>> M = ['X', L[:], 'Y'] # 嵌入一個L的副本

>>> L[1] = 0 # 僅僅改變了L,但是不影響M
>>> L
[1, 0, 3]
>>> M
['X', [1, 2, 3], 'Y']

切片的范圍起始從默認的0到被切片的序列的最大長度。如果兩者都省略掉了,那麼切片會抽取該序列中的所有元素,並創造一個頂層的副本(一個新的,不被公用的對象)。對於字典來說,使用字典的dict.()方法。
靜態識別本地域的變數名
Python默認將一個函數中賦值的變數名視作是本地域的,它們存在於該函數的作用域中並且僅僅在函數運行的時候才存在。從技術上講,Python是在編譯def代碼時,去靜態的識別本地變數,而不是在運行時碰到賦值的時候才識別到的。如果不理解這點的話,會引起人們的誤解。比如,看看下面的例子,當你在一個引用之後給一個變數賦值會怎麼樣:

>>> X = 99
>>> def func():
... print X # 這個時候還不存在
... X = 88 # 在整個def中將X視作本地變數
...
>>> func( ) # 出錯了!

你會得到一個「未定義變數名」的錯誤,但是其原因是很微妙的。當編譯這則代碼時,Python碰到給X賦值的語句時認為在這個函數中的任何地方X會被視作一個本地變數名。但是之後當真正運行這個函數時,執行print語句的時候,賦值語句還沒有發生,這樣Python便會報告一個「未定義變數名」的錯誤。
事實上,之前的這個例子想要做的事情是很模糊的:你是想要先輸出那個全局的X,然後創建一個本地的X呢,還是說這是個程序的錯誤?如果你真的是想要輸出這個全局的X,你需要將它在一個全局語句中聲明它,或者通過包絡模塊的名字來引用它。
默認參數和可變對象
在執行def語句時,默認參數的值只被解析並保存一次,而不是每次在調用函數的時候。這通常是你想要的那樣,但是因為默認值需要在每次調用時都保持同樣對象,你在試圖改變可變的默認值(mutable defaults)的時候可要小心了。例如,下面的函數中使用一個空的列表作為默認值,然後在之後每一次函數調用的時候改變它的值:

>>> def saver(x=[]): # 保存一個列表對象
... x.append(1) # 並每次調用的時候
... print x # 改變它的值
...
>>> saver([2]) # 未使用默認值
[2, 1]
>>> saver() # 使用默認值
[1]
>>> saver() # 每次調用都會增加!
[1, 1]
>>> saver()
[1, 1, 1]

有的人將這個視作Python的一個特點——因為可變的默認參數在每次函數調用時保持了它們的狀態,它們能提供像C語言中靜態本地函數變數的類似的一些功能。但是,當你第一次碰到它時會覺得這很奇怪,並且在Python中有更加簡單的辦法來在不同的調用之間保存狀態(比如說類)。
要擺脫這樣的行為,在函數開始的地方用切片或者方法來創建默認參數的副本,或者將默認值的表達式移到函數裡面;只要每次函數調用時這些值在函數里,就會每次都得到一個新的對象:

>>> def saver(x=None):

... if x is None: x = [] # 沒有傳入參數?
... x.append(1) # 改變新的列表
... print x
...
>>> saver([2]) # 沒有使用默認值
[2, 1]
>>> saver() # 這次不會變了
[1]
>>> saver()
[1]

其他常見的編程陷阱
下面列舉了其他的一些在這里沒法詳述的陷阱:
在頂層文件中語句的順序是有講究的:因為運行或者載入一個文件會從上到下運行它的語句,所以請確保將你未嵌套的函數調用或者類的調用放在函數或者類的定義之後。
reload不影響用from載入的名字:reload最好和import語句一起使用。如果你使用from語句,記得在reload之後重新運行一遍from,否則你仍然使用之前老的名字。
在多重繼承中混合的順序是有講究的:這是因為對superclass的搜索是從左到右的,在類定義的頭部,在多重superclass中如果出現重復的名字,則以最左邊的類名為准。
在try語句中空的except子句可能會比你預想的捕捉到更多的錯誤。在try語句中空的except子句表示捕捉所有的錯誤,即便是真正的程序錯誤,和sys.exit()調用,也會被捕捉到。

4. 如何用python編寫collectd的plugin

collect的Python plugin內嵌了一個python的解釋器,可以方便我們用python自定義collectd的plugin,各個callback的函數定義可以參考collectd python plugin。比如自定義一個統計cpu利用率的plugin:

cpu_usage_plugin.py

[python] view plain
#!/usr/bin/env python

import subprocess
import traceback

def get_cpu_usage():
cmd = "grep 'cpu ' /proc/stat | awk '{usage=($2+$4)*100/($2+$4+$5)} END {print usage}'"
result = run(cmd)
for line in result:
try:
usage = float(line)
return usage
except:
raise Exception("Failed to parse cpu usage")

def run(cmd):
try:
result = []
proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, close_fds=True)
(stdout, stderr) = proc.communicate()
output = stdout.split("\n")
for line in output:
if line == '':
continue
result.append(line)
return result
except Exception as err:
raise Exception("failed to execute command: %s, reason: %s" % (' '.join(cmd), err.message))

class CPUStatMon(object):
def __init__(self):
self.plugin_name = "cpu_stat"
self.interval = 30
self.hostname = None
self.verbose_logging = False

def log_verbose(self, msg):
if not self.verbose_logging:
return
collectd.info('%s plugin [verbose]: %s' % (self.plugin_name, msg))

'''''
to store/initialize the internal state like a socket connection
def init(self):
self.SOCKET_CONN = create_sockect_conn()
'''

def configure_callback(self, conf):
for node in conf.children:
val = str(node.values[0])
if node.key == "HostName":
self.hostname = val
elif node.key == 'Interval':
self.interval = int(float(val))
elif node.key == 'Verbose':
self.verbose_logging = val in ['True', 'true']
elif node.key == 'PluginName':
self.plugin_name = val
else:
collectd.warning('[plugin] %s: unknown config key: %s' % (self.plugin_name, node.key))

def dispatch_value(self, plugin, host, type, type_instance, value):
self.log_verbose("Dispatching value plugin=%s, host=%s, type=%s, type_instance=%s, value=%s" %
(plugin, host, type, type_instance, str(value)))
val = collectd.Values(type=type)
val.plugin = plugin
val.host = host
val.type_instance = type_instance
val.interval = self.interval
val.values = [value]
val.dispatch()
self.log_verbose("Dispatched value plugin=%s, host=%s, type=%s, type_instance=%s, value=%s" %
(plugin, host, type, type_instance, str(value)))

def read_callback(self):
try:
usage = get_cpu_usage()
type = 'cpu_usage_percent'
type_instance = "used"
value = usage
self.dispatch_value(self.plugin_name, self.hostname, type, type_instance, value)

except Exception as exp:
self.log_verbose(traceback.print_exc())
self.log_verbose("plugin %s run into exception" % (self.plugin_name))
self.log_verbose(exp.message)

if __name__ == '__main__':
result = get_cpu_usage()
print result

else:
import collectd
cpu_status_mon = CPUStatMon()
collectd.register_config(cpu_status_mon.configure_callback)
'''''
# register the init function
collectd.register_init(cpu_status_mon.init)
'''
collectd.register_read(cpu_status_mon.read_callback)

collectd.conf中enable python plugin並增加如下配置:

[plain] view plain
<Plugin python>
MolePath "/opt/collectd/lib/collectd"
Import "cpu_usage_plugin"
<Mole cpu_usage_plugin>
Interval 30
PluginName "cpu_usage"
HostName "demo_host"
Verbose false
</Mole>
</Plugin>

值得注意的是:

對於dispatch_value函數中type參數的值,可以直接傳入字元串gauge,derived,count等collectd的內建數據類型,也可以在types.db中對這些數據類型做一個map,看起來更有意義,如下所示:
[html] view plain
types.db

cpu_usage_percentage value:GAUGE:0:U

如果想維持某些變數的狀態,可以把該通過regiseter_init來注冊包含該變數的函數,如代碼中被注釋掉的地方。
如果有多個自定義的python plugin,在<Plugin python></Plugin>片段中使用多個Import導入相應的模塊,並定義多個<Mole></Mole>片段。
默認情況下,collectd的log在syslog中。

5. python的sys是什麼文件

sys-系統特定的參數和功能

該模塊提供對解釋器使用或維護的一些變數的訪問,以及與解釋器強烈交互的函數。它始終可用。

sys.argv

傳遞給Python腳本的命令行參數列表。argv[0]是腳本名稱(依賴於操作系統,無論這是否是完整路徑名)。如果使用-c解釋器的命令行選項執行命令,argv[0]則將其設置為字元串』-c』。如果沒有腳本名稱傳遞給Python解釋器,argv[0]則為空字元串。

要循環標准輸入或命令行上給出的文件列表,請參閱fileinput模塊。

sys.byteorder

本機位元組順序的指示符。這將具有』big』big-endian(最重要的位元組優先)平台和』little』little-endian(最不重要的位元組優先)平台的價值。

推薦學習《python教程》。

2.0版本中的新功能

sys.builtin_mole_names

一個字元串元組,給出了編譯到此Python解釋器中的所有模塊的名稱。(此信息不以任何其他方式提供 - moles.keys()僅列出導入的模塊。)

sys.call_tracing(func,args )

呼叫func(*args),同時啟用跟蹤。跟蹤狀態被保存,然後恢復。這是從調試器從檢查點調用,以遞歸調試其他一些代碼。

sys.right

包含與Python解釋器相關的版權的字元串

sys._clear_type_cache()

清除內部類型緩存。類型緩存用於加速屬性和方法查找。僅在參考泄漏調試期間使用該函數刪除不必要的引用。

此功能僅用於內部和專門用途。

版本2.6中的新功能。

sys._current_frames()

返回一個字典,將每個線程的標識符映射到調用該函數時該線程中當前活動的最頂層堆棧幀。請注意,traceback模塊中的函數可以在給定這樣的幀的情況下構建調用堆棧。

這對於調試死鎖是最有用的:這個函數不需要死鎖線程的協作,只要這些線程的調用堆棧保持死鎖,它們就會被凍結。對於非死鎖線程返回的幀在調用代碼檢查幀時可能與該線程的當前活動沒有關系。

此功能僅用於內部和專門用途。

2.5版中的新功能。

sys.dllhandle

指定Python DLL句柄的整數。可用性:Windows。

sys.displayhook(值)

如果值不是None,則此函數sys.stdout將其列印到並保存builtin._。

sys.displayhook調用在 互動式Python會話中輸入的表達式的結果。可以通過為其分配另一個單參數函數來自定義這些值的顯示sys.displayhook。

sys.dont_write_bytecode

如果這是真的,Python將不會嘗試在源模塊的導入上編寫.pyc或.pyo文件。此值最初設置為True或 False取決於-B命令行選項和 PYTHONDONTWRITEBYTECODE 環境變數,但您可以自己設置它來控制位元組碼文件的生成。

版本2.6中的新功能。

sys.excepthook(類型,值,回溯)

此函數列印出給定的回溯和異常sys.stderr。

當引發異常並且未被捕獲時,解釋器sys.excepthook使用三個參數調用 ,即異常類,異常實例和回溯對象。在互動式會話中,這發生在控制返回到提示之前; 在Python程序中,這發生在程序退出之前。可以通過為其分配另一個三參數函數來自定義此類頂級異常的處理sys.excepthook。

sys._displayhook_

sys._excepthook_

這些對象包含的原始值displayhook,並excepthook 在程序的開始。它們被保存,以便displayhook和 excepthook情況下可以恢復他們碰巧得到破碎的對象替換。

sys.exc_info()

此函數返回三個值的元組,這些值提供有關當前正在處理的異常的信息。返回的信息特定於當前線程和當前堆棧幀。如果當前堆棧幀未處理異常,則從調用堆棧幀或其調用者獲取信息,依此類推,直到找到正在處理異常的堆棧幀。這里,「處理異常」被定義為「正在執行或已執行except子句。」對於任何堆棧幀,只能訪問有關最近處理的異常的信息。

如果堆棧中的任何位置都沒有處理異常,None則返回包含三個值的元組 。否則,返回的值是。它們的含義是:type獲取正在處理的異常的異常類型(類對象); value獲取異常參數(其 關聯值或第二個參數,如果異常類型是類對象,則始終為類實例); traceback 獲取一個回溯對象(參見參考手冊),該對象在最初發生異常的位置封裝調用堆棧。(type, value, traceback)raise

如果exc_clear()被調用,則此函數將返回三個None值,直到當前線程中引發另一個異常或執行堆棧返回到正在處理另一個異常的幀。

6. python syslog 怎麼去模塊和進程編號

logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s:%(levelname)s:%(message)s',
filename=logging_file,
filemode='w',
)


format 配置如下類似的模版即可

%(pathname)s # 調用日誌輸出函數的模塊的完整路徑名,可能沒有


%(filename)s # 調用日誌輸出函數的模塊的文件名


%(mole)s # 調用日誌輸出函數的模塊名


%(funcName)s # 調用日誌輸出函數的函數名


%(lineno)d # 調用日誌輸出函數的語句所在的代碼行

7. python logging.conf是什麼類型文件

下面的函數用於配置logging模塊,它們位於logging.config模塊中。你可以使用這些函數來配置,也可以在logging或是logging.handlers中聲明它們來配置。
logging.config.dictConfig(config)
從dictionary中獲取logging配置
logging.config.fileConfig(fname, defaults=None, disable_existing_loggers=True)
從指定的fname的配置文件中讀取logging配置文件
該函數可以在應用程序中多次調用
logging.config.listen(port=DEFAULT_LOGGING_CONFIG_PORT)
在指定埠啟動socket server並偵聽新配置
logging.config.stopListening()
關閉先前正在偵聽的server

Configuration file format
被fileConfiguration()所理解的配置文件格式基於configparser功能。配置文件必須包含[loggers], [handlers]和[formatters],它們分別代表日誌文件中定義的每種類型的實體。對這3種實體,後面有一個單獨的section來定義該實體如何配置。
因此,[loggers]節中名為log01的logger,相關的配置文件細節在[logger_log01]節中定義。類似地,[handlers]節中名為
hand01的handler將在[handler_hand01]節中聲明,[formatters]節中的form01將在[formatter_form01]聲明。root logger配置必須在[logger_root]節聲明。
注意:fileConfig() API比dictConfig()舊,並不包含logging某些方面的功能。建議以後盡量使用dictConfig API。
配置文件的例子如下:
[loggers]
keys=root,log02,log03,log04,log05,log06,log07

[handlers]
keys=hand01,hand02,hand03,hand04,hand05,hand06,hand07,hand08,hand09

[formatters]
keys=form01,form02,form03,form04,form05,form06,form07,form08,form09

root logger必須指定一個級別和handlers列表。示例如下:
[logger_root]
level=NOTSET
handlers=hand01
其中level可以是DEBUG, INFO, WARNING, ERROR, CRITICAL or NOTSET之一,僅對root logger來說,NOTSET意味著所有的log message
都會記錄。對非root的logger,強制要求一些額外信息,比如
[logger_parser]
level=DEBUG
handlers=hand01
propagate=1
qualname=compiler.parser
當一個非root的logger中level被配置為NOSET,它將通過上一級的logger來確定當前logger的有效級別。propagete為1表示message必須傳播到上一級logger中,為0表示不傳。qualname表示該logger的層級channel名稱,這就是說,應用程序使用該名稱可以得到該logger對象。
handler類型很多,主要有StreamHandler,FileHandler,NullHandler,SysLogHandler,HTTPHandler等
handler節對應的配置示例如下:
[handler_hand01]
class=StreamHandler
level=NOTSET
formatter=form01
args=(sys.stdout,)

class表示該handler在logging包命名空間中的類名,level表示logger的級別,NONSET表示要記錄所有日誌。
formatter表示該handler的formatter的鍵名,假如空白的話,就使用默認值logging._defaultFormatter。假如formatter指定了該名字,必須在對應的section聲明。args欄位是handler類的構造函數的變數列表,參考相關handler構造函數,或者下面的例子,去觀察通常的元素是如何構造的。比如:
[handler_hand02]
class=FileHandler
level=DEBUG
formatter=form02
args=('python.log', 'w')

下面是formatter的配置
[formatter_form01]
format=F1 %(asctime)s %(levelname)s %(message)s
datefmt=
class=logging.Formatter
format欄位是全局格式字元串,datefmt是strftime()兼容的date/time格式字元串,為空時使用默認的ISO8601格式,比如2003-01-23 00:29:50,411,class欄位表示formatter的類名,

日誌級別如下:
Level Numeric value
CRITICAL 50
ERROR 40
WARNING 30
INFO 20
DEBUG 10
NOTSET 0

logging.handlers解讀

logging模塊中定義了這3個handler:StreamHandler, FileHandler and NullHandler
其它的handler都在logging.handler中定義,一並說明如下:
StreamHandler
該類位於logging包,將logging output輸出到流中,比如sys.stdout,sys.stderr或任何支持write()和flush()方法的類文件對象
class logging.StreamHandler(stream=None)
假如指定了stream名稱,日誌將輸出到流實例中,否則,日誌輸出到sys.stderr

FileHandler
該類位於logging包,將logging output輸出到磁碟文件中,文件默認無限增長
class logging.FileHandler(filename, mode='a', encoding=None, delay=False)
打開指定的文件並記錄日誌,假如mode沒有設置,默認使用'a'表示追加日誌到文件中。

NullHandler
該對象什麼也不處理

WatchedFileHandler
一個FileHandler實例,監視日誌文件的變化,假如文件變化了,它會關閉並重新打開,不建議在Windows下使用
文件的變化可以發生,當應用程序使用newsyslog和logrotate來實現日誌文件的回滾時。這個handle是在Unix/Linux下面,監視文件是否改變。(一個文件認為改變了,假如它的device厚實inode已經改變),將舊的文件關閉,這個流打開。
class logging.handlers.WatchedFileHandler(filename[, mode[, encoding[, delay]]])
指定的文件被打開,用來記錄日誌,假如mode未指示,默認使用a

RotatingFileHandler
支持磁碟文件的回滾
class logging.handlers.RotatingFileHandler(filename, mode='a', maxBytes=0, backupCount=0, encoding=None, delay=0)
你可以使用 maxBytes和backupCount值去讓日誌文件在預設大小時回滾。只要日誌文件在長度上接近maxBytes時,就會關閉舊日誌文件,打開一個新的日誌文件,實現回滾。假如maxBytes或backupCount為0,回滾不會發生。假如backupCount非零,系統會備份舊文件,文件名後加『.1』, 『.2』 。比如,日誌文件名為app.log,backupCount為5,將會得到app.log, app.log.1, app.log.2, 直到app.log.5這6個文件。寫入日誌的文件總是app.log,當這個文件填滿時,就關閉它並重命名為app.log.1, 假如還存在app.log.1, app.log.2等文件,就逐一改名為app.log.2, app.log.3等等。

TimedRotatingFileHandler
支持在指定時間段內回滾日誌
class logging.handlers.TimedRotatingFileHandler(filename, when='h', interval=1, backupCount=0, encoding=None, delay=False, utc=False)
回滾基於when和interval設置,when指定interval的類型,參見下表,大小寫不敏感,默認按小時回滾
Value Type of interval
'S' Seconds
'M' Minutes
'H' Hours
'D' Days
'W0'-'W6' Weekday (0=Monday)
'midnight' Roll over at midnight
回滾擴展名使用strftime format %Y-%m-%d_%H-%M-%S或其頭部子字元串,當使用基於weekday的回滾時,W0表示周一,……,W6表示周日,interval的值不會用到
backupCount表示備份數,當日誌很多時,新日誌會覆蓋舊日誌,刪除邏輯使用interval值去決定刪除哪些日誌文件
utc為true,表示使用UTC時間,否則使用本地時間

SocketHandler
通過網路套接字輸出日誌,SocketHandler類的基類使用TCP socket
class logging.handlers.SocketHandler(host, port)
向指定地址和埠的遠程主機發送日誌

DatagramHandler
繼承自基類SocketHandler類,使用UDP socket發送日誌message
class logging.handlers.DatagramHandler(host, port)

SysLogHandler
發送日誌到遠程或是本地unix syslog
class logging.handlers.SysLogHandler(address=('localhost', SYSLOG_UDP_PORT), facility=LOG_USER, socktype=socket.SOCK_DGRAM)

NTEventLogHandler
發送日誌消息到本地Windows NT, Windows 2000 or Windows XP event log
class logging.handlers.NTEventLogHandler(appname, dllname=None, logtype='Application')

SMTPHandler
通過SMTP將日誌消息發送到email address

MemoryHandler
支持將日誌message緩存到內存中,周期性刷新日誌到target handler
class logging.handlers.BufferingHandler(capacity)
class logging.handlers.MemoryHandler(capacity, flushLevel=ERROR, target=None)

HTTPHandler
使用GET或是POST,將日誌message發送到web server
class logging.handlers.HTTPHandler(host, url, method='GET')

8. 如何解決的Python類型錯誤

1.Python異常類

Python是面向對象語言,所以程序拋出的異常也是類。常見的Python異常有以下幾個,大家只要大致掃一眼,有個映像,等到編程的時候,相信大家肯定會不只一次跟他們照面(除非你不用Python了)。

異常 描述
NameError 嘗試訪問一個沒有申明的變數
ZeroDivisionError 除數為0
SyntaxError 語法錯誤
IndexError 索引超出序列范圍
KeyError 請求一個不存在的字典關鍵字
IOError 輸入輸出錯誤(比如你要讀的文件不存在)
AttributeError 嘗試訪問未知的對象屬性
ValueError 傳給函數的參數類型不正確,比如給int()函數傳入字元串形
2.捕獲異常
Python完整的捕獲異常的語句有點像:
復制代碼 代碼如下:

try:
try_suite
except Exception1,Exception2,...,Argument:
exception_suite
...... #other exception block
else:
no_exceptions_detected_suite
finally:
always_execute_suite

額...是不是很復雜?當然,當我們要捕獲異常的時候,並不是必須要按照上面那種格式完全寫下來,我們可以丟掉else語句,或者finally語句;甚至不要exception語句,而保留finally語句。額,暈了?好吧,下面,我們就來一一說明啦。
2.1.try...except...語句
try_suite不消我說大家也知道,是我們需要進行捕獲異常的代碼。而except語句是關鍵,我們try捕獲了代碼段try_suite里的異常後,將交給except來處理。
try...except語句最簡單的形式如下:
復制代碼 代碼如下:

try:
try_suite
except:
exception block

上面except子句不跟任何異常和異常參數,所以無論try捕獲了任何異常,都將交給except子句的exception block來處理。如果我們要處理特定的異常,比如說,我們只想處理除零異常,如果其他異常出現,就讓其拋出不做處理,該怎麼辦呢?這個時候,我們就要給except子句傳入異常參數啦!那個ExceptionN就是我們要給except子句的異常類(請參考異常類那個表格),表示如果捕獲到這類異常,就交給這個except子句來處理。比如:
復制代碼 代碼如下:

try:
try_suite
except Exception:
exception block

舉個例子:
復制代碼 代碼如下:

>>> try:
... res = 2/0
... except ZeroDivisionError:
... print "Error:Divisor must not be zero!"
...
Error:Divisor must not be zero!

看,我們真的捕獲到了ZeroDivisionError異常!那如果我想捕獲並處理多個異常怎麼辦呢?有兩種辦法,一種是給一個except子句傳入多個異常類參數,另外一種是寫多個except子句,每個子句都傳入你想要處理的異常類參數。甚至,這兩種用法可以混搭呢!下面我就來舉個例子。
復制代碼 代碼如下:

try:
floatnum = float(raw_input("Please input a float:"))
intnum = int(floatnum)
print 100/intnum
except ZeroDivisionError:
print "Error:you must input a float num which is large or equal then 1!"
except ValueError:
print "Error:you must input a float num!"
[[email protected] tmp]# python test.py
Please input a float:fjia
Error:you must input a float num!
[[email protected] tmp]# python test.py
Please input a float:0.9999
Error:you must input a float num which is large or equal then 1!
[[email protected] tmp]# python test.py
Please input a float:25.091
4

上面的例子大家一看都懂,就不再解釋了。只要大家明白,我們的except可以處理一種異常,多種異常,甚至所有異常就可以了。
大家可能注意到了,我們還沒解釋except子句後面那個Argument是什麼東西?別著急,聽我一一道來。這個Argument其實是一個異常類的實例(別告訴我你不知到什麼是實例),包含了來自異常代碼的診斷信息。也就是說,如果你捕獲了一個異常,你就可以通過這個異常類的實例來獲取更多的關於這個異常的信息。例如:
復制代碼 代碼如下:

>>> try:
... 1/0
... except ZeroDivisionError,reason:
... pass
...
>>> type(reason)
<type 'exceptions.ZeroDivisionError'>
>>> print reason
integer division or molo by zero
>>> reason
ZeroDivisionError('integer division or molo by zero',)
>>> reason.__class__
<type 'exceptions.ZeroDivisionError'>
>>> reason.__class__.__doc__
'Second argument to a division or molo operation was zero.'
>>> reason.__class__.__name__
'ZeroDivisionError'

上面這個例子,我們捕獲了除零異常,但是什麼都沒做。那個reason就是異常類ZeroDivisionError的實例,通過type就可以看出。
2.2try ... except...else語句
現在我們來說說這個else語句。Python中有很多特殊的else用法,比如用於條件和循環。放到try語句中,其作用其實也差不多:就是當沒有檢測到異常的時候,則執行else語句。舉個例子大家可能更明白些:
復制代碼 代碼如下:

>>> import syslog
>>> try:
... f = open("/root/test.py")
... except IOError,e:
... syslog.syslog(syslog.LOG_ERR,"%s"%e)
... else:
... syslog.syslog(syslog.LOG_INFO,"no exception caught\n")
...
>>> f.close()

2.3 finally子句
finally子句是無論是否檢測到異常,都會執行的一段代碼。我們可以丟掉except子句和else子句,單獨使用try...finally,也可以配合except等使用。
例如2.2的例子,如果出現其他異常,無法捕獲,程序異常退出,那麼文件 f 就沒有被正常關閉。這不是我們所希望看到的結果,但是如果我們把f.close語句放到finally語句中,無論是否有異常,都會正常關閉這個文件,豈不是很 妙
復制代碼 代碼如下:

>>> import syslog
>>> try:
... f = open("/root/test.py")
... except IOError,e:
... syslog.syslog(syslog.LOG_ERR,"%s"%e)
... else:
... syslog.syslog(syslog.LOG_INFO,"no exception caught\n")
... finally:
>>> f.close()

大家看到了沒,我們上面那個例子竟然用到了try,except,else,finally這四個子句!:-),是不是很有趣?到現在,你就基本上已經學會了如何在Python中捕獲常規異常並處理之。
3.兩個特殊的處理異常的簡便方法
3.1斷言(assert)
什麼是斷言,先看語法:
復制代碼 代碼如下:

assert expression[,reason]

其中assert是斷言的關鍵字。執行該語句的時候,先判斷表達式expression,如果表達式為真,則什麼都不做;如果表達式不為真,則拋出異常。reason跟我們之前談到的異常類的實例一樣。不懂?沒關系,舉例子!最實在!
復制代碼 代碼如下:

>>> assert len('love') == len('like')
>>> assert 1==1
>>> assert 1==2,"1 is not equal 2!"
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
AssertionError: 1 is not equal 2!

我們可以看到,如果assert後面的表達式為真,則什麼都不做,如果不為真,就會拋出AssertionErro異常,而且我們傳進去的字元串會作為異常類的實例的具體信息存在。其實,assert異常也可以被try塊捕獲:
復制代碼 代碼如下:

>>> try:
... assert 1 == 2 , "1 is not equal 2!"
... except AssertionError,reason:
... print "%s:%s"%(reason.__class__.__name__,reason)
...
AssertionError:1 is not equal 2!
>>> type(reason)
<type 'exceptions.AssertionError'>

3.2.上下文管理(with語句)
如果你使用try,except,finally代碼僅僅是為了保證共享資源(如文件,數據)的唯一分配,並在任務結束後釋放它,那麼你就有福了!這個with語句可以讓你從try,except,finally中解放出來!語法如下:
復制代碼 代碼如下:

with context_expr [as var]:
with_suite

是不是不明白?很正常,舉個例子來!
復制代碼 代碼如下:

>>> with open('/root/test.py') as f:
... for line in f:
... print line

上面這幾行代碼幹了什麼?
(1)打開文件/root/test.py
(2)將文件對象賦值給 f
(3)將文件所有行輸出
(4)無論代碼中是否出現異常,Python都會為我們關閉這個文件,我們不需要關心這些細節。
這下,是不是明白了,使用with語句來使用這些共享資源,我們不用擔心會因為某種原因而沒有釋放他。但並不是所有的對象都可以使用with語句,只有支持上下文管理協議(context management protocol)的對象才可以,那哪些對象支持該協議呢?如下表:
file
decimal.Context
thread.LockType
threading.Lock
threading.RLock
threading.Condition
threading.Semaphore
threading.BoundedSemaphore
至於什麼是上下文管理協議,如果你不只關心怎麼用with,以及哪些對象可以使用with,那麼我們就不比太關心這個問題:)
4.拋出異常(raise)
如果我們想要在自己編寫的程序中主動拋出異常,該怎麼辦呢?raise語句可以幫助我們達到目的。其基本語法如下:
復制代碼 代碼如下:

raise [SomeException [, args [,traceback]]

第一個參數,SomeException必須是一個異常類,或異常類的實例
第二個參數是傳遞給SomeException的參數,必須是一個元組。這個參數用來傳遞關於這個異常的有用信息。
第三個參數traceback很少用,主要是用來提供一個跟中記錄對象(traceback)
下面我們就來舉幾個例子。
復制代碼 代碼如下:

>>> raise NameError
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
NameError
>>> raise NameError() #異常類的實例
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
NameError
>>> raise NameError,("There is a name error","in test.py")
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
>>> raise NameError("There is a name error","in test.py") #注意跟上面一個例子的區別
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
NameError: ('There is a name error', 'in test.py')
>>> raise NameError,NameError("There is a name error","in test.py") #注意跟上面一個例子的區別
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
NameError: ('There is a name error', 'in test.py')

其實,我們最常用的還是,只傳入第一個參數用來指出異常類型,最多再傳入一個元組,用來給出說明信息。如上面第三個例子。
5.異常和sys模塊
另一種獲取異常信息的途徑是通過sys模塊中的exc_info()函數。該函數回返回一個三元組:(異常類,異常類的實例,跟中記錄對象)
復制代碼 代碼如下:

>>> try:
... 1/0
... except:
... import sys
... tuple = sys.exc_info()
...
>>> print tuple
(<type 'exceptions.ZeroDivisionError'>, ZeroDivisionError('integer division or molo by zero',), <traceback object at 0x7f538a318b48>)
>>> for i in tuple:
... print i
...
<type 'exceptions.ZeroDivisionError'> #異常類
integer division or molo by zero #異常類的實例
<traceback object at 0x7f538a318b48> #跟蹤記錄對象

熱點內容
資料庫表的外鍵 發布:2023-01-30 21:41:30 瀏覽:588
華為9選哪個配置 發布:2023-01-30 21:40:43 瀏覽:941
雲伺服器gpu 發布:2023-01-30 21:33:26 瀏覽:544
發票忘記密碼如何列印 發布:2023-01-30 21:30:25 瀏覽:580
手機照片怎樣壓縮打包 發布:2023-01-30 21:30:12 瀏覽:276
軟體怎麼壓縮 發布:2023-01-30 21:29:19 瀏覽:570
如何將安卓手機屏幕投送到電腦上 發布:2023-01-30 21:28:10 瀏覽:520
c多線程編譯 發布:2023-01-30 21:27:50 瀏覽:393
怎麼破解郵箱126密碼 發布:2023-01-30 21:27:09 瀏覽:263
怎麼樣進入我的世界2b2t伺服器 發布:2023-01-30 21:26:59 瀏覽:581