大纲:
1、双层装饰器
单层装饰器
双层装饰器
原理
2、字符串的格式化
3、format字符串格式化
4、生成器
5、递归
6、模块的安装
7、json模块
8、pickle模块
9、time模块
10、datetime模块
11、logging模块
双层装饰器
还是老样,没有改变:
USER_INFO = {} def check_login(func): def inner(*args, **kwargs): if USER_INFO.get("is_login", None): # 用get方法拿字典里面的内容,如果字典里面没有我们要拿的参数,不会报错,给他默认返回的为None ret = func(*args, **kwargs) return ret else: print("请登录") return inner def check_admin(func): # 判断是否为管理员用户 def inner(*args, **kwargs): if USER_INFO.get("is_login", None): if USER_INFO.get("user_type", None) == 2: # 如果用户类型等于2,表示为管理员用户 ret = func(*args, **kwargs) return ret else: print("无权限查看") # 否者无权限查看 else: print("请登录") return inner @check_admin def index(): # 超级管理员可以查看 print("index") @check_login def home(): # 登录可以查看 """ 普通用户的功能 :return: """ print("home") def login(): # 登录 user = input("请输入用户名:") if user == "admin": USER_INFO["is_login"] = True USER_INFO["user_type"] = 2 else: # 否者如果不为admin,表示登录的用户为普通用户 USER_INFO["is_login"] = True USER_INFO["is_login"] = 1 def main(): while True: inp = input("1、登录;2、查看信息;3超级管理员\n>>>") if inp == "1": login() elif inp == "2": home() elif inp == "3": index() main()
输出:
1、登录;2、查看信息;3超级管理员 >>>2 请登录 1、登录;2、查看信息;3超级管理员 >>>3 请登录 1、登录;2、查看信息;3超级管理员 >>>1 请输入用户名:user 1、登录;2、查看信息;3超级管理员 >>>2 home 1、登录;2、查看信息;3超级管理员 >>>3 无权限查看 1、登录;2、查看信息;3超级管理员 >>>1 请输入用户名:admin 1、登录;2、查看信息;3超级管理员 >>>2 home 1、登录;2、查看信息;3超级管理员 >>>3 index 1、登录;2、查看信息;3超级管理员 >>>
新变化:
# 从版本以一中我们可以看到很多我们的check_admin里面重复了check_login的代码(check_admin又判断登录,又判断权限), # 如果我们又加上了超级管理员,那我们就会又写一个重复的装饰器, # 所以我们需要用到双层装饰器,先用check_login,判断是否登录,然后用check_admin判断是否为管理员 USER_INFO = {} def check_login(func): def inner(*args, **kwargs): if USER_INFO.get("is_login", None): # 用get方法拿字典里面的内容,如果字典里面没有我们要拿的参数,不会报错,给他默认返回的为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: # 如果用户类型等于2,表示为管理员用户 ret = func(*args, **kwargs) return ret else: print("无权限查看") # 否者无权限查看 return inner # 为什么check_login写上面,我们从下向上看,从index()开始, # 可以看到先用admin装饰后,比如变成了nindex这个函数,然后再用login装饰进行装饰,比如又变成了nnindex,然后python是从上向下执行, # 所以python会执行nnindex,判断是否登录,然后在执行nindex,判断是否为管理员,如果没有登录, # 提示登录,如果已经登录(不为管理员),提示无权限 @check_login @check_admin def index(): # 管理员可以查看 """ 管理员的功能 :return: """ print("index") @check_login def home(): # 登录可以查看 """ 普通用户的功能 :return: """ print("home") def login(): # 登录 user = input("请输入用户名:") if user == "admin": USER_INFO["is_login"] = True USER_INFO["user_type"] = 2 else: # 否者如果不为admin,表示登录的用户为普通用户 USER_INFO["is_login"] = True USER_INFO["is_login"] = 1 def main(): while True: inp = input("1、登录;2、查看信息;3超级管理员\n>>>") if inp == "1": login() elif inp == "2": home() elif inp == "3": index() main()
输出:
1、登录;2、查看信息;3超级管理员 >>>2 请登录 1、登录;2、查看信息;3超级管理员 >>>3 请登录 1、登录;2、查看信息;3超级管理员 >>>1 请输入用户名:user 1、登录;2、查看信息;3超级管理员 >>>2 home 1、登录;2、查看信息;3超级管理员 >>>3 无权限查看 1、登录;2、查看信息;3超级管理员 >>>1 请输入用户名:admin 1、登录;2、查看信息;3超级管理员 >>>2 home 1、登录;2、查看信息;3超级管理员 >>>3 index 1、登录;2、查看信息;3超级管理员 >>>
输出效果完全一样,注意看v2的注释
装饰器的原理(多层原理也一样):
字符串的格式化:
%[(name)] [flags] [width].[precision] typecode
# 字符串格式化 # %[(name)] [flags] [width].[precision] typecode # 常规的格式化 string = "博客网址:www.cnblogs.com/%s,园龄:%d个月" % ("smelond", 1) print(string) # %[(name)]可选,用于指定的key: string = "博客网址:www.cnblogs.com/%(name)s,园龄:%(age)d个月" % {"name": "smelond", "age": 1} # 用字典方式 print(string) # flags 可选,可供选择的值有(听说没卵用) # + 右对齐:正数前加正号,负数前加负号 # - 左对齐:正数前无符号,负数前加负号 # 空格 右对齐:正数前加空格,负数前加负号 # 0 右对齐:正数前无符号,负数前加负号;用0填充空白处 string = "博客网址:www.cnblogs.com/%(name)+20s,园龄:%(age)-10d个月" % {"name": "smelond", "age": 1} # 占有20个空格,smelond在其中,向右对齐 print(string) # width 可选,占有宽度 # .precision 可选,小数点后保留的位数 string = "数值:%(p).2f" % {"p": 1.23656} # 在后面加上.然后数字,代表保留几位,有四舍五入功能 print(string) # typecode 必选 # s,获取传入对象的__str__方法的返回值,并将其格式化到指定位置 # r,获取传入对象的__repr__方法的返回值,并将其格式化到指定位置(面向对象内容) # c,整数:将数字转换成其unicode对应的值,10进制范围为 0 <= i <= 1114111(py27则只支持0-255);字符:将字符添加到指定位置 # o,将整数转换成 八 进制表示,并将其格式化到指定位置 # x,将整数转换成十六进制表示,并将其格式化到指定位置 string = "%c___%o___%x" % (65, 15, 15) # 将十进制转换为其他进制(A,17,f) print(string) # d,将整数、浮点数转换成 十 进制表示,并将其格式化到指定位置 # e,将整数、浮点数转换成科学计数法,并将其格式化到指定位置(小写e) # E,将整数、浮点数转换成科学计数法,并将其格式化到指定位置(大写E) # f, 将整数、浮点数转换成浮点数表示,并将其格式化到指定位置(默认保留小数点后6位) # F,同上 string = "%d--------%f--------%e--------%E-------%.2ef" % (100000000, 1.23456, 10000000, 10000000, 10000000) print(string) # g,自动调整将整数、浮点数转换成 浮点型或科学计数法表示(超过6位数用科学计数法),并将其格式化到指定位置(如果是科学计数则是e;) # G,自动调整将整数、浮点数转换成 浮点型或科学计数法表示(超过6位数用科学计数法),并将其格式化到指定位置(如果是科学计数则是E;) string = "%g-------%g-------%G-------%G" % (10000000, 100, 10000000, 100) print(string) # %,当字符串中存在格式化标志时,需要用 %%表示一个百分号 string = "name:%s %% %%%%" % "smelond" # 如果需要输出一个%,但是前面已经有了一个占位符,那就需要输出%%才能代表一个%,否者会报错,需要输出%%,就需要%%%% print(string) # # 注:Python中百分号格式化是不存在自动将整数转换成二进制表示的方式
博客网址:www.cnblogs.com/smelond,园龄:1个月 博客网址:www.cnblogs.com/smelond,园龄:1个月 博客网址:www.cnblogs.com/ smelond,园龄:1 个月 数值:1.24 A___17___f 100000000--------1.234560--------1.000000e+07--------1.000000E+07-------1.00e+07f 1e+07-------100-------1E+07-------100 name:smelond % %%
format格式化:
# [[fill]align] [sign] [#] [0] [widht] [,] [.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位)
# 两个最基本的格式化 string = "asdfasgsdf__{0}__asdf__{0}__adhkg__{1}__".format(123, "smelond") print(string) # asdfasgsdf__123__asdf__123__adhkg__smelond__ string = "___{name:s}___{age:d}___{name:s}".format(name="smelond", age=16) print(string) # ___smelond___16___smelond # 一些常用的用法 # 空白处填充*,^字符居中,20个空格,s:字符串形式{:*^20s} # +有符号数值,d:十进制{:+d} # x 直接转换为16进制 # #如果后面输入的为x,那就转换为16进制后再前面加上0x{:#x} string = "_____{:*^20s}_____{:+d}_____{:x}_____{:#x}".format("smelond", 123, 15, 15) print(string) # _____******smelond*******_____+123_____f_____0xf string = "百分比:{:%}".format(1.2345) print(string) # 百分比:123.450000%
# 一些常用的用法 tpl = "i am {},age {},{}".format("seven", 16, "smelond") print(tpl) # i am seven,age 16,smelond tpl = "i am {},age {},{}".format(*["seven", 16, "smelond"]) print(tpl) # i am seven,age 16,smelond,注意,如果是列表要在前面加上* tpl = "i am {0},age {1}, really {0}".format("seven", 16) print(tpl) # i am seven,age 16, really seven tpl = "i am {0},age {1}, really {0}".format(*["seven", 16]) print(tpl) # i am seven,age 16, really seven,列表需要加上* tpl = "i am {name}, age {age}, really {name}".format(name="smelond", age=16) print(tpl) # i am smelond, age 16, really smelond tpl = "i am {name}, age {age}, really {name}".format(**{"name": "smelond", "age": 16}) print(tpl) # i am smelond, age 16, really smelond,注意,如果是字典需要加上两个* tpl = "i am {0[0]}, age {0[1]}, really {1[2]}".format([1, 2, 3], [11, 22, 33]) print(tpl) # i am 1, age 2, really 33,列表里面的列表 tpl = "i am {:s}, age {:d}".format("smelond", 16) print(tpl) # i am smelond, age 16 tpl = "i am {name:s}, age {age:d}".format(name="smelond", age=16) print(tpl) # i am smelond, age 16 tpl = "i am {name:s}, age {age:d}".format(**{"name": "smelond", "age": 16}) print(tpl) # i am smelond, age 16,字典需要加上** tpl = "numbers:{:b},{:o},{:d},{:x},{:X},{:%}".format(15, 15, 15, 15, 15, 15.87612) print(tpl) # s:1111,17,15,f,F,1500.000000% tpl = "numbers:{0:b},{0:o},{0:d},{0:x},{0:X},{0:%}".format(15) print(tpl) # s:1111,17,15,f,F,1500.000000% tpl = "numbers:{num:b},{num:o},{num:d},{num:x},{num:X},{num:%}".format(num=15) print(tpl) # s:1111,17,15,f,F,1500.000000%
生成器的使用(生成器是使用函数创建的):
# 普通函数 # def func(): # return 123 # # # ret = func() # 执行函数拿结果 # 生成器 def func(): # print("start") print(111) yield 1 print(222) yield 2 print(333) yield 3 # 如果在函数里面出现了yield,这个函数就称之为生成器 ret = func() print(ret) # for i in ret: # print(i) # 输出 # 循环第一次的时候就进入func函数里面去,进入后拿走yield后面的值,所以输出1,然后循环第二次, # 第二次进入func函数时,找到上一次结尾的位置,从结尾的位置又开始循环(往下走),所以就是输出2 # 然后第三次 r1 = ret.__next__() # 进入函数找到yield,获取yield后面的数据,然后我们就拿到了1 print(r1) r2 = ret.__next__() # 进入函数找到yield,获取yield后面的数据,然后我们就拿到了2 print(r2) r3 = ret.__next__() # 进入函数找到yield,获取yield后面的数据,然后我们就拿到了3 print(r3) # r4 = ret.__next__() # print(r4) # 从函数里面可以看到没有第4个yield,所以这句要报错 #输出: 111 1 222 2 333 3
# 基于生成器实现range功能 def myrange(arg): # 相当于这是一个生成器 start = 0 while True: if start > arg: return yield start start += 1 ret = myrange(3) # for i in ret: # print(i) r = ret.__next__() print(r) r = ret.__next__() print(r) r = ret.__next__() print(r) r = ret.__next__() print(r) # r = ret.__next__() # print(r)#第四次肯定报错,因为只循环3次,从0开始 输出: 0 1 2 3
python的递归:
自己拿着windows自带的画图工具画的,将就看吧,是有点丑
代码贴上
# 一个递给另外一个,一个简单的原理 def d(): r = "end" # 将字符串end赋给r return r # 返回一个变量r def c(): r = d() # 拿到函数d的返回值 return r def b(): r = c() # 拿到函数c的返回值 return r def a(): r = b() # 拿到函数b的返回值 print(r) # 拿到结果后输出 a() # 输出end # 递归 # 执行第一次时的效果 def func(n): # 现在n=1 n += 1 # n等于2 if n >= 4: # 当如果n>=4的时候 return "end" # 遇到return直接退出,然后返回一个字符串end return func(n) # 上面if如果没执行,肯定会执行这句,返回func函数,现在的n=2 r = func(1) # 传入实参1到func函数里去慢慢执行,然后接收返回值 print(r) #输出end
用递归实现一个1*2*3*4*5*6*7:
def func(n, x): # n=1,x=1.......n=2,x=2.......n=3,x=6 n += 1 # n=2.......n=3.......n=4 x *= n # x=x*n,x=2.......x=x*n,x=6.......x=x*n,x=24 if n >= 7: # 直到n等于7的时候,将x返回 return x return func(n, x) # n=2,x=2.......n=3,x=6....... r = func(1, 1) print(r) 输出:5040
def func(num): if num == 1: return 1 return num * func(num - 1) x = func(7) print(x) 输出:5040
事实证明,我太笨了,我那个太复杂了,而且全是运算,但是老师的感觉就轻快明了
模块的使用及安装
# 导入模块 # 单模块 import call_m # 直接调用当前目录下的call_m.py文件 import lib.commons # 调用lib目录下的commons.py文件 # 嵌套在文件夹下的模块 from lib import commons from src import commons as xxx # 如果重名,我们可以用as给他做一个别名 # call_m.login() # 输出里面的方法,就相当于调用了里面的函数 # lib.commons.logout()
安装requests模块
pip3 install requests
json模块
json只能处理基本的数据类型
import json # json只能处理基本的数据类型 dic = {"k1": "v1"} print(dic, type(dic)) # 用json模块将python的基本数据类型转换成为字符串形式 result = json.dumps(dic) print(result, type(result)) s1 = '{"k1":123}' # json将python字符串形式转换成为基本数据类型 dic = json.loads(s1) print(dic, type(dic)) # py基本数据类型转换字符串 r = json.dumps([11, 22, 33]) # li = "['smelond','amanda']" #这种方法不行,因为其他语言里面 ' 和 "跟python不一样 li = '["smelond","amanda"]' # 反序列化时,一定要使用 " print(r, type(r)) ret = json.loads(li) print(ret, type(ret)) li = [11, 22, 33] json.dump(li, open("db", "w")) # dump先把他进行序列化,然后写到文件里面 li = json.load(open("db", "r")) # 从文件里面把字符串读出来,读出来后会转换成为列表类型 print(li, type(li))
用json加requests模块调用天气的api接口
import json import requests import sys response = requests.get("http://www.sojson.com/open/api/weather/json.shtml?city=双流") response.encoding = "utf-8" dic = json.loads(response.text) print(dic)
json/pickle
json更加适合跨语言操作,因为它传递的是字符串,基本数据类型
pickle,对python的所有类型的序列化,仅适用与python
pickle模块
pickle支持任何的类型
# pickle支持任何的类型 import pickle # dumps a loads li = [11, 22, 33] r = pickle.dumps(li) # 字符方式 print(r) result = pickle.loads(r) print(result) # dump a load li = [11, 22, 33] pickle.dump(li, open("db", "wb")) ##pickle是以字符方式存取,所以要加上b resul = pickle.load(open("db", "rb")) # 读取 print(resul)
time&datetime模块
time模块
import time print(time.process_time()) # 测量处理器运算时间,不包括sleep时间,不稳定 print(time.altzone) # 返回与utc时间的时间差,以秒计算 print(time.asctime()) # 返回时间格式“Sat Dec 30 17:32:59 2017” print(time.localtime()) # 返回本地时间的struct time对象格式 tm = time.localtime() # 将返回的struct time格式的时间赋给tm print("{}-{}".format(tm.tm_year, tm.tm_mon)) # 用format输出年月 print(time.gmtime(time.time() - 8000000)) # 返回utc时间的struc时间对象格式 print(time.asctime(time.localtime())) # 返回时间格式“Sat Dec 30 17:39:47 2017” print(time.ctime()) # 返回时间格式“Sat Dec 30 17:41:44 2017”同上 # 日期字符串 转换 时间戳 string_2_struct = time.strptime("2017/12/30", "%Y/%m/%d") # 将日期字符串 转换 struct时间对象格式 print(string_2_struct) struct_2_stamp = time.mktime(string_2_struct) # 将struct时间对象转换成为时间戳 print(struct_2_stamp) print(time.ctime(struct_2_stamp)) # 返回时间为“Sat Dec 30 00:00:00 2017”格式 # 将时间戳转为字符串格式 print(time.gmtime(time.time() - 86640)) # 将utc时间戳转换struct_time格式 print(time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime())) # 将utc struct_time格式转换成指定的字符串格式 print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())) # 将本地 struct_time格式转换成指定的字符串格式
datetime模块
import datetime print(datetime.datetime.now()) # 返回“2017-12-30 17:56:40.261813” print(datetime.date.fromtimestamp(time.time())) # 时间戳直接转换成为日期格式“2017-12-30” # 时间加减 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)) # 时间替换,替换小时和分钟 print(c_time.replace(hour=2, minute=3)) # 时间替换,替换小时和分钟
logging模块
logging模式是一个日志模块,很多程序都需要一个记录日志,所以python为我们提供了这么一个模块,logging的日志分为5个等级:debug(),waring(),error(),critical()
日志等级(数字越大,表示危害越高):
critical = 50
error = 40
warning = 30
info = 20
debug = 10
注意:只有【当前写等级】大于【日志等级】时,日志文件才被记录
日志输出,最简单的用法:
import logging logging.warning("user [smelond] attempted wrong password more than 3 times") # 可以直接输出到屏幕上 logging.critical("server is down")
将日志输出到文件里面:
import logging logging.basicConfig(filename='example.log', level=logging.INFO) # 设置将输出内容保存到example.log # level=loggin.INFO意思是,把日志纪录级别设置为INFO,也就是说,只有比日志是INFO或比INFO级别更高的日志才会被纪录到文件里 logging.debug("this message should go to the log file") # 不会保存到日志文件里面 logging.info("So should this") # 日志级别也为info,所以可以保存到文件 logging.warning("And this,too") # 这个等级大于info,所以也可以保存到文件里面
将日志输出到文件里面,并且加上时间:
logging.basicConfig(filename='example.log', level=logging.INFO, format="%(asctime)s (message)s", datefmt="%m%d%Y %H:%M:%S %p") # format格式化输出,后面放时间格式 # level=loggin.INFO意思是,把日志纪录级别设置为INFO,也就是说,只有比日志是INFO或比INFO级别更高的日志才会被纪录到文件里 logging.debug("this message should go to the log file") # 不会保存到日志文件里面 logging.info("So should this") # 日志级别也为info,所以可以保存到文件 logging.warning("And this,too") # 这个等级大于info,所以也可以保存到文件里面 logging.warning("is when this event was logged.") # 大于info 输出: 01012018 20:16:36 PM So should this 01012018 20:16:36 PM And this,too 01012018 20:16:36 PM is when this event was logged.
以下来自alex li
日志输出格式:
%(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 |
用户输出的消息 |
logging模块记录日志涉及到的四个主要类:
logger提供了应用程序可以直接使用接口
handler将(logging创建)日志记录发送到合适的目的输出
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.INFO) # 设置一个最低日志输出等级,设置为了INFO等级,(全局) # create console handler and set level to debug ch = logging.StreamHandler() # 输出到屏幕上 ch.setLevel(logging.DEBUG) # 设置屏幕输出的最低日志等级但是会发现不能输出debug,因为我们上面的全局配置上最低设置成为了INFO等级,DEBIG>INFO # create file handler and set level to warning fh = logging.FileHandler("access.log") # 设置输出到文件 fh.setLevel(logging.WARNING) # 设置文件输出的最低等级 # create formatter formatter_ch = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') # 格式化 formatter_fh = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s') # 格式化 # add formatter to ch and fh ch.setFormatter(formatter_ch) # 设置输出到屏幕上的格式 fh.setFormatter(formatter_fh) # 设置输出到日志中的格式 # add ch and fh to logger logger.addHandler(ch) # 添加handler logger.addHandler(fh) # 'application' code logger.debug('debug message') # 输出提示(不能输出到任何地方) logger.info('info message') # 输出提示(只能输出到屏幕,因为输出到文件最低等级需要WARNING) logger.warning('warn message') # 输出提示(双方) logger.error('error message') # 双方 logger.critical('critical message') # 双方 屏幕输出: 2018-01-02 11:44:34,121 - TEST-LOG - INFO - info message 2018-01-02 11:44:34,121 - TEST-LOG - WARNING - warn message 2018-01-02 11:44:34,121 - TEST-LOG - ERROR - error message 2018-01-02 11:44:34,121 - TEST-LOG - CRITICAL - critical message 文件输出: 2018-01-02 11:44:34,121 - WARNING - warn message 2018-01-02 11:44:34,121 - ERROR - error message 2018-01-02 11:44:34,121 - CRITICAL - critical message