标签：
如上篇文章所讲单层装饰器指一个函数用一个装饰器来装饰，即在函数执行前或者执行后用于添加相应的操作（如判断某个条件是否满足）。
具体请见如下：
双层解释器在原理上相同，只是在执行时比单层复杂。见如下实例：
需求： 做一个简单的登录展示，有两个菜单即可一个菜单仅需要登录后就能查看，一个菜单不但需要登录，而且还得需要是超级管理员登录才能查看。
分析：1.可以写一个装饰器，在着一个装饰器中判断是否满足两个条件如果满足着执行函数体，但问题是还有一个菜单是不需要两个都判断的，所以这样写在一个装饰器的方案不容易实现，
而且还无法满足后续程序的扩展（如，某一天又需要在判断一个条件则还得在改装饰器函数，这样就违背了当初用装饰器的目的）。
解决：使用多个装饰器来判断条件，每个装饰器判断一个条件，灵活。如下代码实现：
如下代码仅为测试使用，双层解释器，模拟是否登录可以采用修改USER_INFO的is_log_in的值，True表示已经登录，同样的user_type表示是否为admin用户。
1 ####双层装饰器:############## 2 #如下定义一个字典用于存放登录状态和,用户类型。 3 USER_INFO = {"is_log_in":True,"user_type":0} 4 5 6 def check_log(func): 7 ‘‘‘ 8 装饰器一,用于判断用户是否已经登录 9 :param func: 10 :return: 11 ‘‘‘ 12 def inner(*args,**kwargs): 13 if USER_INFO.get("is_log_in"): 14 res = func(*args,**kwargs) 15 return res 16 else: 17 print("必须先登录--") 18 return inner 19 20 def check_admin(func): 21 ‘‘‘ 22 装饰器二,用于判断登录用户是否是admin 23 :param func: 24 :return: 25 ‘‘‘ 26 def inner(*args,**kwargs): 27 if int(USER_INFO.get("user_type")) == 1: 28 rest = func() 29 return rest 30 else: 31 print("必须为超级用户才能够操作--") 32 return inner 33 34 35 36 @check_log 37 def login (): 38 ‘‘‘ 39 选择1后展示的内容。 40 :return: 41 ‘‘‘ 42 print("-------普通用户界面————————") 43 44 @check_log 45 @check_admin 46 def index(): 47 ‘‘‘ 48 选择2后展示的内容 49 :return: 50 ‘‘‘ 51 print("超级管理员页面") 52 53 54 def main(): 55 ‘‘‘ 56 主函数用于展示和获取用户输入。 57 :return: 58 ‘‘‘ 59 while True: 60 print("1.普通用户界面 2.超级管理员界面") 61 userchoice = int(input(">>> ")) 62 if userchoice == 1: 63 login() 64 65 if userchoice == 2: 66 index() 67 68 main()
双层修饰器的执行过程如下：
1.当两个装饰器同时引用时，执行第一个装饰器的时候，这时候传递给第一个装饰器的参数就是第二个装饰器连同下面的原函数。
2，而再执行到第二个装饰器的时候，这个装饰器的参数就是真正的原函数。
装饰器的主要原则如上，多层可以以此类推。
ptyhon的字符串有两种方法，一种是使用百分号的方法，一种为使用format() 方法来完成字符串的格式化，对于两者来说目前共存，相比较而言format方法提供的
功能更加丰富，比较先进，下面为两种方法的详细使用方法。
使用方法：
#
%[(name)][flags][width].[precision]typecode
name -- 可选参数，用于指定可用的key（引用时必须指定name的值，顺序可以不一致。）
flags --可选参数，如下的值可以选择：
width -- 可选参数，用于指定占位符所占有的宽度。
.precision --可选参数，用于指定小数点后保留的位数。
typecode --必选参数，可用值如下：
以上参数中并没有将正数转换成二进制的方式，这种效果 可以通过format()，方法来实现。
使用百分号方式格式化，如下实例：
1 # -*- coding:utf-8 -*- 2 # Author:wencheng.zhao 3 4 s1 = "my name is %s " % ("赵文成") #直接使用 %s 5 print(s1) 6 ##显示如下 7 my name is 赵文成 8 9 Process finished with exit code 0 10 11 #———————————————————————————————————— 12 s1 = "my name is %s, age is %d" % ("赵文成",26) #使用%d 13 print(s1) 14 15 #显示如下 16 my name is 赵文成, age is 26 17 18 Process finished with exit code 0 19 #———————————————————————————————————— 20 21 s1 = "my name is %(name)s, age is %(age)d" % {"age" : 26,"name" : "赵文成"} 22 print(s1) ##使用名称指定变量引用时可以顺序不一致。 23 #显示如下： 24 my name is 赵文成, age is 26 25 26 Process finished with exit code 0 27 #———————————————————————————————————— 28 s2 = "百分数：%.2f" % (96.3456) 29 s3 = "百分数：%.2f" % (96.3446) 30 print(s2) 31 print(s3) #保留两位小数，并且会四舍五入 32 #显示如下 33 百分数：96.35 34 百分数：96.34 35 36 Process finished with exit code 0 37 #———————————————————————————————————— 38 s4 = "i am %% %(pp).2f" % {"pp": 123.425556, } #两个%才能显示 39 #显示如下： 40 i am % 123.43 41 42 Process finished with exit code 0
参数用法：
[[fill]align][sign][#][0][width][,][.precision][type]
fill 【可选】空白处填充的字符
align 【可选】对齐方式（需配合width使用）
sign 【可选】有无符号数字
+，正号加正，负号加负；
-，正号不变，负号加负；
空格 ，正号空格，负号加负；
# 【可选】对于二进制、八进制、十六进制，如果加上#，会显示 0b/0o/0x，否则不显示
， 【可选】为数字添加分隔符，如：1,000,000
width 【可选】格式化位所占宽度
.precision 【可选】小数位保留精度
type 【可选】格式化类型
format()应用实例如下：
# -*- coding:utf-8 -*- # Author:wencheng.zhao s1 = "my name is {},age {}".format("赵文成",26) print(s1) # 直接使用。 #显示如下： my name is 赵文成,age 26 Process finished with exit code 0 #—————————————————————————————— s2 = "my name is {},age {}".format(*["赵文成",26]) print(s2) #同样可以用这种*[]的方法传递参数 #显示如下： my name is 赵文成,age 26 Process finished with exit code 0 #—————————————————————————————— s3 = "my name is {0},age {1},!!name{0}".format("赵文成",26) print(s3) #下标的方式来引用 #显示如下： my name is 赵文成,age 26,!!name赵文成 Process finished with exit code #—————————————————————————————— s3 = "my name is {name},age {age},!!name{name}".format(name = "赵文成",age = 26) print(s3) #变量名称的方式来传递参数 #显示如下 my name is 赵文成,age 26,!!name赵文成 Process finished with exit code #—————————————————————————————— s3 = "my name is {name},age {age},!!name{name}".format(**{"name":"赵文成","age":26}) print(s3) #同样可以用**{}的方式来传递参数 #显示如下 my name is 赵文成,age 26,!!name赵文成 #—————————————————————————————— s4 = "the first number is {0[1]}, second is {1[0]}.thrid is {0[2]}..".format([11,22,33,44],[55,66,77]) print(s4) #当元素为列表等类似类型时可以直接用下标来引用 #显示如下： the first number is 22, second is 55.thrid is 33.. Process finished with exit code 0 #—————————————————————————————— s3 = "my name is {name:s},age {age:d} ".format(name = "赵文成",age = 26) print(s3) #显示如下： my name is 赵文成,age 26 Process finished with exit code #—————————————————————————————— s4 = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2) print(s4) #显示如下： numbers: 1111,17,15,f,F, 1587.623000% Process finished with exit code 0 #—————————————————————————————— s5 = "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15) print(s5) #显示如下： numbers: 1111,17,15,f,F, 1500.000000% Process finished with exit code 0 #——————————————————————————————
字符串的格式化需要记住如下方法：
1.可以顺序传入参数，2.指定名称传入参数 3.如何保留小数点后几位 4.如果出现站位符则写%% ，打印是才能打印% ，此处%号相当于一个转译。
相比%来说 format 更具有优势体现在如下：
1.支持填充任意字符
2.可以居中
3.可以二进制显示
4.没有%的特殊意义，可直接用%
5...等
迭代器是访问集合元素的一种方式。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退，不过这也没什么，因为人们很少在迭代途中往后退。另外，迭代器的一大优点是不要求事先准备好整个迭代过程中所有的元素。迭代器仅仅在迭代到某个元素时才计算该元素，而在这之前或之后，元素可以不存在或者被销毁。这个特点使得它特别适合用于遍历一些巨大的或是无限的集合，比如几个G的文件，
迭代器的特点：
每当调用一个__next__方法时，则会去一次值。
a = iter([1,2,3,4,5]) print(a) print(a.__next__()) print(a.__next__()) print(a.__next__()) print(a.__next__()) print(a.__next__()) ## 显示如下： <list_iterator object at 0x00000076E2BB8630> 1 2 3 4 5 Process finished with exit code 0 ##如上，如果取值次数大于总次数时，则会报错。
一个函数调用时返回一个迭代器，那这个函数就叫做生成器（genetator）；如果一个函数包含yield语法，那这个函数就会变成生成器；
def func(): #定义一个函数 yield 1 yield 2 yield 3 yield 4 r = func() #r 获取返回值 res = r.__next__() #r调用next方法 print(res) res = r.__next__() print(res) res = r.__next__() print(res) res = r.__next__() print(res) ##获取结果如下： 1 2 3 4 Process finished with exit code 0 ##
取值时同样还会获得yield前面的值，如下：
def func(): print(1111) yield 1 print(2222) yield 2 print(3333) yield 3 r = func() res1 = r.__next__() print(res1) res2 = r.__next__() print(res2) res3 = r.__next__() print(res3) #显示如下： 1111 1 2222 2 3333 3 Process finished with exit code 0
对于如上，他的执行和对应关系如下：
利用生成器的方法自定义一个函数叫做，myrange(), 实现功能，当此函数被调用时，接受一个数值参数，函数自动返回从0开始到此数值的所有值。
实现如下：
def myrange(arg): start = 0 while True: if start >arg: return else: yield start start += 1 r = myrange(4) res = r.__next__() print(res) res = r.__next__() print(res) res = r.__next__() print(res) res = r.__next__() print(res) res = r.__next__() print(res) #显示如下： 0 1 2 3 4
如下有一串函数，分析他的执行的结果，函数如下：
def a(): r = b() print(r) def b(): r = c() return r def c(): r = d() return r def d(): return 123 a()
分析：
1.a函数中r的结果为b函数的返回值
b函数的返回值r为c函数的返回值
c函数的返回值r为d函数的返回值
d函数的返回值就是123
如上分析，a函数中的r的值为d函数的返回值123
如上为一个类似的递归，依次去执行，直到获取完最后一个返回值。
如下同样为一个递归的例子：
1 def myself (n): 2 n += 1 3 print(n) 4 if n >= 4: 5 return "end" 6 else: 7 return myself(n) ＃＃如果满足次条件则再次执行本函数，依次递归 8 9 r = myself(0) 10 print(r) 11 12 ＃显示结果如下： 13 1 14 2 15 3 16 4 17 end 18 19 Process finished with exit code 0
模块是用一系列的代码实现了某一个功能的代码集合，类似于函数式编程和面向过程编程，函数式编程则完成一个功能，其他代码用来调用即可，提供了代码的重用性和代码间的耦合。而对于一个复杂的功能来，可能需要多个函数才能完成（函数又可以在不同的.py文件中），n个 .py 文件组成的代码集合就称为模块。
模块有很多重模块，如os模块，file模块，time模块等，具体分类如下：
模块分类为3种：
直接创建 .py文件
－index.py
在同级目录下直接创建其他 .py文件
-index.py
-a.py
-b.py
在同级目录下直接创建目录在目录中在创建 .py的文件。
-index.py
-lib
-aaa.py
-bbb.py
所有的模块都是需要先倒入后使用，python丰富的模块，为python的程序员提供的各种操作工功能，使得python语言十分灵活和简单，当然所有的模块在使用之前都需要先倒入
python模块倒入的方法：
import module form module.xx.xx import xx form module.xx.xx import xx as xxx form module.xx.xx import * ##
导入的过程就是告诉python解释器去解释某个文件，
如下使用sys，使用前先倒入：（sys.path所获的路径就是默认的python倒入模块时所要寻找的路径）
# import sys ＃先倒入 r = sys.path ＃再使用 for i in r: print(i) # 显示如下： /Users/wenchengzhao/PycharmProjects/s13/day5 /Users/wenchengzhao/PycharmProjects/s13 /Library/Frameworks/Python.framework/Versions/3.5/lib/python35.zip /Library/Frameworks/Python.framework/Versions/3.5/lib/python3.5 /Library/Frameworks/Python.framework/Versions/3.5/lib/python3.5/plat-darwin /Library/Frameworks/Python.framework/Versions/3.5/lib/python3.5/lib-dynload /Library/Frameworks/Python.framework/Versions/3.5/lib/python3.5/site-packages
安装方式
1.使用系统自带的包管理工具安装，如： yum ， apt－get ，python专门提供的pip，esayinstall等
2.下载源码包编译
下载源码
解压源码
进入目录
编译安装 python setup.py build
安装源码 python setup.py install
注：在使用源码安装时，需要使用到gcc编译和python开发环境，所以，需要先执行：
yum -y install gcc python-devel
atp-get python-dev
安装成功后会自动安装到python所能识别的环境路径下。
json 和 pickle 提供的功能：
模块使用以及使用说明如下：
json与pickle对于 dumps dump load loads等的使用方法和使用效果相同（对于简单的数据类型），如下一json为例：
1 #s1 = "{‘k1‘:‘v1‘,‘k2‘:‘v2‘}" ＃＃注意此处不能写成这种形式 2 s1 = ‘{"k1":"v1","k2":"v2"}‘ 3 s1_l = json.loads(s1) # json.loads使用将原先的字符串类型转换成字典类型。 4 5 print(s1_l,type(s1_l)) 6 ＃显示如下： 7 {‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘} <class ‘dict‘> 8 9 Process finished with exit code 0 10 11 ＃－－－－－－－－－－－－－－－－－－－－－ 12 13 l1 = ["abc","1",1,"hello"] # 定义时为列表 14 l1_s = json.dumps(l1) ＃json的dumps方法将原先的列表类型转换成字符串类型。 15 print(l1_s,type(l1_s)) 16 ＃显示如下： 17 ["abc", "1", 1, "hello"] <class ‘str‘> 18 19 Process finished with exit code 0 20 21 ＃－－－－－－－－－－－－－－－－－－－－ 22 l2 = ["abc","1",1,"hello"] 23 24 json.dump(l2,open("testd.txt","w")) ##json.dump() 会直接将结果写入文件中 25 26 ＃结果如下： 27 ＃自动创建了一个文件为 testd.txt，然后里面的内容如下： 28 ["abc", "1", 1, "hello"] 29 ＃－－－－－－－－－－－－－－－－－－－－ 30 ss = json.load(open("testd.txt","r")) #json.load()直接打开文件 31 print(ss,type(ss)) 32 ＃显示如下 33 [‘abc‘, ‘1‘, 1, ‘hello‘] <class ‘list‘> 34 35 Process finished with exit code 0
json与pickle区别：
序列化使用例子：
通过天气预报借口获得天气情况，并使之可处理，实现如下：
1 ##天气相关 2 3 import requests ＃第三方模块，用于发送请求 4 import json 5 6 response = requests.get(‘http://wthrcdn.etouch.cn/weather_mini?city=北京‘) 7 response.encoding = ‘utf-8‘ 8 9 dic = json.loads(response.text) ＃将获得的字符串类型的结果存放到字典中。 10 print(dic,type(dic)) 11 ＃＃＃ 12 {‘status‘: 1000, ‘desc‘: ‘OK‘, ‘data‘: {‘forecast‘: [{‘high‘: ‘高温 31℃‘, ‘fengli‘: ‘微风级‘, ‘type‘: ‘多云‘, ‘low‘: ‘低温 19℃‘, ‘fengxiang‘: ‘无持续风向‘, ‘date‘: ‘8日星期三‘}, {‘high‘: ‘高温 32℃‘, ‘fengli‘: ‘3-4级‘, ‘type‘: ‘多云‘, ‘low‘: ‘低温 21℃‘, ‘fengxiang‘: ‘南风‘, ‘date‘: ‘9日星期四‘}, {‘high‘: ‘高温 32℃‘, ‘fengli‘: ‘微风级‘, ‘type‘: ‘雷阵雨‘, ‘low‘: ‘低温 20℃‘, ‘fengxiang‘: ‘无持续风向‘, ‘date‘: ‘10日星期五‘}, {‘high‘: ‘高温 30℃‘, ‘fengli‘: ‘3-4级‘, ‘type‘: ‘晴‘, ‘low‘: ‘低温 19℃‘, ‘fengxiang‘: ‘北风‘, ‘date‘: ‘11日星期六‘}, {‘high‘: ‘高温 31℃‘, ‘fengli‘: ‘微风级‘, ‘type‘: ‘晴‘, ‘low‘: ‘低温 21℃‘, ‘fengxiang‘: ‘无持续风向‘, ‘date‘: ‘12日星期天‘}], ‘yesterday‘: {‘high‘: ‘高温 26℃‘, ‘fl‘: ‘微风‘, ‘date‘: ‘7日星期二‘, ‘type‘: ‘多云‘, ‘low‘: ‘低温 16℃‘, ‘fx‘: ‘无持续风向‘}, ‘aqi‘: ‘148‘, ‘ganmao‘: ‘各项气象条件适宜，发生感冒机率较低。但请避免长期处于空调房间中，以防感冒。‘, ‘wendu‘: ‘28‘, ‘city‘: ‘北京‘}} <class ‘dict‘> 13 14 Process finished with exit code 0
1 import time 2 import datetime 3 4 ##返回当前系统的时间戳: 5 print(time.time()) ##显示 1465384604.16719 6 7 #———— 8 #当前系统的时间 9 print(time.ctime()) ##Wed Jun 8 19:17:35 2016 10 11 #———— 12 #将时间转换成字符串格式 13 print(time.ctime(time.time()-86440)) ## Tue Jun 7 19:18:44 2016 14 15 #---- 16 #将时间戳转换成struct_time格式 17 print(time.gmtime(time.time())) 18 #显示如下: 19 #time.struct_time(tm_year=2016, tm_mon=6, tm_mday=8, tm_hour=11, tm_min=21, tm_sec=32, tm_wday=2, tm_yday=160, tm_isdst=0) 20 21 #---- 22 #将时间戳转换成struct_time格式,但是返回的是本地时间 23 print(time.localtime(time.time())) 24 #显示如下: 25 #time.struct_time(tm_year=2016, tm_mon=6, tm_mday=8, tm_hour=19, tm_min=24, tm_sec=6, tm_wday=2, tm_yday=160, tm_isdst=0) 26 27 #---- 28 #与time.localtime()功能相反,将struc_time的格式转化为时间戳的格式。 29 print(time.mktime(time.localtime())) #显示1465385308.0 30 31 #---- 32 #time.sleep(4) #sleep 休眠等待。。。 33 34 #---- 35 #将struct_time格式转成指定的字符串格式 36 print(time.strftime("%Y-%m-%d %H:%M:%S")) ##2016-06-08 19:36:59 37 38 #---- 39 ##将字符串格式转换成struct_time格式 40 print(time.strptime("2016-01-28","%Y-%m-%d") ) 41 #显示如下: 42 #time.struct_time(tm_year=2016, tm_mon=1, tm_mday=28, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=28, tm_isdst=-1)
1 ######################### 2 import time 3 import datetime 4 print(datetime.date.today()) ##输出 2016-06-08 5 6 print(datetime.date.fromtimestamp(time.time()-86640)) #将时间戳转换成日期格式 输出:2016-06-07 7 8 now_time = datetime.datetime.now() 9 print(now_time) ##获取当前时间 显示2016-06-08 19:44:35.519973 10 11 print(now_time.timetuple()) ##返回 struct_time格式 12 #显示: time.struct_time(tm_year=2016, tm_mon=6, tm_mday=8, tm_hour=19, tm_min=45, tm_sec=49, tm_wday=2, tm_yday=160, tm_isdst=-1) 13 14 print(now_time.replace(2018,9,12)) #输出2018-09-12 19:47:56.355124,返回当前时间,但指定的值将被替换 15 16 str_to_date = datetime.datetime.strptime("21/11/16 16:30", "%d/%m/%y %H:%M") #将字符串转换成日期格式 17 print(str_to_date) 18 #显示 2016-11-21 16:30:00 19 20 new_date = datetime.datetime.now() + datetime.timedelta(days=10) #比现在加10天 21 print(new_date) 22 #显示 2016-06-18 19:52:03.079831 23 #同样的如下: 24 new_date = datetime.datetime.now() + datetime.timedelta(days=-10) #比现在减10天 25 new_date = datetime.datetime.now() + datetime.timedelta(hours=-10) #比现在减10小时 26 new_date = datetime.datetime.now() + datetime.timedelta(seconds=120) #比现在+120s
－－－－对应的字母代表的时间格式如下：
| Directive | Meaning | Notes |
|---|---|---|
%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. | |
%d |
Day of the month as a decimal number [01,31]. | |
%H |
Hour (24-hour clock) as a decimal number [00,23]. | |
%I |
Hour (12-hour clock) as a decimal number [01,12]. | |
%j |
Day of the year as a decimal number [001,366]. | |
%m |
Month as a decimal number [01,12]. | |
%M |
Minute as a decimal number [00,59]. | |
%p |
Locale’s equivalent of either AM or PM. | (1) |
%S |
Second as a decimal number [00,61]. | (2) |
%U |
Week number of the year (Sunday as the first day of the week) as a decimal number [00,53]. All days in a new year preceding the first Sunday are considered to be in week 0. | (3) |
%w |
Weekday as a decimal number [0(Sunday),6]. | |
%W |
Week number of the year (Monday as the first day of the week) as a decimal number [00,53]. All days in a new year preceding the first Monday are considered to be in week 0. | (3) |
%x |
Locale’s appropriate date representation. | |
%X |
Locale’s appropriate time representation. | |
%y |
Year without century as a decimal number [00,99]. | |
%Y |
Year with century as a decimal number. | |
%z |
Time zone offset indicating a positive or negative time difference from UTC/GMT of the form +HHMM or -HHMM, where H represents decimal hour digits and M represents decimal minute digits [-23:59, +23:59]. | |
%Z |
Time zone name (no characters if no time zone exists). | |
%% |
A literal ‘%‘ character. |
几乎所有程序都有记录日志的需求，并且日志中包含的信息即有正常的程序访问日志，还可能有错误、警告等信息输出，python的logging模块提供了标准的日志接口，你可以通过它存储各种格式的日志，logging的日志可以分为 debug(), info(), warning(), error() and critical() 5个级别。
更详细的日志等级：只有大于当前日志级别的信息才会被记录。
1 CRITICAL = 50 2 FATAL = CRITICAL 3 ERROR = 40 4 WARNING = 30 5 WARN = WARNING 6 INFO = 20 7 DEBUG = 10 8 NOTSET = 0
根据如下输出可知，logging的默认级别为warn，只用大于此级别的日志才能够输出：
##日志模块的测试 import logging logging.debug("debug.debug....") logging.info("info.info...") logging.warning("warn,warn.....") logging.error("err.err....") logging.critical("critical.critical...") ##显示如下 WARNING:root:warn,warn..... ERROR:root:err.err.... CRITICAL:root:critical.critical... Process finished with exit code 0
1 import logging 2 3 logging.basicConfig(filename="access.log",format=‘%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s‘,datefmt=‘%Y-%m-%d %H:%M:%S %p‘,level=10) 4 5 logging.debug(‘debug‘) 6 logging.info(‘info‘) 7 logging.warning(‘warning‘) 8 logging.error(‘error‘) 9 logging.critical(‘critical‘) 10 logging.log(10,‘log‘) 11 ##结果： 12 ＃1.创建了access.log文件： 13 ＃2.文件中内容如下： 14 2016-06-09 10:28:59 AM - root - DEBUG -temp: debug 15 2016-06-09 10:28:59 AM - root - INFO -temp: info 16 2016-06-09 10:28:59 AM - root - WARNING -temp: warning 17 2016-06-09 10:28:59 AM - root - ERROR -temp: error 18 2016-06-09 10:28:59 AM - root - CRITICAL -temp: critical 19 2016-06-09 10:28:59 AM - root - DEBUG -temp: log
根据上面可见：logging.basicConfig()函数中可通过具体参数来更改logging模块默认行为，可用参数有
format参数中可能用到的格式化串：
3.对log进行灵活的配置需要掌握如下知识：
logging库提供了多个组件：Logger、Handler、Filter、Formatter。Logger对象提供应用程序可直接使用的接口，Handler发送日志到适当的目的地，Filter提供了过滤日志信息的方法，Formatter指定日志显示格式。
如下定义个日志输出，分别输出到屏幕上和日志文件中，并且输出的日志级别不同。这就需要自定义hander指定输出的位置。
1 import logging 2 3 # 创建一个logger 4 logger = logging.getLogger(‘ZHAOWENCHENG-LOG‘) 5 logger.setLevel(logging.DEBUG) 6 7 # 创建一个handler(用与输出到屏幕上),设置日志级别为debug 8 ch = logging.StreamHandler() 9 ch.setLevel(logging.DEBUG) 10 11 # 创建一个handler(用与输出到日志文件中),设置日志级别为warn 12 fh = logging.FileHandler("access.log") 13 fh.setLevel(logging.WARNING) 14 # 定义一个文件格式 formatter 15 formatter = logging.Formatter(‘%(asctime)s - %(name)s - %(levelname)s - %(message)s‘) 16 17 ###将如上的定义做关联 18 #将formater与hander做关联 19 ch.setFormatter(formatter) 20 fh.setFormatter(formatter) 21 22 # 将ch 与 logger 做关联 23 logger.addHandler(ch) 24 logger.addHandler(fh) 25 26 # 用于输出的信息。 27 logger.debug(‘debug message‘) 28 logger.info(‘info message‘) 29 logger.warn(‘warn message‘) 30 logger.error(‘error message‘) 31 logger.critical(‘critical message‘)
文成小盆友python-num5 -装饰器回顾，模块，字符串格式化
标签：
原文地址：http://www.cnblogs.com/wenchengxiaopenyou/p/5562786.html
