python_模块
时间模块
import time
#时间戳 计算
print(time.time()) #从1970年到现在的时间（秒数）
#结构化时间
print(time.locatime()) #这是东八区时间，也就是中国时间
time.struct_time(tm_year=2017, tm_mon=3, tm_mday=27, tm_hour=22, tm_min=34, tm_sec=13, tm_wday=0, tm_yday=86, tm_isdst=0)
#全球按经度分为24个时区，每个时区占经度15°。 以本初子午线为中央经线的时区为零时区，由零时区向东、西各分12区，东、西12区都是半时区，共同使用180°经线的地方时。
其实可以算一算：360/15=24。就这么简单。
print(time.gmtime()) #这是国际时间
####################时间类型转换####################
#将结构化时间转换成时间戳
t = time.mktime(time.localtime())
print(t)
#将结构化时间转化成字符串时间
print(time.strftime('%Y---%m-%d %X',time.localtime()))
#将字符串时间转换成结构化时间strptime
print(time.strptime('2017:09:23:12:50:56','%Y:%m:%d:%X'))
# print(time.asctime())#当前时间
time,asctime(time.localtime(111111111))#显示我添加进去的时间
# print(time.ctime())#不填写值，就显示的是当前的时间，加入值就是你写入值的时间
random 模块
#随机的0-1的浮点数 ret = random.random() print(ret) #打印你指定的随机数一位（整数型） print(random.randint(1,3)) #1>=打印的数>=3 print(random.randrange(1,3))#1>=打印的数>3 #随机打印你的列表 print(random.choice([1,'23',[4,5]])) #需要加入到一个[]中，随机打印你列表中的数 #打印1-3的浮点数 print(random.uniform(1,3))
print(random.sample([1,2,3,'8',[3,4,5,6]],3))#打印列表中的随机三个数，（打印几个数是你列表后面定义的数说的算，但是不能超过了列表里面的数）
l = [1,4,56,78,2]
random.shuffle(l) #打乱次序，
print(l)
#很好玩的验证随机
def v_code():
ret = ''
for i in range(4):
nums = random.randint(0,9)
strs = chr(random.randint(65,122))
all = str(random.choice([nums,strs]))
ret+= all
#ret = ''.join([ret,str(all)])
return ret
print(v_code())
hashlib模块
是一个摘要算法，还算不上是加密算法吧！
import hashlib #如果是中文进行加密的话，需要编码， #如果是英文的话，需要在字符串前面加一个b md5 = hashlib.md5() md5.update(b'hello') # md5.update('我是谁'.encode('utf-8')) print(md5.hexdigest()) md5.update('我是谁aa sdffs'.encode('utf-8')) #等于是‘我是谁我是谁’ print(md5.hexdigest())
#md5和sha1是完全一样的， sha1 = hashlib.sha1() sha1.update(b'hello') print(sha1.hexdigest())
当用户的密码非常简单，黑客能够很快的进行破解，那么有一个方法'加盐'可以对用户的密码进行二次加密
sha1 = hashlib.sha1('qasss'.encode('utf-8'))#在sha1（）加上你给用户二次密码的内容然后进行编码。那么和用户的密码算法就又不相同了 sha1.update(b'hello') print(sha1.hexdigest())
sys模块
关于sys模块
sys.path.append() #进行临时性的修改 如果永久修改，需要进入环境变量里面
import sys,time #打印100个# for i in range(100): sys.stdout.write('#') time.sleep(0.1) sys.stdout.flush()
import sys,time
#打印100个#
for i in range(100):
sys.stdout.write('#')
time.sleep(0.1)
sys.stdout.flush()
自己定义的模块，import
下面文件序列图
import sys,os
BASE_DIR = os.path.dirname(os.path.dirname(__file__)) #得到父级目录以上的路径
sys.path.append(BASE_DIR) #临时添加到系统文件中
from web1 import cal
if __name__ == '__main__':
cal.main()
print('ok')
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所指向的文件或者目录的最后修改时间
json模块
json:可以让不同的语言进行数据交换，
json中所有的数据类型都是字符串，字符串都要双引号“” import json dic = {'name':'yang'} #----->将单引号变双引号{"name": "yang"} ----->在给这个字典的外面套上单引号'{"name": "yang"}' i = 8 #------>直接给外面套上str'8' li = [11,22,] #------>'[11,22]' st = 'yang' #----->将单引号变双引号"yang"------>外面套上str'"yang"' dd = json.dumps(dic) print(dd)
#----------------------------序列化
import json
dic={'name':'alvin','age':23,'sex':'male'}
print(type(dic))#<class 'dict'>
j=json.dumps(dic) #封装成json的数据
print(type(j))#<class 'str'>
f=open('序列化对象','w')
f.write(j) #-------------------等价于json.dump(dic,f)
f.close()
#-----------------------------反序列化<br>
import json
f=open('序列化对象')
data=json.loads(f.read())# 等价于data=json.load(f)
1 import json 2 # dic = {'name':'yangxiang'} 3 # dic_str = json.dumps(dic) #先将我的字典转换成字符串 4 # f = open('hello.txt','w') #对文件进行写操作 5 # f.write(dic_str) #将我上面转换的字典添加进去 6 #########可以直接写成 7 # f = open('hello.txt','w') 8 # json.dump(dic,f) 9 10 r_read = open('hello.txt','r') 11 data = json.loads(r_read.read()) #----->json.load(r_read) 12 print(data) 13 print(data['name']) 14 print(type(data))
import json # dic = {'name':'yangxiang'} # dic_str = json.dumps(dic) #先将我的字典转换成字符串 # f = open('hello.txt','w') #对文件进行写操作 # f.write(dic_str) #将我上面转换的字典添加进去 #########可以直接写成 # f = open('hello.txt','w') # json.dump(dic,f) r_read = open('hello.txt','r') data = json.loads(r_read.read()) #----->json.load(r_read) print(data) print(data['name']) print(type(data))
import json with open('json_test','r') as f: data = json.loads(f.read()) print(data) print(data['name'])
sheve模块
import shelve
f = shelve.open(r'shelve.txt') #添加
#添加字典
# f['stu1_info']={'name':'alex','age':'18'}
# f['stu2_info']={'name':'alvin','age':'20'}
# f['school_info']={'website':'oldboyedu.com','city':'beijing'}
#
#
# f.close()
#获取需要的val（）
print(f.get('stu_info')['age'])
xml模块
文件操作.xml
<?xml version="1.0"?> <data> <country name="Liechtenstein"> <rank updated="yes">2</rank> <year>2008</year> <gdppc>141100</gdppc> <neighbor name="Austria" direction="E"/> <neighbor name="Switzerland" direction="W"/> </country> <country name="Singapore"> <rank updated="yes">5</rank> <year>2011</year> <gdppc>59900</gdppc> <neighbor name="Malaysia" direction="N"/> </country> <country name="Panama"> <rank updated="yes">69</rank> <year>2011</year> <gdppc>13600</gdppc> <neighbor name="Costa Rica" direction="W"/> <neighbor name="Colombia" direction="E"/> </country> </data>
代码块
import xml.etree.ElementTree as ET #as将引入的模块重新命名
tree = ET.parse('xml_lesson1') #parse（）:解析文件 读文件
root = tree.getroot() #getroot()获取根节点
# print(root) #获取的是根的内存地址
# print(root.tag) #获取根的标签
# for i in root:
# # print('----->',i.tag) #遍历跟标签，获取的是它的子节点的标签
# # print('____---',i.attrib) #attrib:获取遍历出来标签的属性
#
# for j in i:
# # print(j.tag)
# print(j.text) #-----text:获取遍历后，标签里面的元素
#-----------------------------
#查询Search
#只遍历某一个标签‘year’
# for i in root.iter('year'): #iter:获取你遍历的某个标签
# print(i.text,i.tag)
#
# #通过遍历根标签，在year的父级标签上查找year
# for i in root:
# for j in i.iter('year'):
# print('---->',j.tag)
# print(j.text)
#upadd(添加) 修改元素
# for node in root.iter('year'):
# node_new = int(node.text) + 1 #给year标签里面的元素做一个加1的操作(进行操作时要将元素转换成int型)
# node.text = str(node_new) #在将写的元素赋给node.text （赋值时要先转换成str型）
# node.set('updated','123') #给遍历的标签添加属性值使用set方法，这个set方法不是set集合
# # print(node.text,node.attrib)
#
# tree.write('abd.xml')
#删除node
for country in root.findall('country'): #遍历所有的country
# 找到country下的rank的元素,标签中的元素都是字符串，所以在操作的时候要转成整数型
rank = int(country.find('rank').text)
# print(rank)
if rank > 50:
root.remove(country)
# print(i.tag)
tree.write('aaa.xml')
使用代码，添加新的xml文件
import xml.etree.ElementTree as ET #as将引入的模块重新命名
new_xml = ET.Element('Newlist') #创建根节点<NewList></NewList>
#1-ET.SubElement:创建子节点，2-创建在谁的节点下，3-创建的名称，4-创建属性
name = ET.SubElement(new_xml,'name',attrib = {'enrolled':'yes'})
age = ET.SubElement(name,'age',attrib = {'checked':'no'})
sex = ET.SubElement(name,'sex',)
#给创建的标签写入元素
sex.text = str('male')
name2 = ET.SubElement(new_xml,'name2',attrib = {'upname2':'yes'})
age2 = ET.SubElement(name2,'age2',attrib = {'checked':'no'})
sex2 = ET.SubElement(name2,'sex2',)
sex2.text = str('male')
#*************************************************************
#最重要的，这个是创建好文件之后，生成文件的代码。
et = ET.ElementTree(new_xml) #生成文档对象
et.write('test.xml',encoding='utf-8',xml_declaration=True) #写入一个新的文件
ET.dump(new_xml) #打印生成的格式
re模块
| 语法 | 意义 | 说明 |
| "." | 任意字符 | |
| "^" | 字符串开始 | '^hello'匹配'helloworld'而不匹配'aaaahellobbb' |
| "$" | 字符串结尾 | 与上同理 |
| "*" | 0 个或多个字符（贪婪匹配） | <*>匹配<title>chinaunix</title> |
| "+" | 1 个或多个字符（贪婪匹配） | 与上同理 |
| "?" | 0 个或多个字符（贪婪匹配） | 与上同理 |
| *?,+?,?? | 以上三个取第一个匹配结果（非贪婪匹配） | <*>匹配<title> |
| {m,n} | 对于前一个字符重复m到n次，{m}亦可 | a{6}匹配6个a、a{2,4}匹配2到4个a |
| {m,n}? | 对于前一个字符重复m到n次，并取尽可能少 | ‘aaaaaa’中a{2,4}只会匹配2个 |
| "\\" | 特殊字符转义或者特殊序列 | |
| [] | 表示一个字符集 | [0-9]、[a-z]、[A-Z]、[^0] |
| "|" | 或 | A|B,或运算 |
| (...) | 匹配括号中任意表达式 | |
| (?#...) | 注释，可忽略 | |
| (?=...) | Matches if ... matches next, but doesn't consume the string. | '(?=test)' 在hellotest中匹配hello |
| (?!...) | Matches if ... doesn't match next. | '(?!=test)' 若hello后面不为test，匹配hello |
| (?<=...) | Matches if preceded by ... (must be fixed length). | '(?<=hello)test' 在hellotest中匹配test |
| (?<!...) | Matches if not preceded by ... (must be fixed length). | '(?<!hello)test' 在hellotest中不匹配test |
| 特殊序列符号 | 意义 |
| \A | 只在字符串开始进行匹配 |
| \Z | 只在字符串结尾进行匹配 |
| \b | 匹配位于开始或结尾的空字符串 |
| \B | 匹配不位于开始或结尾的空字符串 |
| \d | 相当于[0-9] |
| \D | 相当于[^0-9] |
| \s | 匹配任意空白字符:[\t\n\r\r\v] |
| \S | 匹配任意非空白字符:[^\t\n\r\r\v] |
| \w | 匹配任意数字和字母:[a-zA-Z0-9] |
| \W | 匹配任意非数字和字母:[^a-zA-Z0-9] |
1 import re 2 3 # re.findall(格式，字符串内容) #找到所有的匹配元素，返回列表 4 5 6 #.:匹配除了\n以外的任意符号 7 print(re.findall('a.b','asb')) 8 #+：指的是1-n个 9 print(re.findall('as+','assssdd')) 10 print(re.findall('a.+d','abcgd')) 11 #*：指的是0-n个 12 print(re.findall('s*','adffsssss')) 13 #？：值的是0-1个 14 print(re.findall('s?','adffs')) 15 16 #^:从字符串开始的位置匹配 17 print(re.findall('^y','yang')) 18 19 #$:从字符串的结尾匹配 20 print(re.findall('g$','yang')) 21 22 #* + ? {} :重复 23 #{}：可以在里面写入要获取的位数，1：’最少获取到n个‘。 3’就获取3位‘ 24 print(re.findall('[0-9]{5}','ddd53453425jl3454255lj34535jl54353ljjj'))#获取字符串中4位数字在一起的 25 26 27 #贪婪匹配 28 #获取所有的数字 29 print(re.findall('\d+','aa2222kk44444w2224h45345')) 30 31 #非贪婪匹配 32 33 print(re.findall('\d+?','aa2222kk44444w2224h45345')) 34 print(re.findall('(a\d)','aa2222kk44444w2224h45345')) 35 36 #字符集 []:取一个或者的意思,但是找到第一个这种类型的还会继续往下找 37 print(re.findall('a[bc]d','hasdacdddabd')) 38 39 #注意：* , + . 等元字符都是普通的符号，- ^ \ 40 print(re.findall('[0-9]+','dssd4234jjj223')) #获取的是是一个列表的数组 41 print(re.findall("[a-z]+","dashj342jhg234")) #获取的是一个字母的组合 42 print(re.findall("[^\d]+","d2a2fhj87fgj")) #获取不是数字的的内容 43 44 #（）分组 45 print(re.findall('(ad)+','addd')) #['ad'] 46 print(re.findall("(ad)+yuan","adddyuangfsdui")) #[] 47 print(re.findall("(?:ad)+yuan","adadyuangfsdui"))#['adadyuan'] 48 print(re.findall("(?:\d)+yuan","adad678423yuang4234fsdui"))#['678423yuang'] 49 50 #命名分组********* 51 ''' 52 ?P<name> 53 通过符号组名称name可以访问类似于常规的括号，但由组匹配的子字符串。 54 组名必须是有效的 Python 标识符，并且每个组名必须在正则表达式内只有一次定义。 55 海员象征性的组织也是带编号的组，就好像组未被命名。 56 ''' 57 ret8=re.search(r"(?P<A>\w+)\\aticles\\(?P<id>\d{4})",r"yuan\aticles\1234") #######yuan\aticles\1234 58 print(ret8.group('A')) #yuan 59 ret7=re.search(r"a\\nb",r"a\nb")#a\nb 60 print(ret7.group()) 61 62 # | :或 63 print(re.findall("www\.(?:oldboy|baidu)\.com","www.oldboy.com"))#['www.oldboy.com'] 64 65 #\:转义 66 ''' 67 1.后面加一个元字符使其变成普通符号\. \* 68 2.将一些普通符号变成特殊符号 比如：\d \w 69 ''' 70 print(re.findall("\d+\.?\d*\*\d+\.?\d*","-2*6+7*45+1.456*3-8/4"))#['2*6', '7*45', '1.456*3'] 71 print(re.findall("\w","$da@s4 234"))#\w:匹配任意数字和字母:[a-zA-Z0-9] 72 print(re.findall("a\sb","a badf"))#\s：匹配任意空白字符:[\t\n\r\r\v] 73 ''' 74 结果： 75 ['2*6', '7*45', '1.456*3'] 76 ['d', 'a', 's', '4', '2', '3', '4'] 77 ['a b'] 78 ''' 79 print(re.findall(r"\bI","hello I am LIA")) #加上r就只用一个\ 不然就\\ 80 print(re.findall("\dI","hello 654I am LIA")) 81 print(re.findall(r"c\\l","abc\l")) 82 ''' 83 结果： 84 ['I'] 85 ['4I'] 86 ['c\\l'] 87 ''' 88 89 # re的方法 90 91 #re.findall():找到 RE 匹配的所有子串，并把它们作为一个列表返回。这个匹配是从左到右有序地返回。如果无匹配，返回空列表。 92 # s=re.finditer("\d+","ad324das32") 93 s=re.finditer("[^\d]+","ad324das32sss") 94 print(s)#<callable_iterator object at 0x0000000000C07048>是一个可迭代的 95 print(next(s).group()) 96 print(next(s).group()) 97 print(next(s).group()) 98 ''' 99 结果： 100 <callable_iterator object at 0x0000000000BD70F0> 101 ad 102 das 103 sss 104 ''' 105 106 #search： 只匹配第一个结果 107 ret=re.search("\d+","djksf34asd3") 108 print(ret.group()) 109 ''' 110 结果： 111 34 112 ''' 113 114 #match:只在字符串开始的位置匹配 115 ret=re.match("\d+","423djksf34asd3") 116 print(ret.group()) 117 ''' 118 结果： 119 423 120 ''' 121 122 #split 分割 123 s2=re.split("\d+","fhd3245jskf54skf453sd",2) #以数字作为分隔 124 print(s2) 125 ret3=re.split("l","hello yuan") 126 print(ret3) 127 ''' 128 结果： 129 ['fhd', 'jskf', 'skf453sd'] 130 ['he','','o yuan'] 131 ''' 132 133 # sub:替换 ('旧值','新值'，'字符串','替换的次数') 134 ret4=re.sub("\d+","A","hello 234jkhh23",1) 135 print(ret4) 136 #subn:替换 直接给你全部替换了，不需要输入次数，打印的时候会提示你替换了几次 137 ret4=re.subn("\d+","A","hello 234jkhh23") 138 print(ret4) 139 ''' 140 结果： 141 hello Ajkhh23 142 ('hello AjkhhA', 2) 143 ''' 144 # compile:编译方法 145 c=re.compile("\d+") 146 ret5=c.findall("hello32world53") #== re.findall("\d+","hello32world53") 147 print(ret5) 148 ''' 149 结果： 150 ['32', '53'] 151 '''
logging模块
基本用法
import logging logging.debug('debug message') logging.info('info message') logging.warning('warning message') logging.error('error message') logging.critical('critical message') ''' 输出： WARNING:root:warning message ERROR:root:error message CRITICAL:root:critical message ''' #日志等级 debug info warning（默认） error critical
灵活配置日志级别，日志格式，输出位置
import logging logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s', datefmt='%a, %d %b %Y %H:%M:%S', filename='/tmp/test.log', filemode='w') logging.debug('debug message') logging.info('info message') logging.warning('warning message') logging.error('error message') logging.critical('critical message') ''' 查看输出： cat /tmp/test.log Mon, 05 May 2014 16:29:53 test_logging.py[line:9] DEBUG debug message Mon, 05 May 2014 16:29:53 test_logging.py[line:10] INFO info message Mon, 05 May 2014 16:29:53 test_logging.py[line:11] WARNING warning message Mon, 05 May 2014 16:29:53 test_logging.py[line:12] ERROR error message Mon, 05 May 2014 16:29:53 test_logging.py[line:13] CRITICAL critical message '''
1 format参数中可能用到的格式化串： 2 %(name)s Logger的名字 3 %(levelno)s 数字形式的日志级别 4 %(levelname)s 文本形式的日志级别 5 %(pathname)s 调用日志输出函数的模块的完整路径名，可能没有 6 %(filename)s 调用日志输出函数的模块的文件名 7 %(module)s 调用日志输出函数的模块名 8 %(funcName)s 调用日志输出函数的函数名 9 %(lineno)d 调用日志输出函数的语句所在的代码行 10 %(created)f 当前时间，用UNIX标准的表示时间的浮 点数表示 11 %(relativeCreated)d 输出日志信息时的，自Logger创建以 来的毫秒数 12 %(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒 13 %(thread)d 线程ID。可能没有 14 %(threadName)s 线程名。可能没有 15 %(process)d 进程ID。可能没有 16 %(message)s用户输出的消息
logger对象
上述几个例子中我们了解到了logging.debug()、logging.info()、logging.warning()、logging.error()、logging.critical()（分别用以记录不同级别的日志信息），logging.basicConfig()（用默认日志格式（Formatter）为日志系统建立一个默认的流处理器（StreamHandler），设置基础配置（如日志级别等）并加到root logger（根Logger）中）这几个logging模块级别的函数，另外还有一个模块级别的函数是logging.getLogger([name])（返回一个logger对象，如果没有指定名字将返回root logger）
import logging logger = logging.getLogger() # 创建一个handler，用于写入日志文件 fh = logging.FileHandler('test.log') # 再创建一个handler，用于输出到控制台 ch = logging.StreamHandler() formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') fh.setFormatter(formatter) ch.setFormatter(formatter) logger.addHandler(fh) #logger对象可以添加多个fh和ch对象 logger.addHandler(ch) logger.debug('logger debug message') logger.info('logger info message') logger.warning('logger warning message') logger.error('logger error message') logger.critical('logger critical message')
先简单介绍一下，logging库提供了多个组件：Logger、Handler、Filter、Formatter。Logger对象提供应用程序可直接使用的接口，Handler发送日志到适当的目的地，Filter提供了过滤日志信息的方法，Formatter指定日志显示格式。
(1)
Logger是一个树形层级结构，输出信息之前都要获得一个Logger（如果没有显示的获取则自动创建并使用root Logger，如第一个例子所示）。
logger = logging.getLogger()返回一个默认的Logger也即root Logger，并应用默认的日志级别、Handler和Formatter设置。
当然也可以通过Logger.setLevel(lel)指定最低的日志级别，可用的日志级别有logging.DEBUG、logging.INFO、logging.WARNING、logging.ERROR、logging.CRITICAL。
Logger.debug()、Logger.info()、Logger.warning()、Logger.error()、Logger.critical()输出不同级别的日志，只有日志等级大于或等于设置的日志级别的日志才会被输出。
logger.debug('logger debug message') logger.info('logger info message') logger.warning('logger warning message') logger.error('logger error message') logger.critical('logger critical message') ''' 只输出了 2014-05-06 12:54:43,222 - root - WARNING - logger warning message 2014-05-06 12:54:43,223 - root - ERROR - logger error message 2014-05-06 12:54:43,224 - root - CRITICAL - logger critical message '''
从这个输出可以看出logger = logging.getLogger()返回的Logger名为root。这里没有用logger.setLevel(logging.Debug)显示的为logger设置日志级别，所以使用默认的日志级别WARNIING，故结果只输出了大于等于WARNIING级别的信息。
如果我们再创建两个logger对象：
################################################## logger1 = logging.getLogger('mylogger') logger1.setLevel(logging.DEBUG) logger2 = logging.getLogger('mylogger') logger2.setLevel(logging.INFO) logger1.addHandler(fh) logger1.addHandler(ch) logger2.addHandler(fh) logger2.addHandler(ch) logger1.debug('logger1 debug message') logger1.info('logger1 info message') logger1.warning('logger1 warning message') logger1.error('logger1 error message') logger1.critical('logger1 critical message') logger2.debug('logger2 debug message') logger2.info('logger2 info message') logger2.warning('logger2 warning message') logger2.error('logger2 error message') logger2.critical('logger2 critical message')
1 #coding:utf-8 2 import logging 3 4 # 创建一个logger 5 logger = logging.getLogger() 6 7 logger1 = logging.getLogger('mylogger') 8 logger1.setLevel(logging.DEBUG) 9 10 logger2 = logging.getLogger('mylogger') 11 logger2.setLevel(logging.INFO) 12 13 logger3 = logging.getLogger('mylogger.child1') 14 logger3.setLevel(logging.WARNING) 15 16 logger4 = logging.getLogger('mylogger.child1.child2') 17 logger4.setLevel(logging.DEBUG) 18 19 logger5 = logging.getLogger('mylogger.child1.child2.child3') 20 logger5.setLevel(logging.DEBUG) 21 22 # 创建一个handler，用于写入日志文件 23 fh = logging.FileHandler('/tmp/test.log') 24 25 # 再创建一个handler，用于输出到控制台 26 ch = logging.StreamHandler() 27 28 # 定义handler的输出格式formatter 29 formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') 30 fh.setFormatter(formatter) 31 ch.setFormatter(formatter) 32 33 #定义一个filter 34 #filter = logging.Filter('mylogger.child1.child2') 35 #fh.addFilter(filter) 36 37 # 给logger添加handler 38 #logger.addFilter(filter) 39 logger.addHandler(fh) 40 logger.addHandler(ch) 41 42 #logger1.addFilter(filter) 43 logger1.addHandler(fh) 44 logger1.addHandler(ch) 45 46 logger2.addHandler(fh) 47 logger2.addHandler(ch) 48 49 #logger3.addFilter(filter) 50 logger3.addHandler(fh) 51 logger3.addHandler(ch) 52 53 #logger4.addFilter(filter) 54 logger4.addHandler(fh) 55 logger4.addHandler(ch) 56 57 logger5.addHandler(fh) 58 logger5.addHandler(ch) 59 60 # 记录一条日志 61 logger.debug('logger debug message') 62 logger.info('logger info message') 63 logger.warning('logger warning message') 64 logger.error('logger error message') 65 logger.critical('logger critical message') 66 67 logger1.debug('logger1 debug message') 68 logger1.info('logger1 info message') 69 logger1.warning('logger1 warning message') 70 logger1.error('logger1 error message') 71 logger1.critical('logger1 critical message') 72 73 logger2.debug('logger2 debug message') 74 logger2.info('logger2 info message') 75 logger2.warning('logger2 warning message') 76 logger2.error('logger2 error message') 77 logger2.critical('logger2 critical message') 78 79 logger3.debug('logger3 debug message') 80 logger3.info('logger3 info message') 81 logger3.warning('logger3 warning message') 82 logger3.error('logger3 error message') 83 logger3.critical('logger3 critical message') 84 85 logger4.debug('logger4 debug message') 86 logger4.info('logger4 info message') 87 logger4.warning('logger4 warning message') 88 logger4.error('logger4 error message') 89 logger4.critical('logger4 critical message') 90 91 logger5.debug('logger5 debug message') 92 logger5.info('logger5 info message') 93 logger5.warning('logger5 warning message') 94 logger5.error('logger5 error message') 95 logger5.critical('logger5 critical message')
浙公网安备 33010602011771号