您可以捐助,支持我们的公益事业。

1元 10元 50元





认证码:  验证码,看不清楚?请点击刷新验证码 必填



  求知 文章 文库 Lib 视频 Code iProcess 课程 认证 咨询 工具 火云堂 讲座吧   成长之路  
会员   
 
   
 
  
每天15篇文章
不仅获得谋生技能
更可以追随信仰
 
     
   
 订阅
  捐助
Python3 常用模块
 
940 次浏览     评价:  
 2018-5-25 
 
编辑推荐:
本文来源于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") #领导说,需要为领导们单独定制领导们看的日志
   
941 次浏览  评价: 差  订阅 捐助
相关文章

手机软件测试用例设计实践
手机客户端UI测试分析
iPhone消息推送机制实现与探讨
Android手机开发(一)
相关文档

Android_UI官方设计教程
手机开发平台介绍
android拍照及上传功能
Android讲义智能手机开发
相关课程

Android高级移动应用程序
Android系统开发
Android应用开发
手机软件测试
每天2个文档/视频
扫描微信二维码订阅
订阅技术月刊
获得每月300个技术资源
 
 

关于我们 | 联系我们 | 京ICP备10020922号 京公海网安备110108001071号