python---常用模块
# 什么是模块：一个模块就是一个包含了python定义和声明的文件，文件名就是模块名字加.py的后缀 # import 加载的模块分四个同于类别 # 1.使用python编写的代码（.py文件） # 2.已被编译为共享库或DLL的c或c++扩展 # 3.包好一组 模块的包 # 4.使用c编程写并连接到python解释器的内置模块 #常用模块 #在内置数据类型（dict，list，set，tuple）的基础上，collestions模块提供了几个额外的数据类型： #Counter，deque，defaultdict,namedtuple和OrderedDict #1.namedtuple:生成可以使用名字来访问元素内容的tuple #2.deque：双端队列，可以快速的从另外一侧追加和退出对象 #3.Counter：计数器，主要用来计数 #4.OrderedDict：有序字典 #5.defaultdict：带默认值的字典 #collections模块 tuple #可表示不变集合 #namedtuple #可命名元组 （如果要用坐标和半径表示一个圆，可以用namedtuple） # from collections import namedtuple #从进口namedtuple集合 # Point=namedtuple('Point',['x','y']) # p=Point(1,2) # print(p.x,p.y) # # #deque 双队列 （是为了高效实现插入和删除操作的双向类表，适用于队列和栈） #deque 除了四线list的append（）和pop（）外，还支持appendleft（）和popleft（），这样就能高效的添加和删除元素了 # from collections import deque # q=deque(['a','b','c']) # q.append('x') #追加至后 # q.appendleft('y') # =添加至前 # print(q) # OrderedDict #有序字典 #使用dict时，key是无须的，在对dict做迭代时，可以的值无法确定顺序 #如要保持可以的顺序，可以用OrderedDict # from collections import OrderedDict # d=OrderedDict([('a',1),('b',2),('c',3)]) #key是有序的 # print(d) # d1=dict([('a',1),('b',2),('c',3)]) #key是无序的 # print(d1) #OrderedDict的key会按照插入的顺序排列，不是key本身排列 #例如 # from collections import OrderedDict # ##d=OrderedDict([('a',1),('b',2),('c',3)]) # d2=OrderedDict() # d2['z']=1 # d2['y']=2 # d2['x']=3 # ##print(d) # print(d2.keys()) #按照插入的key的顺序返回 #defaultdict #原生字典解决方法 # value=[11,22,33,44,55,66,77,88,99,100] # dict={'k1':[],'k2':[]} # for i in value: # if i<66: # dict['k1'].append(i) # else: # dict['k2'].append(i) # print(dict) #defaultdict字典解决方法 # from collections import defaultdict # value=[11,22,33,44,55,66,77,88,99,100] # dict=defaultdict(list) # for item in value: # if item>66: # dict['k1'].append(item) # else: # dict['k2'].append(item) # print(dict) #使用dict时，如果引用的key不存在，就会抛出keyError，如果希望key不存在时，返回一个默认值，就可以 #用defaultdict #Counter 计算值出现的次数，无序的容器类型，以字典的键值对形式储存，其中元素作为key #其技术作为value，技术值可以是任意的interger（包括0和负数） # a=Counter('aaaffffvvvvxx') # print(a) #########re######### # '#re模块 #1、验证手机号是否合法 # while True: # phone_number=input('请输入手机号：') # if len(phone_number)==11 and phone_number.isdigit()\ # and phone_number.startswith('13')\ # or phone_number.startswith('14') \ # or phone_number.startswith('15')\ # or phone_number.startswith('17') \ # or phone_number.startswith('18'): # print('手机号合法') # else: # print('手机号不行') #2、验证手机是否合法 # import re # phone_nuber=input('输入手机号：') # if re.match('^(13|14|15|18)[0-9]{9}$',phone_nuber): # print('合法手机号') # else: # print('不合法手机号') #re模块和正则表达式 ##正则表达式不仅在python领域中，在整个编程界都有举足轻重的地位 #正则表达式本身就是匹配字符串内容的一种规则 #正则表达式是对字符串操作的一种逻辑公式，就是是先定义号的一些特定字符、这些特定字符的组合 #，组成一个“规则字符串”，这个“规则字符串”用来哦表达对字符串的一种过滤逻辑 ##正则表达式 #字符组:在同一个位置可能出现的各种字符组成了一个字符组，在正则表达式中用[]表示 #字符分为很多种类，如数字，字母，标点等等 #re模块下的常用方法 import re ret=re.findall('a','eva egon yuan') #返回所有满足匹配条件的结果，放在列表里 print(ret) ret=re.search('a','eva egon yuan').group() print(ret) ##函数会在字符串内查找模式匹配5时时时身上ss，只要找到第一个匹配然后返回一个包含匹配信息的对象，该对象可以通过调用group（） #方法得到匹配的字符串，如果字符串没有匹配，则返回None ret=re.match('a','abc').group() #同search，不过在字符串开始处进行匹配 print(ret) ret=re.split('[ab]','abcd') #先按a分隔，再按b分隔 print(ret) ret=re.sub('\d','H','eva3egon4yuan5',1)#将数字替换成H，参数1表示之替换一个 print(ret) ret=re.subn('\d','H','eva3egon4yuan4') #将数字替换成H，返回元组 print(ret) a=re.compile('\d{3}') #将正则表达式编译成一个正则表达式对象，匹配3个数字 ret=a.search('abc123eee')#正则表达式对象调用search，参数为待匹配的字符串 print(ret) import re ret=re.findall('\d','ds3sy4784a') #findall返回一个存放匹配结果的迭代器 print(ret) #<callable_iterator object at 0x10195f940> print(next(ret).group()) #查看第一个结果 print(next(ret).group()) #查看第二个结果 print([i.group() for i in ret]) #查看剩余的左右结果 #findall优先级查询 import re ret = re.findall('www.(baidu|oldboy).com', 'www.oldboy.com') print(ret) # ['oldboy'] 这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可 ret = re.findall('www.(?:baidu|oldboy).com', 'www.oldboy.com') print(ret) # ['www.oldboy.com'] #split的优先级查询 ret=re.split("\d+","eva3egon4yuan") print(ret) #结果 ： ['eva', 'egon', 'yuan'] ret=re.split("(\d+)","eva3egon4yuan") print(ret) #结果 ： ['eva', '3', 'egon', '4', 'yuan'] #在匹配部分加上（）之后所切出的结果是不同的， #没有（）的没有保留所匹配的项，但是有（）的却能够保留了匹配的项， #这个在某些需要保留匹配部分的使用过程是非常重要的。
#! usr/bin/env python # -*- coding: utf-8 -*- #常用方法 # import time # #time.sleep(secs) #(线程)推迟指定的时间运行。单位为秒。 # time.time() #获取当前时间戳 表示时间的三种方式 时间戳(timestamp)，元组(struce_time)，格式化时间字符串(format String)： import time #时间模块 #时间戳 time.time() #时间字符串 ret=time.strftime('%Y-%m-%d %X') # 表示年月日 %X表示时分秒 print(ret) import time #格式时间字符串 ret=time.strftime('%H-%M-%S') #表示时分秒 print(ret) #时间元组:localtime将一个时间戳转换为当前时区的struct_time time.localtime() time.struct_time(tm_year=2017,tm_mon=7,tm_mday=24, tm_hour=13,tm_min=59,tm_sec=37, tm_wday=0,tm_yday=205,tm_isdst=0) #几种格式化之间的转换 #时间戳--->结构化时间 time.gmtime('时间戳') #UCT时间 time.localtime('时间戳') #当地时间 time.gmtime(15000000000) time.struct_time(tm_year=2017,tm_mon=7,tm_mday=14,tm_hour=2,tm_min=40,tm_sec=0,tm_wday=4,tm_yday=195,tm_isdst=0) time.localtime(15000000000) time.struct_time(tm_year=2017,tm_mon=7,tm_mday=14,tm_huor=10,tm_min=40,tm_sec=0,tm_wday=4,tm_yday=195,tm_isdst=0) #结构化时间--->时间戳 time.mktime('结构化时间') time_tuple=time.localtime(1500000000) time.mktime(time_tuple) #结构化时间---->字符串时间 #time.strftime('格式化'，‘结构化时间’) #结构化时间参数若不转，则实现当前时间 time.strftime('2017-3-15','%Y-%m-%d %X') time.strftime('%Y-%m-%d',time.localtime(1500000000)) #字符串时间---->结构化时间 time.strptime('2017-03-16','%Y-%m-%d') time.srtptime('时间字符串，字符串对应格式') time.strptime(tm_year=2017,tm_mon=7,tm_mday=15,tm_hour=10,tm_min=46,tm_sec=22,tm_wday=3,tm_yday=75,tm_isdst=-1) time.strptime('07/24/2017','%m%d%Y') time.struce_time(tm_year=2017,tm_mon=7,tm_mday=24,tm_hour=0,tm_min=0,tm_sec=0,tm_wday=0,tm_yday=205,tm_isdst=-1) #结构化时间------>%a %b %d %H:%M:%S %Y串 #time.asctime('结构化时间')#如果不传参数，直接返回当前时间的格式化串 time.asctime(time.localtime(15000000000)) time.asctime() #%a %d %d %H:%M：%S %Y串--->结构化时间 #time.ctime(时间戳) 如果不传参，直接返回当前时间的格式化串 time.ctime() time.ctime(1500000000) #random模块 import random #随机小数 random._urandom() #大于0且小于1之间的小数 random.uniform(1,3) #大于1小于3的小数 #随机整数 random.randint(1,5) #大于1且小于等于5之间的整数 random.randrange(1,10,2) #大于等于1且小于3之间的整数 #随机选择一个返回 random.choice([1,'23',[4,5]]) #1或者23或者[4,5] #随机选择多个返回，返回的个数为函数的第二个参数 random.sample([1,'23',[4,5]],2) #列表元素任意两个组合 #打乱列表顺序 item=[1,3,5,7,9] random.shuffle(time) #打乱次序 item random.shuffle(item) item #练习生成随机验证码 import random def code1(): code='' for i in range(5): num=random.randint(0,9) alf=chr(random.randint(65,90)) aef=random.randint(91,122) add=random.choice([num,alf,aef]) code=''.join([code,str(add)]) return code print(code1()) #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.popen("bash command) 运行shell命令，获取执行结果 os.environ 获取系统环境变量 os.path 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的大小 ''' #注：os.stat('path/filenanme')获取文件/目录信息的结构说明 # stat 结构: # # st_mode: inode 保护模式 # st_ino: inode 节点号。 # st_dev: inode 驻留的设备。 # st_nlink: inode 的链接数。 # st_uid: 所有者的用户ID。 # st_gid: 所有者的组ID。 # st_size: 普通文件以字节为单位的大小；包含等待某些特殊文件的数据。 # st_atime: 上次访问的时间。 # st_mtime: 最后一次修改的时间。 # st_ctime: 由操作系统报告的"ctime"。在某些系统上（如Unix）是最新的元数据更改的时间，在其它系统上（如Windows）是创建时间（详细信息参见平台的文档）。 #sys模块 #sys模块是否与python解释器交互的一个接口 # sys.argv 命令行参数List，第一个元素是程序本身路径 # sys.exit(n) 退出程序，正常退出时exit(0) # sys.version 获取Python解释程序的版本信息 # sys.maxint 最大的Int值 # sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值 # sys.platform 返回操作系统平台名称 #序列化模块 #什么叫序列化-----将原本的字典、列表等内容转换成一个字符串的过程就叫做序列化 #序列化的目的 #1.以某种存储形式自定义对象持久化 #2.将对象从一个地方递到另一个地方 #3.使程序更具维护性。
#json 模块提供了四个功能：dumps、dump、loads、load #loads和dumps import json dic={'k1':'v1','k2':'v2','k3':'v3'} str_idc=json.dumps(dic) #序列化:将一个字典转换成一个字符串 print(type(str_idc),str_idc) #注：json转换完的字符串类型的字典中的字符串是由“”表示的 #dic2=json.loads(str_dic) #反序列化：将一个字符串格式的字典转换成一个字典 #注要用json的loads功能处理的字符串类型的字典中的字符串必须由“”表示 #print(type(dic2),dic2) 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'}] #load和dump 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) #pickle #json & pickle 模块 #用于序列化的两个模块 # *json，用于字符串和python数据类型件进行转换 # *pickle，用于python特有的类型和python的数据类型jian进行转换 #pickle模块了四个功能：dumps、dump(序列化，存)，loads（反序列化，读），load（不仅可以序列化字典、列表，，，，可以吧python中任意的数据类型序列化） import pickle dic = {'k1':'v1','k2':'v2','k3':'v3'} str_dic = pickle.dumps(dic) print(str_dic) #一串二进制内容 dic2 = pickle.loads(str_dic) print(dic2) #字典 import time struct_time = time.localtime(1000000000) print(struct_time) f = open('pickle_file','wb') pickle.dump(struct_time,f) f.close() f = open('pickle_file','rb') struct_time2 = pickle.load(f) print(struct_time.tm_year) #shelve #shelve是python提供给我们的序列化工具 import shelve f = shelve.open('shelve_file') f['key'] = {'int':10, 'float':9.5, 'string':'Sample data'} #直接对文件句柄操作，就可以存入数据 f.close() import shelve f1 = shelve.open('shelve_file') existing = f1['key'] #取出数据的时候也只需要直接用key获取即可，但是如果key不存在会报错 f1.close() print(existing) #shelve只读 import shelve f = shelve.open('shelve_file', flag='r') existing = f['key'] f.close() print(existing) #设置writeback import shelve f1 = shelve.open('shelve_file') print(f1['key']) f1['key']['new_value'] = 'this was not here before' f1.close() f2 = shelve.open('shelve_file', writeback=True) print(f2['key']) f2['key']['new_value'] = 'this was not here before' f2.close()
#模块博客：http://www.cnblogs.com/Eva-J/articles/7228075.html
常用模块：
1，hashlib----单向的，只能正向把一个字符串进行摘要结果，md5，sha在hashlib模块下使用
hashlib----------摘要算法模块
摘要算法的主要方法有：
Md5，SHA等称为摘要算法又称哈希算法，散列算法
应用：1，查看某两个文件是否完全一致（文件的一致校验）
2，加密认证-----在存储密码的时候是使用密文存储的，消炎密码的时候对用户的输入在做一次校验。
摘要算法的用法（需转bytes类型）：
#hashlib:摘要算法的模块 #作用/用途：查看某两个文件是否完全一致，加密认证两种 import hashlib #导如hashlib模块 md5_obj = hashlib.md5() #选择摘要算法中的md5进行实例化，得到一个对象md5_obj md5_obj.update(b'how to use md5 in python hashlib?') #对一个字符串进行摘要，这放一定放bytes类型 # 这里必须转成bytes类型，所以在字符串前加b print(md5_obj.hexdigest()) #在摘要对象中找结果
*********可以在百度MD5破解玩一下
在摘要文件时：有两个文件，一行一行读，每读一行就update一下，在对比hexdigest。
一篇文章校验，还是一行一行读，转bytes类型。再update。最后hexdigest
加盐命令：
为了加强保密性，不让md5简单容易计算出来，可以通过加盐方法提高难度
hashlib.md5('*'.encode('utf-8'))
MD5难度小于SHA，SHA1更大。难度越大越慢
用户的加密认证：单纯的md5是最通用的，不够安全。
加盐处理：简单的加盐可能会被破解，破解之后的盐都会失效。
动态加盐：用户作为盐，每一个用户都加盐。用户名+复杂字符串+密码
SHA的算法跟md5算法不同，但别的应用一样。
import hashlib #导如hashlib模块 sha_obj = hashlib.sha1() #选择摘要算法中的md5进行实例化，得到一个对象sha_obj sha_obj.update(b'how to use md5 in python hashlib?') #对一个字符串进行摘要， # 这里必须转成bytes类型，所以在字符串前加b print(sha_obj.hexdigest()) #在摘要对象中找结果 hashlib.sha1('*'.encode('utf-8'))
2，configparser模块
只要是cong，congfig，congfiger都是和配置文件有关的
配置文件：通过一个文件或什么控制程序的走向
# 创建文件 #该模块适用于配置文件的格式 import configparser config = configparser.ConfigParser() #生成一对象 config['DEFAULT'] = { 'SeverAliveInterval':'45', 'Compression':'yes', 'CompressionLevel':'9', 'ForwardXll':'yes' } config['bitbucket.org'] = {'User':'hg'} config['topsecret.server.com'] = {'Host Port':'50022','ForwardXll':'no'} with open('example.ini','w') as configfile: config.write(configfile)
# 查找文件 import configparser config = configparser.ConfigParser() #-----查找文件内容，基于字典的形式 print(config.sections()) config.read('example.ini') print(config.sections()) print('byrebong.com' in config) #False print('bitbucket.org' in config) #True print(config['bitbucket.org']['user']) #hg print(config['DEFAULT']['Compression']) #yes print(config['topsecret.server.com']['ForwardXll']) #no print(config['bitbucket.org']) #<Section:bitbucket.org for key in config['bitbucket.org']: #注意，有default会默认default的键 print(key) print(config.options('bitbucket.org')) #同for循环，找到'bitbucket.org'下所有键 print(config.items('bitbucket.org')) #找到'bitbucket.org' 下所有键值对 print(config.get('bitbucket.org','compression')) #yes get方法Section下的key对应的value
#增删改操作 import configparser config = configparser.ConfigParser() #生成一个对象 config.read('example.ini') #读文件 config.add_section('yuan') #添加 config.remove_section('bitbucker.org') #删除 config.remove_option('topsecret.server.com','forwardxll') config.set('topsecret.server.com','forwardxll') #修改 config.set('topsecret.server.com','k1','111111') config.set('yuan','k2','22222') config.write('new2.ini','w') #写文件
3，logging------日志模块
日志模块用于记录系统在运行过程中的一些关键信息，logging模块支持日志信息保存到不同的目标域中，以文件或邮件的形式发送。
logging模块下的几种模式/方法
1，debug-----------调试模式（最细致，只有在出错的情况下打印中间结果，用debug）默认情况下不打印debug
2，info--------------信息模式 （必须出现，对程序的正常运行没有影响用info），默认情况下不用info
3，warning-------------警告模式（不会引发程序崩溃，但可能会出现错误，用warning）
4，error----------------错误模式（程序出现错误用error）
5，critical---------------批判模式（程序崩溃时用）
等级由低到高由debug到critical
函数式简单配置
import logging logging.debug('debug message') #调试模式 logging.info('info message') #信息模式 logging.warning('warning message')#警告模式 logging.error('error message') #错误模式 logging.critical('critical message')#批判模式
logging模块分为简单模式（BasicConfig---简单配置就能用）和高级模式（对象模式）
对象模式：可以随意控制往哪里输出日志，且可以控制分别输出在不同的位置。
#简单模式的------BasicConfig import logging logging.basicConfig(level=logging.DEBUG, #DEBUG级别可改 #控制一行输出的内容 format = '%s(asctime)s %(filename)s[line:%(line:%(lineo)d] %(levelname)s %(message)s', detefmt = '%a,%d,%b,%Y %H:%M:%S',#设定时间模式 filename = 'life', #filename的设定就是在文件中打印，不设定会在输出框中输出 filemode='w') #规定写文件 import logging logging.debug('debug sessmage') logging.info('info sessmage') logging.warning('warning sessmage') logging.error('error sessmage') logging.critical('critical sessmage')
配置参数 logging.basicConfig()函数中可通过具体参数来更改logging模块默认行为，可用参数有： filename：用指定的文件名创建FiledHandler，这样日志会被存储在指定的文件中。 filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。 format：指定handler使用的日志显示格式。 datefmt：指定日期时间格式。 level：设置rootlogger（后边会讲解具体概念）的日志级别 stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件(f=open(‘test.log’,’w’))，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。 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用户输出的消息
高级模式
# logger对象配置 import logging logger = logging.getLogger() #实例化一个logger对象 #创建一个handler，用于写入日志文件 fh = logging.FileHandler('文件名',encoding='utf-8') #文件句柄---日志文件操作 #再创建一个handler，用于输出到控制台 ch = logging.StreamHandler() #文件句柄 formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') fh.setFormatter(formatter) #文件句柄 绑 格式 ch.setFormatter(formatter) logger.setLevel(logging.DEBUG) #设置日志等级，默认是warning logger.addHandler(fh) #logger 绑定文件句柄 logger.addHandler(ch) sh = logging.StreamHandler() #屏幕流对象 sh.setFormatter(frozenset) logger.addHandler(sh) logger.info('hello') logging.debug('logger debug message') logging.info('logger info message') logging.warning('logger warning message') logging.error('logger error message') logging.critical('logger critical message')
logging库提供了多个组件：Logger、Handler、Filter、Formatter。Logger对象提供应用程序可直接使用的接口，Handler发送日志到适当的目的地，Filter提供了过滤日志信息的方法，Formatter指定日志显示格式。另外，可以通过：logger.setLevel(logging.Debug)设置级别,当然，也可以通过
fh.setLevel(logging.Debug)单对文件流设置某个级别。
