雙層裝飾器
#!/usr/bin/env python
#-*- coding:utf-8 -*-
USER_INFO = {}
USER_INFO['is_login'] = False
USER_INFO['user_type'] = 2
def check_login(func):
def inner(*args, **kwargs):
if USER_INFO.get('is_login',None):
ret = func(*args, **kwargs)
return ret
else:
print('請登錄')
return inner
def check_admin(func):
def inner(*args, **kwargs):
if USER_INFO.get('user_type',None) == 2:
ret = func(*args, **kwargs)
return ret
else:
print('無權限查看')
return inner
@check_login
@check_admin
def index():
print('index')
index()字符串格式化
Python的字符串格式化有兩種方式: 百分號方式、format方式
百分號的方式相對來說比較老，而format方式則是比較先進的方式，目前兩者並存。
1、百分號方式
%[(name)][flags][width].[precision]typecode
(name) 可選，用於選擇指定的key
flags 可選，可供選擇的值有:
+ 右對齊；正數前加正好，負數前加負號；
- 左對齊；正數前無符號，負數前加負號；
空格 右對齊；正數前加空格，負數前加負號；
0 右對齊；正數前無符號，負數前加負號；用0填充空白處
width 可選，佔有寬度
.precision 可選，小數點後保留的位數
typecode 必選
s，獲取傳入對象的__str__方法的返回值，並將其格式化到指定位置
r，獲取傳入對象的__repr__方法的返回值，並將其格式化到指定位置
c，整數：將數字轉換成其unicode對應的值，10進制範圍爲 0 <= i <= 1114111（py27則只支持0-255）；字符：將字符添加到指定位置
o，將整數轉換成 八 進製表示，並將其格式化到指定位置
x，將整數轉換成十六進制表示，並將其格式化到指定位置
d，將整數、浮點數轉換成 十 進製表示，並將其格式化到指定位置
e，將整數、浮點數轉換成科學計數法，並將其格式化到指定位置（小寫e）
E，將整數、浮點數轉換成科學計數法，並將其格式化到指定位置（大寫E）
f， 將整數、浮點數轉換成浮點數表示，並將其格式化到指定位置（默認保留小數點後6位）
F，同上
g，自動調整將整數、浮點數轉換成 浮點型或科學計數法表示（超過6位數用科學計數法），並將其格式化到指定位置（如果是科學計數則是e；）
G，自動調整將整數、浮點數轉換成 浮點型或科學計數法表示（超過6位數用科學計數法），並將其格式化到指定位置（如果是科學計數則是E；）
%，當字符串中存在格式化標誌時，需要用 %%表示一個百分號
注：Python中百分號格式化是不存在自動將整數轉換成二進制表示的方式
常用格式化：
tpl = "i am %s" % "wangxin"
tpl = "i am %s age %d" % ("wangxin", 18)
tpl = "i am %(name)s age %(age)d" % {"name": "wangxin", "age": 18}
tpl = "percent %.2f" % 99.97623
tpl = "i am %(pp).2f" % {"pp": 123.425556, }
tpl = "i am %.2f %%" % {"pp": 123.425556, }2、Format方式
[[fill]align][sign][#][0][width][,][.precision][type]
fill 【可選】空白處填充的字符
align 【可選】對齊方式（需配合width使用）
<，內容左對齊
>，內容右對齊(默認)
＝，內容右對齊，將符號放置在填充字符的左側，且只對數字類型有效。 即使：符號+填充物+數字
^，內容居中
sign 【可選】有無符號數字
+，正號加正，負號加負；
-，正號不變，負號加負；
空格 ，正號空格，負號加負；
# 【可選】對於二進制、八進制、十六進制，如果加上#，會顯示 0b/0o/0x，否則不顯示
， 【可選】爲數字添加分隔符，如：1,000,000
width 【可選】格式化位所佔寬度
.precision 【可選】小數位保留精度
type 【可選】格式化類型
傳入” 字符串類型 “的參數
s，格式化字符串類型數據
空白，未指定類型，則默認是None，同s
傳入“ 整數類型 ”的參數
b，將10進制整數自動轉換成2進製表示然後格式化
c，將10進制整數自動轉換爲其對應的unicode字符
d，十進制整數
o，將10進制整數自動轉換成8進製表示然後格式化；
x，將10進制整數自動轉換成16進製表示然後格式化（小寫x）
X，將10進制整數自動轉換成16進製表示然後格式化（大寫X）
傳入“ 浮點型或小數類型 ”的參數
e， 轉換爲科學計數法（小寫e）表示，然後格式化；
E， 轉換爲科學計數法（大寫E）表示，然後格式化;
f ， 轉換爲浮點型（默認小數點後保留6位）表示，然後格式化；
F， 轉換爲浮點型（默認小數點後保留6位）表示，然後格式化；
g， 自動在e和f中切換
G， 自動在E和F中切換
%，顯示百分比（默認顯示小數點後6位）
常用格式化：
tpl = "i am {}, age {}, {}".format("seven", 18, 'alex')
tpl = "i am {}, age {}, {}".format(*["seven", 18, 'alex'])
tpl = "i am {0}, age {1}, really {0}".format("seven", 18)
tpl = "i am {0}, age {1}, really {0}".format(*["seven", 18])
tpl = "i am {name}, age {age}, really {name}".format(name="seven", age=18)
tpl = "i am {name}, age {age}, really {name}".format(**{"name": "seven", "age": 18})
tpl = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33])
tpl = "i am {:s}, age {:d}, money {:f}".format("seven", 18, 88888.1)
tpl = "i am {:s}, age {:d}".format(*["seven", 18])
tpl = "i am {name:s}, age {age:d}".format(name="seven", age=18)
tpl = "i am {name:s}, age {age:d}".format(**{"name": "seven", "age": 18})
tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
tpl = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15)
tpl = "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15)迭代器和生成器
1、迭代器
迭代器是訪問集合元素的一種方式。迭代器對象從集合的第一個元素開始訪問，直到所有的元素被訪問完結束。迭代器只能往前不會後退，不過這也沒什麼，因爲人們很少在迭代途中往後退。另外，迭代器的一大優點是不要求事先準備好整個迭代過程中所有的元素。迭代器僅僅在迭代到某個元素時才計算該元素，而在這之前或之後，元素可以不存在或者被銷燬。這個特點使得它特別適合用於遍歷一些巨大的或是無限的集合，比如幾個G的文件
特點：
1 訪問者不需要關心迭代器內部的結構，僅需通過next()方法不斷去取下一個內容
2 不能隨機訪問集合中的某個值 ，只能從頭到尾依次訪問
3 訪問到一半時不能往回退
4 便於循環比較大的數據集合，節省內存
>>> a = iter([1,2,3,4,5]) >>> a <list_iterator object at 0x101402630> >>> a.__next__() 1 >>> a.__next__() 2 >>> a.__next__() 3 >>> a.__next__() 4 >>> a.__next__() 5 >>> a.__next__() Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration
def myrange(arg): start = 0 while True: if start > arg: return yield start start += 1 ret = myrange(2) # r = ret.__next__() # print(r) # r = ret.__next__() # print(r) # r = ret.__next__() for item in ret: print(item)
2、生成器
一個函數調用時返回一個迭代器，那這個函數就叫做生成器（generator）；如果函數中包含yield語法，那這個函數就會變成生成器；
def func(): yield 1 yield 2 yield 3 yield 4
上述代碼中：func是函數稱爲生成器，當執行此函數func()時會得到一個迭代器。
>>> temp = func() >>> temp.__next__() 1 >>> temp.__next__() 2 >>> temp.__next__() 3 >>> temp.__next__() 4 >>> temp.__next__() Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration
模塊
模塊，用一砣代碼實現了某個功能的代碼集合。
類似於函數式編程和麪向過程編程，函數式編程則完成一個功能，其他代碼用來調用即可，提供了代碼的重用性和代碼間的耦合。而對於一個複雜的功能來，可能需要多個函數才能完成（函數又可以在不同的.py文件中），n個 .py 文件組成的代碼集合就稱爲模塊。
如：os 是系統相關的模塊；file是文件操作相關的模塊
模塊分爲三種：
自定義模塊
第三方模塊
內置模塊
導入模塊
如果想要使用模塊，則需要導入。導入模塊有一下幾種方法：
import module
from module.xx.xx import xx
from module.xx.xx import xx as rename
from module.xx.xx import *
導入模塊其實就是告訴Python解釋器去解釋那個py文件
導入一個py文件，解釋器解釋該py文件
導入一個包，解釋器解釋該包下的 __init__.py 文件
導入模塊時根據的路徑，即：sys.path
import sys
print sys.path
結果：
['C:\\Users\\kingroll\\PycharmProjects\\s13\\day5', 'C:\\Users\\kingroll\\PycharmProjects\\s13', 'C:\\Python36\\python36.zip', 'C:\\Python36\\DLLs', 'C:\\Python36\\lib', 'C:\\Python36', 'C:\\Python36\\lib\\site-packages']
如果sys.path路徑列表沒有你想要的路徑，可以通過 sys.path.append('路徑') 添加。
import sys import os project_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) sys.path.append(project_path)
第三方模塊
安裝requests模塊
pip3安裝
pip3 install requests
源碼安裝
進入解壓目錄
python3 setup.py install
內置模塊
內置模塊是Python自帶的功能，在使用內置模塊相應的功能時，需要【先導入】再【使用】
一、sys
用於提供對Python解釋器相關的操作：
sys.argv 命令行參數List，第一個元素是程序本身路徑
sys.exit(n) 退出程序，正常退出時exit(0)
sys.version 獲取Python解釋程序的版本信息
sys.maxint 最大的Int值
sys.path 返回模塊的搜索路徑，初始化時使用PYTHONPATH環境變量的值
sys.platform 返回操作系統平臺名稱
sys.stdin 輸入相關
sys.stdout 輸出相關
sys.stderror 錯誤相關
進度百分比
import sys import time def view_bar(num, total): rate = float(num) / float(total) rate_num = int(rate * 100) r = '\r%d%%' % (rate_num, ) sys.stdout.write(r) sys.stdout.flush() if __name__ == '__main__': for i in range(0, 100): time.sleep(0.1) view_bar(i, 100)
二、os
用於提供系統級別的操作：
os.getcwd() 獲取當前工作目錄，即當前python腳本工作的目錄路徑
os.chdir("dirname") 改變當前腳本工作目錄；相當於shell下cd
os.curdir 返回當前目錄: ('.')
os.pardir 獲取當前目錄的父目錄字符串名：('..')
os.makedirs('dir1/dir2') 可生成多層遞歸目錄
os.removedirs('dirname1') 若目錄爲空，則刪除，並遞歸到上一級目錄，如若也爲空，則刪除，依此類推
os.mkdir('dirname') 生成單級目錄；相當於shell中mkdir dirname
os.rmdir('dirname') 刪除單級空目錄，若目錄不爲空則無法刪除，報錯；相當於shell中rmdir dirname
os.listdir('dirname') 列出指定目錄下的所有文件和子目錄，包括隱藏文件，並以列表方式打印
os.remove() 刪除一個文件
os.rename("oldname","new") 重命名文件/目錄
os.stat('path/filename') 獲取文件/目錄信息
os.sep 操作系統特定的路徑分隔符，win下爲"\\",Linux下爲"/"
os.linesep 當前平臺使用的行終止符，win下爲"\t\n",Linux下爲"\n"
os.pathsep 用於分割文件路徑的字符串
os.name 字符串指示當前使用平臺。win->'nt'; Linux->'posix'
os.system("bash command") 運行shell命令，直接顯示
os.environ 獲取系統環境變量
os.path.abspath(path) 返回path規範化的絕對路徑
os.path.split(path) 將path分割成目錄和文件名二元組返回
os.path.dirname(path) 返回path的目錄。其實就是os.path.split(path)的第一個元素
os.path.basename(path) 返回path最後的文件名。如何path以／或\結尾，那麼就會返回空值。即os.path.split(path)的第二個元素
os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path) 如果path是絕對路徑，返回True
os.path.isfile(path) 如果path是一個存在的文件，返回True。否則返回False
os.path.isdir(path) 如果path是一個存在的目錄，則返回True。否則返回False
os.path.join(path1[, path2[, ...]]) 將多個路徑組合後返回，第一個絕對路徑之前的參數將被忽略
os.path.getatime(path) 返回path所指向的文件或者目錄的最後存取時間
os.path.getmtime(path) 返回path所指向的文件或者目錄的最後修改時間
三、序列化
Python中用於序列化的兩個模塊
json 用於【字符串】和 【python基本數據類型】 間進行轉換
pickle 用於【python特有的類型】 和 【python基本數據類型】間進行轉換
Json模塊提供了四個功能：dumps、dump、loads、load
pickle模塊提供了四個功能：dumps、dump、loads、load
import json
dic = {'k1':'v1'}
print(dic,type(dic))
#將python基本數據類型轉化成字符串形式
result = json.dumps(dic)
print(result,type(result))
s1 = '{"k1":123}'
#將python字符串形式轉化成基本數據類型
dic1 = json.loads(s1)
print(dic1,type(dic1))
import json r = json.dumps([11,22,33]) li = '["wangxin","yuehan"]' #li = "['wangxin','yuehan']" ret = json.loads(li) #反序列化時，一定要使用"" 跨語言之間的統一 print(ret,type(ret))
import json
li = [11,22,33]
#先進行序列化，然後寫進文件
json.dump(li,open('db','w'))
#先讀文件，再轉化,
li =json.load(open('db','r'))
print(type(li),li)pickle只能python用.用法與json大致相同
json只能處理基本數據類型，pickle支持任何類型
json更加適合跨語言，字符串，基本數據類型;pickle，python複雜類型的序列化操作
import pickle
li = [11,22,33]
r = pickle.dumps(li)
print(r)
result = pickle.loads(r)
print(result)
li = [11,22,33]
pickle.dump(li,open('db1','wb'))
result = pickle.load(open('db1','rb'))
print(result,type(result))四、time
時間相關的操作，時間有三種表示方式：
時間戳 1970年1月1日之後的秒，即：time.time()
格式化的字符串 2014-11-11 11:11， 即：time.strftime('%Y-%m-%d')
結構化時間 元組包含了：年、日、星期等... time.struct_time 即：time.localtime()
import time
# print(time.asctime()) #返回時間格式"Fri Aug 19 11:14:16 2016",
# print(time.localtime()) #返回本地時間 的struct time對象格式
# print(time.gmtime(time.time()-800000)) #返回utc時間的struc時間對象格式
# print(time.asctime(time.localtime())) #返回時間格式"Fri Aug 19 11:14:16 2016",
#print(time.ctime()) #返回Fri Aug 19 12:38:29 2016 格式, 同上
# 日期字符串 轉成 時間戳
# string_2_struct = time.strptime("2016/05/22","%Y/%m/%d") #將 日期字符串 轉成 struct時間對象格式
# print(string_2_struct)
# #
# struct_2_stamp = time.mktime(string_2_struct) #將struct時間對象轉成時間戳
# print(struct_2_stamp)
#將時間戳轉爲字符串格式
# print(time.gmtime(time.time()-86640)) #將utc時間戳轉換成struct_time格式
# print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()) ) #將utc struct_time格式轉成指定的字符串格式
#時間加減
import datetime
'''
datetime.date：表示日期的類。常用的屬性有year, month, day
datetime.time：表示時間的類。常用的屬性有hour, minute, second, microsecond
datetime.datetime：表示日期時間
datetime.timedelta：表示時間間隔，即兩個時間點之間的長度
timedelta([days[, seconds[, microseconds[, milliseconds[, minutes[, hours[, weeks]]]]]]])
strftime("%Y-%m-%d")
'''
# print(datetime.datetime.now()) #返回 2016-08-19 12:47:03.941925
#print(datetime.date.fromtimestamp(time.time()) ) # 時間戳直接轉成日期格式 2016-08-19
# print(datetime.datetime.now() )
# print(datetime.datetime.now() + datetime.timedelta(3)) #當前時間+3天
# print(datetime.datetime.now() + datetime.timedelta(-3)) #當前時間-3天
# print(datetime.datetime.now() + datetime.timedelta(hours=3)) #當前時間+3小時
# print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #當前時間+30分
# c_time = datetime.datetime.now()
# print(c_time.replace(minute=3,hour=2)) #時間替換%Y Year with century as a decimal number. %m Month as a decimal number [01,12]. %d Day of the month as a decimal number [01,31]. %H Hour (24-hour clock) as a decimal number [00,23]. %M Minute as a decimal number [00,59]. %S Second as a decimal number [00,61]. %z Time zone offset from UTC. %a Locale's abbreviated weekday name. %A Locale's full weekday name. %b Locale's abbreviated month name. %B Locale's full month name. %c Locale's appropriate date and time representation. %I Hour (12-hour clock) as a decimal number [01,12]. %p Locale's equivalent of either AM or PM. 格式化佔位符
五、logging模塊
最簡單的用法
import logging
logging.warning("user [wangxin] attempted wrong password more than 3 times")
logging.critical("server is down")
#輸出
WARNING:root:user [wangxin] attempted wrong password more than 3 times
CRITICAL:root:server is down日誌等級：
Level When it’s used
DEBUG Detailed information, typically of interest only when diagnosing problems.
INFO Confirmation that things are working as expected.
WARNING An indication that something unexpected happened, or indicative of some problem in the near future (e.g. ‘disk space low’). The software is still working as expected.
ERROR Due to a more serious problem, the software has not been able to perform some function.
CRITICAL A serious error, indicating that the program itself may be unable to continue running.
把日誌寫到文件裏
import logging
logging.basicConfig(filename='example.log',level=logging.INFO)
logging.debug('This message should go to the log file')
logging.info('So should this')
logging.warning('And this, too')其中下面這句中的level=logging.INFO意思是，把日誌紀錄級別設置爲INFO，也就是說，只有比日誌是INFO或比INFO級別更高的日誌纔會被紀錄到文件裏，在這個例子， 第一條日誌是不會被紀錄的，如果希望紀錄debug的日誌，那把日誌級別改成DEBUG就行了。
logging.basicConfig(filename='example.log',level=logging.INFO)
上面的日誌格式忘記加上時間，日誌不知道時間怎麼行呢，加上時間
import logging
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p')
logging.warning('is when this event was logged.')
#輸出
12/12/2010 11:46:36 AM is when this event was logged.注：只有【當前寫等級】大於【日誌等級】時，日誌文件才被記錄。
日誌記錄格式：
%(name)s | Logger的名字 |
%(levelno)s | 數字形式的日誌級別 |
%(levelname)s | 文本形式的日誌級別 |
%(pathname)s | 調用日誌輸出函數的模塊的完整路徑名，可能沒有 |
%(filename)s | 調用日誌輸出函數的模塊的文件名 |
%(module)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 | 用戶輸出的消息 |
如果想同時把log打印在屏幕和文件日誌裏，就需要了解一點複雜的知識 了
Python 使用logging模塊記錄日誌涉及四個主要類，使用官方文檔中的概括最爲合適：
logger提供了應用程序可以直接使用的接口；
handler將(logger創建的)日誌記錄發送到合適的目的輸出；
filter提供了細度設備來決定輸出哪條日誌記錄；
formatter決定日誌記錄的最終輸出格式。
logger
每個程序在輸出信息之前都要獲得一個Logger。Logger通常對應了程序的模塊名，比如聊天工具的圖形界面模塊可以這樣獲得它的Logger：
LOG=logging.getLogger(”chat.gui”)
而核心模塊可以這樣：
LOG=logging.getLogger(”chat.kernel”)
Logger.setLevel(lel):指定最低的日誌級別，低於lel的級別將被忽略。debug是最低的內置級別，critical爲最高
Logger.addFilter(filt)、Logger.removeFilter(filt):添加或刪除指定的filter
Logger.addHandler(hdlr)、Logger.removeHandler(hdlr)：增加或刪除指定的handler
Logger.debug()、Logger.info()、Logger.warning()、Logger.error()、Logger.critical()：可以設置的日誌級別
handler
handler對象負責發送相關的信息到指定目的地。Python的日誌系統有多種Handler可以使用。有些Handler可以把信息輸出到控制檯，有些Logger可以把信息輸出到文件，還有些
Handler可以把信息發送到網絡上。如果覺得不夠用，還可以編寫自己的Handler。可以通過addHandler()方法添加多個多handler
Handler.setLevel(lel):指定被處理的信息級別，低於lel級別的信息將被忽略
Handler.setFormatter()：給這個handler選擇一個格式
Handler.addFilter(filt)、Handler.removeFilter(filt)：新增或刪除一個filter對象
每個Logger可以附加多個Handler。接下來我們就來介紹一些常用的Handler：
1) logging.StreamHandler
使用這個Handler可以向類似與sys.stdout或者sys.stderr的任何文件對象(file object)輸出信息。它的構造函數是：
StreamHandler([strm])
其中strm參數是一個文件對象。默認是sys.stderr
2) logging.FileHandler
和StreamHandler類似，用於向一個文件輸出日誌信息。不過FileHandler會幫你打開這個文件。它的構造函數是：
FileHandler(filename[,mode])
filename是文件名，必須指定一個文件名。
mode是文件的打開方式。參見Python內置函數open()的用法。默認是’a'，即添加到文件末尾。
3) logging.handlers.RotatingFileHandler
這個Handler類似於上面的FileHandler，但是它可以管理文件大小。當文件達到一定大小之後，它會自動將當前日誌文件改名，然後創建
一個新的同名日誌文件繼續輸出。比如日誌文件是chat.log。當chat.log達到指定的大小之後，RotatingFileHandler自動把
文件改名爲chat.log.1。不過，如果chat.log.1已經存在，會先把chat.log.1重命名爲chat.log.2。。。最後重新創建
chat.log，繼續輸出日誌信息。它的構造函數是：
RotatingFileHandler( filename[, mode[, maxBytes[, backupCount]]])
其中filename和mode兩個參數和FileHandler一樣。
maxBytes用於指定日誌文件的最大文件大小。如果maxBytes爲0，意味着日誌文件可以無限大，這時上面描述的重命名過程就不會發生。
backupCount用於指定保留的備份文件的個數。比如，如果指定爲2，當上面描述的重命名過程發生時，原有的chat.log.2並不會被更名，而是被刪除。
4) logging.handlers.TimedRotatingFileHandler
這個Handler和RotatingFileHandler類似，不過，它沒有通過判斷文件大小來決定何時重新創建日誌文件，而是間隔一定時間就
自動創建新的日誌文件。重命名的過程與RotatingFileHandler類似，不過新的文件不是附加數字，而是當前時間。它的構造函數是：
TimedRotatingFileHandler( filename [,when [,interval [,backupCount]]])
其中filename參數和backupCount參數和RotatingFileHandler具有相同的意義。
interval是時間間隔。
when參數是一個字符串。表示時間間隔的單位，不區分大小寫。它有以下取值：
S 秒
M 分
H 小時
D 天
W 每星期（interval==0時代表星期一）
midnight 每天凌晨
import logging
#create logger
logger = logging.getLogger('TEST-LOG')
logger.setLevel(logging.DEBUG)
# create console handler and set level to debug
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
# create file handler and set level to warning
fh = logging.FileHandler("access.log")
fh.setLevel(logging.WARNING)
# create formatter
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# add formatter to ch and fh
ch.setFormatter(formatter)
fh.setFormatter(formatter)
# add ch and fh to logger
logger.addHandler(ch)
logger.addHandler(fh)
# 'application' code
logger.debug('debug message')
logger.info('info message')
logger.warn('warn message')
logger.error('error message')
logger.critical('critical message')文件自動截斷
import logging
from logging import handlers
logger = logging.getLogger(__name__)
log_file = "timelog.log"
#fh = handlers.RotatingFileHandler(filename=log_file,maxBytes=10,backupCount=3)
fh = handlers.TimedRotatingFileHandler(filename=log_file,when="S",interval=5,backupCount=3)
formatter = logging.Formatter('%(asctime)s %(module)s:%(lineno)d %(message)s')
fh.setFormatter(formatter)
logger.addHandler(fh)
logger.warning("test1")
logger.warning("test12")
logger.warning("test13")
logger.warning("test14")