| 编辑推荐: |
| 本文来源于cnblogs
，介绍了 time ，datetime ，random ，os ，sys ， shutil
，json&pickle ，logging 模块等知识。 |
|
一、time与datetime模块
在Python中，通常有这几种方式来表示时间：
时间戳(timestamp)：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。
格式化的时间字符串(Format String)
结构化的时间(struct_time)：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时)
import time
#--------------------------我们先以当前时间为准,让大家快速认识三种形式的时间
print (time.time()) # 时间戳 :1487130156.419527
print (time.strftime("%Y-%m-%d %X"))
# 格式化的时间字符串 :'2017-02-15 11:40:53'
print (time.localtime()) #本地时区的 struct_time
print (time.gmtime()) #UTC时区的 struct_time |
%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.
格式化字符串的时间格式 |
其中计算机认识的时间只能是'时间戳'格式，而程序员可处理的或者说人类能看懂的时间有: '格式化的时间字符串'，'结构化的时间'
，于是有了下图的转换关系
#--------------------------按图1转换时间
# localtime ([secs])
# 将一个时间戳转换为当前时区的 struct_time。secs 参数未提供 ，则以当前时间为准。
time.localtime ()
time.localtime (1473525444.037215)
# gmtime ([secs]) 和localtime()方法类似，gmtime () 方法是将一个时间戳转换为UTC时区（0时区）的struct
_ time。
# mktime(t) : 将一个 struct_time 转化为时间戳。
print (time.mktime (time.localtime ()) ) # 1473525749
.0
# strftime (format[, t]) : 把一个代表时间的元组或者struct_time（如由time.localtime
()和 # time. gmtime () 返回 ）转化为格式化的时间字符串。如果t未指定，将传入time.localtime
()。如果元组中任何一个
# 元素越界，ValueError 的错误将会被抛出。
print(time.strftime ("%Y-%m-%d %X",
time. localtime ( )))#2016-09-11 00:49:56
# time. strptime (string[, format])
# 把一个格式化时间字符串转化为 struct_time 。实际上它和strftime ()是逆操作。
print (time.strptime ('2011-05-05 16:37:06', '%Y-%m
- %d %X'))
#time.struct_time (tm_year=2011, tm_mon = 5, tm_mday
= 5, tm_hour = 16, tm_min = 37, tm_sec = 6,
# tm_wday = 3, tm_yday = 125, tm_isdst = -1)
#在这个函数中，format 默认为："%a %b %d %H:%M:%S %Y"
。 |
#--------------------------按图2转换时间
# asctime([t]) : 把一个表示时间的元组或者struct_ time 表示为这种形式：'Sun
Jun 20 23:21:05 1993 '。
# 如果没有参数，将会将time.localtime ()作为参数传入。
print (time.asctime() ) #Sun Sep 11 00:43:43 2016
# ctime ([secs]) : 把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。如果参数未给或者为
# None的时候，将会默认 time.time ()为参数。它的作用相当于time.asctime
(time.localtime(secs))。
print (time.ctime()) # Sun Sep 11 00:46:38 2016
print (time.ctime(time.time())) # Sun Sep 11
00:46:38 2016 |
1 #--------------------------其他用法
2 # sleep(secs)
3 # 线程推迟指定的时间运行，单位为秒。 |
datetime模块
#时间加减
import datetime
# 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)) #时间替换 |
二、random模块
import random
print (random.random())#(0,1)----float 大于0且小于1之间的小数
print (random.randint(1,3)) #[1,3] 大于等于1且小于等于3之间的整数
print (random.randrange(1,3)) #[1,3) 大于等于1且小于3之间的整数
print (random.choice([1,'23',[4,5]]))#1或者23或者[4,5]
print (random.sample([1,'23',[4,5]],2))#列表元素任意2个组合
print (random.uniform(1,3))#大于1小于3的小数，如1.927109612082716
item = [1,3,5,7,9]
random.shuffle (item) #打乱item的顺序,相当于"洗牌"
print (item) |
import random
def make_code (n):
res=''
for i in range(n):
s1 = chr (random.randint(65,90))
s2 = str (random.randint(0,9))
res += random.choice([s1,s2])
return res
print (make_code(9))
生成随机验证码 |
三、os模块
os模块是与操作系统交互的一个接口
os.getcwd()
获取当前工作目录，即当前python脚本工作的目录路径
os.chdir ("dirname") 改变当前脚本工作目录；相当于
shell下cd
os.curdir 返回当前目录: ('.')
os.pardir 获取当前目录的父目录字符串名：('..')
os.makedirs ('dirname1/dirname2') 可生成多层递归目录
os.removedirs ('dirname1') 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir ('dirname') 生成单级目录；相当于shell中mkdir dirname
os.rmdir ('dirname') 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir
dirname
os.listdir ('dirname') 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove () 删除一个文件
os.rename ("oldname","newname")
重命名文件/目录
os.stat ( 'path/filename') 获取文件/目录信息
os.sep 输出操作系统特定的路径分隔符，win下为"\\ ",Linux下为
"/"
os.linesep 输出当前平台使用的行终止符，win下为"\ t\n ",Linux下为
"\n"
os.pathsep 输出用于分割文件路径的字符串 win下为; , Linux 下为:
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所指向的文件或者目录的最后修改时间
os.path.getsize (path) 返回path的大小 |
在Linux和Mac平台上，该函数会原样返回
path，在windows 平台上会将路径中所有字符转换为小写，并将所有斜杠转换为饭斜杠。
>>> os.path.normcase ('c:/windows\\system32\\')
'c : \\ windows\\system32\\'
规范化路径，如..和/
>>> os.path.normpath ('c://windows \\System32
\\../ Temp /')
'c:\\windows\\Temp'
>>> a= '/Users/jieli /test1/\\\a1/\\\\aa.py/../..'
>>> print (os.path.normpath(a))
/Users /jieli/test1 |
os路径处理
#方式一：推荐使用
import os
#具体应用
import os,sys
possible_topdir = os.path.normpath(os.path.join(
os.path.abspath (__file__),
os.pardir, #上一级
os.pardir,
os.pardir
))
sys.path.insert (0,possible_topdir)
#方式二：不推荐使用
os.path.dirname (os.path.dirname (os .path. dirname
(os.path. abspath (__file__) ))) |
四、sys模块
sys.argv 命令行参数List，第一个元素是程序本身路径
sys.exit (n) 退出程序，正常退出时exit(0)
sys.version 获取 Python 解释程序的版本信息
sys.maxint 最大的 Int 值
sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH 环境变量的值
sys.platform 返回操作系统平台名称 |
打印进度条
#=========知识储备==========
#进度条的效果
[# ]
[## ]
[### ]
[#### ]
#指定宽度
print ('[%-15s]' %'#')
print ('[%-15s]' %'##')
print ('[%-15s]' %'###')
print ('[%-15s]' %'####')
#打印%
print ('%s%%' %(100)) #第二个%号代表取消第一个%的特殊意义
#可传参来控制宽度
print ('[%%-%ds]' %50) #[%-50s]
print (('[%%-%ds]' %50) %'#')
print (('[%%-%ds]' %50) %'##')
print (('[%%-%ds]' %50) %'###')
#=========实现打印进度条函数==========
import sys
import time
def progress (percent,width=50):
if percent >= 1:
percent = 1
show_str = ('[%%-%ds]' %width) % (int(width*percent)*'#')
print ('\r%s %d%%' %(show_str,int (100*percent)
),file = sys . stdout ,flush = True,end='')
#=========应用==========
data_size= 1025
recv_size= 0
while recv_size < data_size:
time.sleep (0.1) #模拟数据的传输延迟
recv_size+= 1024 #每次收1024
percent = recv_size/data_size #接收的比例
progress (percent,width=70) #进度条的宽度70
优化版本：
def progress (percent,width=50):
if percent > 1:
percent = 1
show_str = ('[%%-%ds]' %width) % (int(width*percent)
* '#')
print( '\r%s %d%%' % (show_str,int(100*percent)),end='')
import time
recv_size = 0
total_size = 100
while recv_size < total_size:
time.sleep (0.1)
recv_size += 1
percent = recv_size / total_size
progress (percent) |
五、shutil模块
高级的 文件、文件夹、压缩包 处理模块
shutil.copyfileobj(fsrc, fdst[, length])
将文件内容拷贝到另一个文件中
import shutil
shutil.copyfileobj (open('old.xml','r'), open
('new . xml', 'w')) |
shutil.copyfile(src, dst)
拷贝文件
| shutil.copyfile
('f1.log', 'f2.log') #目标文件无需存在 |
shutil.copymode(src, dst)
仅拷贝权限。内容、组、用户均不变
| Hello World!shutil.copymode
('f1.log', 'f2.log') #目标文件必须存在 |
shutil.copystat(src, dst)
仅拷贝状态的信息，包括：mode bits, atime, mtime, flags
| shutil.copystat
('f1.log', 'f2.log') #目标文件必须存在 |
shutil.copy(src, dst)
拷贝文件和权限
import shutil
shutil.copy ('f1.log', 'f2.log') |
shutil.copy2(src, dst)
拷贝文件和状态信息
import shutil
shutil.copy2('f1.log', 'f2.log') |
shutil.ignore_patterns(*patterns)
shutil.copytree(src, dst, symlinks=False, ignore=None)
递归的去拷贝文件夹
import shutil
shutil.copytree ('folder1', 'folder2', ignore
= shutil .ignore _ patterns ('*.pyc', 'tmp*'))
#目标目录不能存在，注意对 folder2目录父级目录要有可写权限，ignore 的意思是排除
|
import shutil
shutil.copytree ('f1', 'f2', symlinks=True, ignore
= shutil.ignore_patterns('*.pyc', 'tmp*' ) )
'''
通常的拷贝都把软连接拷贝成硬链接，即对待软连接来说，创建新的文件
'''
拷贝软链接 |
shutil.rmtree(path[, ignore_errors[, onerror]])
递归的去删除文件
import shutil
shutil.rmtree('folder1') |
shutil.move(src, dst)
递归的去移动文件，它类似mv命令，其实就是重命名。
import shutil
shutil.move('folder1', 'folder3') |
shutil.make_archive(base_name, format,...)
创建压缩包并返回文件路径，例如：zip、tar
创建压缩包并返回文件路径，例如：zip、tar
base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，
如 data_bak =>保存至当前路径
如：/tmp/data_bak =>保存至/tmp/
format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
root_dir： 要压缩的文件夹路径（默认当前目录）
owner： 用户，默认当前用户
group： 组，默认当前组
logger： 用于记录日志，通常是logging.Logger对象
#将 /data 下的文件打包放置当前程序目录
import shutil
ret = shutil.make_archive ("data_bak",
'gztar', root _ dir= '/data')
#将 /data下的文件打包放置 /tmp/目录
import shutil
ret = shutil.make_archive ("/tmp/data_bak",
'gztar', root_ dir= '/data') |
shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的，详细：
import zipfile
# 压缩
z = zipfile.ZipFile ('laxi.zip', 'w')
z.write ('a.log')
z.write ('data.data')
z.close()
# 解压
z = zipfile.ZipFile ('laxi.zip', 'r')
z.extractall (path='.')
z.close()
zipfile压缩解压缩 |
import tarfile
# 压缩
>>> t=tarfile.open ('/tmp/egon.tar','w')
>>> t.add ('/test1/a.py',arcname='a.bak')
>>> t.add ('/test1/b.py',arcname='b.bak')
>>> t.close ()
# 解压
>>> t=tarfile.open ('/tmp/egon.tar','r')
>>> t.extractall ('/egon')
>>> t.close ()
tarfile 压缩解压缩 |
六、json&pickle模块
之前我们学习过用eval内置方法可以将一个字符串转成python对象，不过，eval方法是有局限性的，对于普通的数据类型，json.loads和eval都能用，但遇到特殊类型的时候，eval就不管用了,所以eval的重点还是通常用来执行一个字符串表达式，并返回表达式的值。
import json
x= "[null,true,false,1]"
print (eval(x)) #报错，无法解析null类型，而json 就可以
print (json.loads(x)) |
什么是序列化？
我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。
为什么要序列化？
1：持久保存状态
需知一个软件/程序的执行就在处理一系列状态的变化，在编程语言中，'状态'会以各种各样有结构的数据类型(也可简单的理解为变量)的形式被保存在内存中。
内存是无法永久保存数据的，当程序运行了一段时间，我们断电或者重启程序，内存中关于这个程序的之前一段时间的数据（有结构）都被清空了。
在断电或重启程序之前将程序当前内存中所有的数据都保存下来（保存到文件中），以便于下次程序执行能够从文件中载入之前的数据，然后继续执行，这就是序列化。
具体的来说，你玩使命召唤闯到了第13关，你保存游戏状态，关机走人，下次再玩，还能从上次的位置开始继续闯关。或如，虚拟机状态的挂起等。
2：跨平台数据交互
序列化之后，不仅可以把序列化后的内容写入磁盘，还可以通过网络传输到别的机器上，如果收发的双方约定好实用一种序列化的格式，那么便打破了平台/语言差异化带来的限制，实现了跨平台数据交互。
反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。
如何序列化之json和pickle:
json
如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。
JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下：
Json模块提供了四个功能：dumps、dump、loads、load
import json
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = json.dumps(dic) #序列化：将一个字典转换成一个字符串
print (type(str_dic),str_dic) #<class 'str'>
{"k3" : "v3", "k1":
"v1", "k2": "v2"
}
#注意， json 转换完的字符串类型的字典中的字符串是由""表示的
dic2 = json.loads (str_dic) #反序列化：将一个字符串格式的字典转换成一个字典
#注意，要用 json 的loads功能处理的字符串类型的字典中的字符串必须由""表示
print (type(dic2) ,dic2) # <class 'dict'>
{'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
list_dic = [1, ['a','b','c'], 3, {'k1': 'v1','k2'
:'v2'} ]
str_dic = json.dumps (list_dic) #也可以处理嵌套的数据类型
print (type(str_dic),str_dic) # <class 'str'>
[1, ["a", "b", "c"]
, 3, {"k1": "v1", "k2":
"v2"}]
list_dic2 = json.loads (str_dic)
print (type (list_dic2),list_dic2) # <class
'list '> [1, ['a', 'b', 'c'], 3, {'k1': 'v1',
'k2': 'v2' }]
loads 和 dumps |
import json
f = open ('json_file','w')
dic = {'k1':'v1','k2':'v2','k3':'v3'}
json.dump (dic,f) #dump方法接收一个文件句柄，直接将字典转换成 json
字符串写入文件
f.close ()
f = open ('json_file')
dic2 = json.load (f) #load 方法接收一个文件句柄，直接将文件中的json字符串转换成数据结构返回
f.close ()
print (type(dic2),dic2)
load 和 dump |
import json
#dct= "{'1':111}"#json 不认单引号
#dct=str ({"1":111}) #报错,因为生成的数据还是单引号:{'one':
1}
dct ='{"1":"111"}'
print (json.loads(dct))
#conclusion:
# 无论数据是怎样创建的，只要满足json格式，就可以json.loads出来,不一定非要
dumps的数据才能 loads
注意点 |
pickle
import pickle
dic = {'name':'alvin','age':23,'sex':'male'}
print (type(dic))#<class 'dict'>
j= pickle.dumps (dic)
print(type(j)) #<class 'bytes'>
f=open ('序列化对象_pickle','wb')#注意是w是写入str,wb 是写入
bytes,j是 'bytes'
f.write (j) #-------------------等价于pickle.dump
(dic ,f)
f.close ()
#-------------------------反序列化
import pickle
f=open ('序列化对象_pickle','rb')
data = pickle.loads (f.read())# 等价于data = pickle
.load (f)
print ( data['age'] ) |
Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。
七、logging模块
日志级别
CRITICAL =
50 #FATAL = CRITICAL
ERROR = 40
WARNING = 30 #WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0 #不设置 |
默认级别为warning,默认打印到终端
import logging
logging.debug ('调试debug')
logging.info ('消息info')
logging.warning ('警告warn')
logging.error ('错误error')
logging.critical ('严重critical')
'''
WARNING:root: 警告 warn
ERROR:root :错误 error
CRITICAL:root: 严重 critical
''' |
为logging模块指定全局配置，针对所有logger有效，控制打印到文件中
可在 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 参数会被忽略。
#格式
%(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：用户输出的消息
format参数中可能用到的格式化串：
%(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用户输出的消息
#========使用
import logging
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)
logging.debug ('调试debug')
logging.info ('消息info')
logging.warning ('警告warn')
logging.error ('错误error')
logging.critical ('严重critical')
#========结果
access.log内容:
2017-07-28 20:32:17 PM - root - DEBUG -test:
调试debug
2017-07-28 20:32:17 PM - root - INFO -test:
消息info
2017-07-28 20:32:17 PM - root - WARNING -test:
警告warn
2017-07-28 20:32:17 PM - root - ERROR -test:
错误error
2017-07-28 20:32:17 PM - root - CRITICAL -test:
严重critical
part2: 可以为logging 模块指定模块级的配置,即所有logger的配置 |
logging模块的Formatter,Handler，Logger，Filter对象
原理图：
logger：产生日志的对象
Filter:过滤日志的对象
Handler:接收日志然后控制打印到不同的地方，FileHandler用来打印到文件中，StreamHandler
用来打印到终端
Formatter 对象：可以定制不同的日志格式对象，然后绑定给不同的 Handler 对象使用，以此来控制不同的Handler
的日志格式
'''
critical=50
error =40
warning =30
info = 20
debug =10
'''
import logging
#1、logger对象：负责产生日志，然后交给 Filter 过滤，然后交给不同的Handler输出
logger = logging.getLogger (__file__)
#2、Filter 对象：不常用，略
#3、Handler 对象：接收 logger 传来的日志，然后控制输出
h1=logging.FileHandler ('t1.log') #打印到文件
h2=logging.FileHandler ('t2.log') #打印到文件
h3=logging.StreamHandler () # 打印到终端
#4、Formatter对象：日志格式
formmater1 = logging.Formatter ('%(asctime)s -
%(name) s - % (levelname)s -% (module)s: % ( message)
s',
datefmt = '%Y-%m-%d %H:%M:%S %p',)
formmater2 = logging.Formatter ('%(asctime)s :
% ( message) s',
datefmt = '%Y-%m-%d %H:%M:%S %p',)
formmater3 = logging.Formatter ('%(name)s %( message)s',)
#5、为 Handler 对象绑定格式
h1.setFormatter (formmater1)
h2.setFormatter (formmater2)
h3.setFormatter (formmater3)
#6、将Handler添加给 logger 并设置日志级别
logger.addHandler (h1)
logger.addHandler (h2)
logger.addHandler (h3)
logger.setLevel (10)
#7、测试
logger.debug ('debug')
logger.info ('info')
logger.warning ('warning')
logger.error ('error')
logger.critical ('critical') |
Logger与Handler的级别
logger是第一级过滤，然后才能到handler，我们可以给logger和handler同时设置level，但是需要注意的是
Logger is also
the first to filter the message based on a level
— if you set the logger to INFO, and all handlers
to DEBUG, you still won't receive DEBUG messages
on handlers — they'll be rejected by the logger
itself. If you set logger to DEBUG, but all handlers
to INFO, you won't receive any DEBUG messages
either — because while the logger says "ok,
process this", the handlers reject it (DEBUG
< INFO).
#验证
import logging
form=logging.Formatter ('%(asctime)s - %(name)s
- % (levelname)s -%(module)s: %(message)s',
datefmt = '%Y-%m-%d %H:%M:%S %p',)
ch=logging.StreamHandler ()
ch.setFormatter (form)
# ch.setLevel (10)
ch.setLevel (20)
l1=logging.getLogger ('root')
# l1.setLevel (20)
l1.setLevel (10)
l1.addHandler (ch)
l1.debug ('l1 debug')
重要，重要，重要！！！ |
Logger的继承(了解)
import logging
formatter=logging.Formatter('%(asctime)s -
%(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',)
ch=logging.StreamHandler()
ch.setFormatter(formatter)
logger1=logging.getLogger('root')
logger2=logging.getLogger('root.child1')
logger3=logging.getLogger('root.child1.child2')
logger1.addHandler(ch)
logger2.addHandler(ch)
logger3.addHandler(ch)
logger1.setLevel(10)
logger2.setLevel(10)
logger3.setLevel(10)
logger1.debug('log1 debug')
logger2.debug('log2 debug')
logger3.debug('log3 debug')
'''
2017-07-28 22:22:05 PM - root - DEBUG -test:
log1 debug
2017-07-28 22:22:05 PM - root.child1 - DEBUG
-test: log2 debug
2017-07-28 22:22:05 PM - root.child1 - DEBUG
-test: log2 debug
2017-07-28 22:22:05 PM - root.child1.child2
- DEBUG -test: log3 debug
2017-07-28 22:22:05 PM - root.child1.child2
- DEBUG -test: log3 debug
2017-07-28 22:22:05 PM - root.child1.child2
- DEBUG -test: log3 debug
'''
了解即可 |
logging应用
"""
logging配置
"""
import os
import logging.config
# 定义三种日志输出格式 开始
standard_format = '[%(asctime)s] [%(threadName)s:
%(thread)d] [task_id:%(name)s] [%(filename)s:
% (lineno)d]' \
'[%(levelname)s] [%(message)s]' # 其中name为getlogger指定的名字
simple_format = '[%(levelname)s] [%(asctime)s]
[%(filename)s: %(lineno)d] %(message)s'
id_simple_format = '[%(levelname)s] [%(asctime)s]
%(message)s'
# 定义日志输出格式 结束
logfile_dir = os.path.dirname (os.path.abspath(__file__))
# log文件的目录
logfile_name = 'all2.log' # log文件名
# 如果不存在定义的日志目录就创建一个
if not os.path.isdir (logfile_dir):
os.mkdir (logfile_dir)
# log文件的全路径
logfile_path = os.path.join (logfile_dir, logfile_name)
# log配置字典
LOGGING_DIC = {
'version': 1,
'disable_existing_loggers': False,
'formatters': {
'standard': {
'format': standard_format
},
'simple': {
'format': simple_format
},
},
'filters': {},
'handlers': {
#打印到终端的日志
'console': {
'level': 'DEBUG',
'class': 'logging.StreamHandler', # 打印到屏幕
'formatter': 'simple'
},
#打印到文件的日志,收集info及以上的日志
'default': {
'level': 'DEBUG',
'class': 'logging.handlers. RotatingFileHandler',
# 保存到文件
'formatter': 'standard',
'filename': logfile_path, # 日志文件
'maxBytes': 1024*1024*5, # 日志大小 5M
'backupCount': 5,
'encoding': 'utf-8', # 日志文件的编码，再也不用担心中文log乱码了
},
},
'loggers': {
#logging.getLogger (__name__)拿到的logger配置
'': {
'handlers': ['default', 'console'], # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
'level': 'DEBUG',
'propagate': True, # 向上（更高level的logger）传递
},
},
}
def load_ my_logging_cfg ():
logging. config.dictConfig (LOGGING_DIC) # 导入上面定义的logging配置
logger = logging.getLogger (__name__) # 生成一个log实例
logger. info ('It works!') # 记录该文件的运行状态
if __name__ = = '__main__':
load_my_logging_ cfg ()
logging 配置文件 |
"""
MyLogging Test
"""
import time
import logging
import my_logging # 导入自定义的logging配置
logger = logging.getLogger(__name__) # 生成logger实例
def demo():
logger.debug ("start range... time:{}".format(time.time()))
logger.info ("中文测试开始。。。")
for i in range(10):
logger.debug ("i:{}".format(i))
time.sleep(0.2)
else:
logger.debug ("over range... time:{}".format
(time.time()))
logger.info("中文测试结束。。。")
if __name__ == "__main__":
my_logging.load_my_logging_cfg() # 在你程序文件的入口加载自定义logging配置
demo ()
应用 |
注意注意注意：
#1、有了上述方式我们的好处是：所有与 logging 模块有关的配置都写到字典中就可以了，更加清晰，方便管理
#2、我们需要解决的问题是：
1、从字典加载配置：logging.config.dictConfig ( settings
.LOGGING_DIC)
2、拿到logger对象来产生日志
logger 对象都是配置到字典的 loggers 键对应的子字典中的
按照我们对 logging 模块的理解，要想获取某个东西都是通过名字，也就是key来获取的
于是我们要获取不同的 logger 对象就是
logge r= logging .getLogger ('loggers子字典的key名')
但问题是：如果我们想要不同 logger名的 logger对象都共用一段配置，那么肯定不能在
loggers子字典中定义n个key
'loggers': {
'l1': {
'handlers': ['default', 'console'], #
'level': 'DEBUG',
'propagate': True, # 向上（更高level的logger）传递
},
'l2: {
'handlers': ['default', 'console' ],
'level': 'DEBUG',
'propagate': False, # 向上（更高level的logger）传递
},
'l3': {
'handlers': ['default', 'console'], #
'level': 'DEBUG',
'propagate': True, # 向上（更高level的logger）传递
},
}
#我们的解决方式是，定义一个空的key
'loggers': {
'': {
'handlers': ['default', 'console'],
'level': 'DEBUG',
'propagate': True,
},
}
这样我们再取logger对象时
logging. getLogger (__name__)，不同的文件__name__不同，这保证了打印日志时标识信息不同，但是拿着该名字去
loggers里找 key名时却发现找不到，于是默认使用key =''的配置
!!!关于如何拿到 logger 对象的详细解释！！！ |
另外一个django的配置，瞄一眼就可以，跟上面的一样
#logging_config.py
LOGGING = {
'version': 1,
'disable_ existing_loggers': False,
'formatters': {
'standard': {
'format': '[%(asctime)s] [%(threadName)s :% (thread)
d] [task_id:%(name)s] [%(filename)s :% (lineno)d]'
'[%(levelname)s] [%(message)s]'
},
'simple': {
'format': '[%(levelname)s] [%(asctime)s] [%( filename)s:
%(lineno)d] %(message)s'
},
'collect': {
'format': '%(message)s'
}
},
'filters': {
'require_debug_true': {
'()' : 'django.utils .log. RequireDebugTrue',
},
},
'handlers': {
#打印到终端的日志
'console': {
'level': 'DEBUG',
'filters': ['require_debug_true'],
'class' : 'logging .StreamHandler',
'formatter': 'simple'
},
#打印到文件的日志,收集info及以上的日志
'default': {
'level': 'INFO',
'class': 'logging.handlers. RotatingFileHandler',
# 保存到文件，自动切
'filename': os.path.join (BASE_LOG_DIR, "xxx_
info.log "), # 日志文件
'maxBytes': 1024 * 1024 * 5, # 日志大小 5M
'backupCount': 3,
'formatter': 'standard',
'encoding': 'utf-8',
},
#打印到文件的日志:收集错误及以上的日志
'error': {
'level': 'ERROR',
'class': 'logging.handlers .RotatingFileHandler',
# 保存到文件，自动切
'filename': os.path.join (BASE_LOG_DIR, "xxx_err.log"),
# 日志文件
'maxBytes': 1024 * 1024 * 5, # 日志大小 5M
'backupCount': 5,
'formatter': 'standard',
'encoding': 'utf-8',
},
#打印到文件的日志
'collect': {
'level': 'INFO',
'class': 'logging.handlers .RotatingFileHandler',
# 保存到文件，自动切
'filename': os.path.join (BASE_LOG_DIR, "xxx_collect.log"),
'maxBytes': 1024 * 1024 * 5, # 日志大小 5M
'backupCount': 5,
'formatter': 'collect',
'encoding': "utf-8"
}
},
'loggers': {
#logging.getLogger (__name__)拿到的logger配置
'': {
'handlers': ['default', 'console', 'error'],
'level': 'DEBUG',
'propagate': True,
},
#logging.getLogger ('collect')拿到的logger配置
'collect': {
'handlers': ['console', 'collect'],
'level': 'INFO',
}
},
}
# -----------
# 用法:拿到俩个logger
logger = logging.getLogger (__name__) #线上正常的日志
collect_logger = logging.getLogger ("collect")
#领导说,需要为领导们单独定制领导们看的日志 |
|
