| 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") #领导说,需要为领导们单独定制领导们看的日志 |