目录
常用模块
time与datetime模块
random模块
os模块
sys模块
shutil模块
json&pickle模块
shelve模块
xml模块
configparser模块
hashlib模块
suprocess模块
logging模块
re模块
PrettyTable模块
图片相关的模块pillow
time与datetime模块
python中通常有以下几种方式来表示时间：
1）、时间戳(timestamp)：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。
2）、格式化的时间字符串(Format String)
3）、结构化的时间(struct_time)：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时)
import time #-----------打印当前时间，三种形式 print(time.time()) #时间戳格式 print(time.strftime("%Y-%M-%d %X")) #格式化的时间字符串:"2020-07-30 15:07:59" print(time.localtime()) #本地时区的struct_time print(time.gmtime()) #UTC时区的struct_time
其中计算机认识的时间只能是'时间戳'格式，而程序员可处理的或者说人类能看懂的时间有: '格式化的时间字符串'，'结构化的时间' ，于是有了下图的转换关系
import time #按图一转换时间 #localtime([secs]). # 将一个时间戳转换为当前时区的struct_time。secs参数未提供，则以当前时间为准。 # gmtime([secs]) 和localtime()方法类似，gmtime()方法是将一个时间戳转换为UTC时区（0时区）的struct_time。 res=time.time() time.localtime(res) print(res) print(time.localtime(res)) """ 打印结果 1585553574.863616 time.struct_time(tm_year=2020, tm_mon=3, tm_mday=30, tm_hour=15, tm_min=32, tm_sec=54, tm_wday=0, tm_yday=90, tm_isdst=0) """ #mktime(t) 将一个struct_time转化为时间戳。 local_time=time.localtime() print(time.mktime(local_time)) ''' #打印结果 1585553574.0 ''' # strftime(format[, t]) : 把一个代表时间的元组或者struct_time（如由time.localtime()和time.gmtime()返回）转化为格式化的时间字符串。如果t未指定，将传入time.localtime()。如果元组中任何一个元素越界，ValueError的错误将会被抛出。 print(time.strftime("%Y-%m-%d %X", time.localtime())) #2020-03-30 15:37:41 # time.strptime(string[, format]) # 把一个格式化时间字符串转化为struct_time。实际上它和strftime()是逆操作。 print(time.strptime('2020-03-30 15:37:41', '%Y-%m-%d %X')) # 打印结果为：time.struct_time(tm_year=2020, tm_mon=3, tm_mday=30, tm_hour=15, tm_min=37, tm_sec=41, tm_wday=0, tm_yday=90, 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())#print(time.asctime()) #Mon Mar 30 15:48:32 2020 # ctime([secs]) : 把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。如果参数未给或者为 # None的时候，将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。 print(time.ctime()) # Mon Mar 30 15:49:11 2020 print(time.ctime(time.time())) # Mon Mar 30 15:49:11 2020
#-------------其他用法 time.sleep(sec) #线程推迟指定的时间运行，单位为秒。#需要掌握
#时间加减 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(weeks=1)) #当前时间+1周 # 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)) #时间替换
#方法二：
import time,datetime
s1="2016-08-19 12:47:03"
t1=time.strptime(s1,"%Y-%m-%d %X")
k1=time.mktime(t1)
#转换成时间戳后加7*24*60*60
k2=k1+7*86400
#再转换成格式化字符串
print(datetime.datetime.fromtimestamp(k2))
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_str(size=6): res="" for i in range(size): s1=chr(random.randint(65,90)) s2=str(random.randint(0,9)) res+=random.choice([s1,s2]) print(res) make_str()
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.walk('dirname') 可以创建一个生成器，用以生成所要查找的目录及其子目录下的所有文件。 os.remove() 删除一个文件 os.rename("oldname","newname") 重命名文件/目录 os.stat('path/filename') 获取文件/目录信息 os.sep 输出操作系统特定的路径分隔符，win下为"\",Linux下为"/" os.linesep 输出当前平台使用的行终止符，win下为" ",Linux下为" " os.pathsep 输出用于分割文件路径的字符串 win下为;,Linux下为:
os.popen(sys_cmd) 可以将系统命令执行结果保存至变量 os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix' os.system("bash command") 运行shell命令，直接显示 os.environ 获取系统环境变量
os.getpid() #查看当前进程进程号
os.getppid() #查看当前进程的父进程进程号 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.getcwd()和os.chdir("dirname") 注意：windows上路径要加双斜杠或在路径前加r //代码 import os print(os.getcwd()) #获取当前工作目录，即当前Python脚本工作的目录路径 os.chdir("D:\pycharm_pj\Day4") #改变当前脚本的工作目录，相当于shell下的cd print(os.getcwd()) os.chdir(r"D:pycharm_pjDay5") print(os.getcwd()) //执行结果 D:pycharm_pjDay5 D:pycharm_pjDay4 D:pycharm_pjDay5
//代码 import os os.makedirs("D:\pycharm_pj\a\b")
//代码 import os print(os.listdir(r"D:pycharm_pjDay5")) #列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表的形式打印 //执行结果 ['module', 'os_test.py', 'package_tests.py', 'random_test.py', 'time_test.py', '__init__.py', '__pycache__']
//代码 import os g=os.walk(r"E:oldboymy_codegrep-rla") #得到一个生成器 print(g) for i in g: print(i) //打印结果（元组中第一个元素是搜索的目录，第二个元素是搜索目录下的子目录，第三个是搜索目录下的文件） ('E:\oldboy\my_code\grep-rl\a', ['b', 'c'], ['a.txt']) ('E:\oldboy\my_code\grep-rl\a\b', ['d'], ['b.txt']) ('E:\oldboy\my_code\grep-rl\a\b\d', [], ['d.txt']) ('E:\oldboy\my_code\grep-rl\a\c', ['e'], ['c.txt']) ('E:\oldboy\my_code\grep-rl\a\c\e', [], ['e.txt']) 示例：（取得目录下的所有文件的绝对路径，包括子目录） //代码 import os g=os.walk(r"E:oldboymy_codegrep-rla") #得到一个生成器 # print(g) for pardir,_,files in g: for file in files: abs_path=r"{}\{}".format(pardir,file) print(abs_path) #打印E:oldboymy_codegrep-rla下所有文件的绝对路径 //执行结果 E:oldboymy_codegrep-rla\a.txt E:oldboymy_codegrep-rla\b.txt E:oldboymy_codegrep-rlad\d.txt E:oldboymy_codegrep-rlac\c.txt E:oldboymy_codegrep-rlace\e.txt
//代码 os.remove(r"D:pycharm_pjDay5modulemain.py") #删除一个文件main.py
//代码 #重命名文件或目录 os.rename(r"D:pycharm_pjDay5 andom_test.py",r"D:pycharm_pjDay5 andom_tt.py")
//代码 print(os.path.abspath(__file__)) #获取当前文件的绝对路径 //执行结果 D:pycharm_pjDay5os_test.py
#os.path.split(path) #将path分割成目录和文件名的元组返回 //代码 print(os.path.split(r"D:pycharm_pjDay5 andom_tt.py")) //执行结果 ('D:\pycharm_pj\Day5', 'random_tt.py')
//代码 print(os.path.dirname(__file__)) //执行结果 D:/pycharm_pj/Day5
#os.path.basename(path) #返回path最后的文件名。 //代码 print(os.path.basename(__file__)) //执行结果 os_test.py
#os.path.isfile(path) #如果path是一个存在的文件，返回True；否则返回False //代码 print(os.path.isfile(r"D:pycharm_pjDay5 andom_tt.py")) //执行结果 True
#os.path.isdir(path) #如果path是一个存在的目录，返回True；否则返回False //代码 print(os.path.isdir(r"D:pycharm_pjDay5 andom_tt.py")) #file print(os.path.isdir(r"D:pycharm_pjDay5")) #dir //执行结果 False True
#os.path.join(path1[,path2[,...]]) #将多个路径组合后返回，第一个绝对路径之前的参数将被忽略 //代码 print(os.path.join(r". andom_tt.py",r".modulemodule_test.py",r"D:pycharm_pjDay5 andom_tt.py")) print(os.path.join(r"D:",r"pycharm_pj",r"Day5 andom_tt.py")) #拼接 //执行结果 D:pycharm_pjDay5 andom_tt.py D:pycharm_pjDay5 andom_tt.py
#os.system //代码 import os cmd_dir=os.system("dir") #只执行命令，不保存结果 print("-->",cmd_dir) #print(os.system("ipconfig /all")) //执行结果（可以看到命令是执行了，但是没有保存下来
os.popen(可以将结果保存至变量则)： //代码1 import os cmd_dir=os.popen("dir") print("-->",cmd_dir) //执行结果 --><os._wrap_close object at 0x000000000104EDA0> 这样执行完，打印的是内存的对象地址（并不是我们想要的打印当前目录；如果想打印当前目录；再加一个.read()则cmd_dir=os.popen("dir").read()） //代码2 import os cmd_dir=os.popen("dir").read() print("-->",cmd_dir) //执行结果 --> 驱动器 E 中的卷是 新加卷 卷的序列号是 98D0-7B36 E:oldboyclasswork 的目录 2020/03/30 19:41 <DIR> . 2020/03/30 19:41 <DIR> .. 2020/03/27 22:43 <DIR> aaa 2020/03/30 19:40 546 class_test.py 2020/03/26 16:20 62 file.txt 2020/03/26 16:20 0 file.txt.swap 2020/03/30 11:37 <DIR> reader_system 2020/03/30 09:52 8,378 reader_system.zip 2020/03/29 19:29 <DIR> read_sys1 2020/03/30 19:22 2,112 show.py 2020/03/30 15:04 <DIR> show_money 2020/03/11 14:54 138 __init__.py 2020/03/27 22:11 <DIR> __pycache__ 2020/03/30 19:41 <DIR> 常用模块 6 个文件 11,236 字节 8 个目录 191,578,996,736 可用字节
sys模块
sys.argv 命令行参数List，第一个元素是程序本身路径
sys.exit(n) 退出程序，正常退出时exit(0)
sys.version 获取Python解释程序的版本信息
sys.maxint 最大的Int值
sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform 返回操作系统平台名称
//代码 #!/usr/bin/env python3 #encodind:utf-8 import sys #sys.argv[0] 获取脚本名 #sys.argv[1] 获取第一个参数 print('脚本名称:{}'.format(sys.argv[0])) for i in sys.argv: if i == sys.argv[0]: continue print('参数为:',i) print('总参数个数:{}'.format(len(sys.argv)-1) //执行 [root@python python]# ./sysargv.py s1 s2 s3 s4 s5 脚本名称:./sysargv.py 参数为: s1 参数为: s2 参数为: s3 参数为: s4 参数为: s5 总参数个数:5
sys.path.append(dir_path) #将目录路径加入到模块的搜索路径列表中 sys.path.insert(0,dir_path) #将目录路径加入到模块的搜索路径列表中 #两者区别 append是将目录路径追加到搜索路径列表最后 insert可以指定加入的索引
#=========知识储备========== #进度条的效果 [# ] [## ] [### ] [#### ] #指定宽度 print('[%-15s]' %'#') print('[%-15s]' %'##') print('[%-15s]' %'###') print('[%-15s]' %'####') #打印% print('%s%%' %(100)) #第二个%号代表取消第一个%的特殊意义 #可传参来控制宽度 print("[%-50s]" %'#') #左对齐50宽度，不够的空格填充 print("[%-50s]" %'##') print("[%-50s]" %'###') ################################# #打印进度条 import time def progress(percent): res = int(50 * percent) * '#' print(' [%-50s] %d%%' % (res, int(100 * percent)), end='') recv_size=0 total_size=1025011 while recv_size < total_size: time.sleep(0.01) # 下载了1024个字节的数据 all_size=total_size-recv_size if all_size > 1024: recv_size+=1024 # recv_size=2048 else: recv_size+=all_size # 打印进度条 percent = recv_size / total_size # 1024 / 333333 progress(percent)
shutil模块
高级的 文件、文件夹、压缩包 处理模块
shutil.copyfileobj(fsrc, fdst[, length]) 将文件内容拷贝到另一个文件中
import shutil
shutil.copyfileobj(open(r'E:oldboyclassworkfile.txt','r'), open(r"E:oldboyclassworkfile.txt.swap", 'w')) #路径都可以是变量
shutil.copyfile(src, dst) 拷贝文件
import shutil shutil.copyfile(r"E:oldboyclassworkfile.txt",r"E:oldboyclassworkfile.txt.swap") #shutil.copyfile(src_path,des_path)
shutil.copymode(src, dst) 仅拷贝权限。内容、组、用户均不变
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.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()
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()
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内置的数据类型对应如下：
import json dic = {'name': 'alvin', 'age': 23, 'sex': 'male'} print(type(dic)) # <class 'dict'> j = json.dumps(dic) print(j,type(j)) # <class 'str'> f = open('file.json', 'w') f.write(j) # -------------------等价于json.dump(dic,f) f.close() # -----------------------------反序列化<br> f = open('file.json') data = json.loads(f.read()) # 等价于data=json.load(f) f.close()
print(data,type(data)) #<class 'dict'> #执行结果 ''' <class 'dict'> {"name": "alvin", "age": 23, "sex": "male"} <class 'str'> {'name': 'alvin', 'age': 23, 'sex': 'male'} <class 'dict'> '''
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
# 在python解释器2.7与3.6之后都可以json.loads(bytes类型)，但唯独3.5不可以 >>> import json >>> json.loads(b'{"a":111}') Traceback (most recent call last): File "<stdin>", line 1, in <module> File "/Users/linhaifeng/anaconda3/lib/python3.5/json/__init__.py", line 312, in loads s.__class__.__name__)) TypeError: the JSON object must be str, not 'bytes'
示例：
import json # 序列化 json_res=json.dumps([1,'aaa',True,False]) # print(json_res,type(json_res)) # "[1, "aaa", true, false]" # 反序列化 l=json.loads(json_res) print(l,type(l)) #[1, 'aaa', True, False] <class 'list'>
用法示例：
import json 序列化的结果写入文件的复杂方法 json_res=json.dumps([1,'aaa',True,False]) # print(json_res,type(json_res)) # "[1, "aaa", true, false]" with open('test.json',mode='wt',encoding='utf-8') as f: f.write(json_res) 将序列化的结果写入文件的简单方法 with open('test.json',mode='wt',encoding='utf-8') as f: json.dump([1,'aaa',True,False],f)
# 从文件读取json格式的字符串进行反序列化操作的复杂方法 with open('test.json',mode='rt',encoding='utf-8') as f: json_res=f.read() l=json.loads(json_res) print(l,type(l)) # 从文件读取json格式的字符串进行反序列化操作的简单方法 with open('test.json',mode='rt',encoding='utf-8') as f: l=json.load(f) print(l,type(l))
关于dump序列化中文内容到文件想要显示任为中文，dump&dumps选项ensure_ascii=False
import json data="爱我中华" with open("file.txt","w",encoding="utf-8") as f: json.dump(data,f) #这个时候显示在文件中为二进制"u7231u6211u4e2du534e" =========================================== #想要在文件中显示为汉字,使用ensure_ascii=False选项 import json data="爱我中华" with open("file.txt","w",encoding="utf-8") as f: json.dump(data,f,ensure_ascii=False) #这时显示为"爱我中华"
了解：
# 一.什么是猴子补丁? 猴子补丁的核心就是用自己的代码替换所用模块的源代码，详细地如下 1，这个词原来为Guerrilla Patch，杂牌军、游击队，说明这部分不是原装的，在英文里guerilla发音和gorllia(猩猩)相似，再后来就写了monkey(猴子)。 2，还有一种解释是说由于这种方式将原来的代码弄乱了(messing with it)，在英文里叫monkeying about(顽皮的)，所以叫做Monkey Patch。 # 二. 猴子补丁的功能(一切皆对象) 1.拥有在模块运行时替换的功能, 例如: 一个函数对象赋值给另外一个函数对象(把函数原本的执行的功能给替换了) class Monkey: def hello(self): print('hello') def world(self): print('world') def other_func(): print("from other_func") monkey = Monkey() monkey.hello = monkey.world monkey.hello() monkey.world = other_func monkey.world() # 三.monkey patch的应用场景 如果我们的程序中已经基于json模块编写了大量代码了，发现有一个模块ujson比它性能更高， 但用法一样，我们肯定不会想所有的代码都换成ujson.dumps或者ujson.loads,那我们可能 会想到这么做 import ujson as json，但是这么做的需要每个文件都重新导入一下，维护成本依然很高 此时我们就可以用到猴子补丁了 只需要在入口处加上 , 只需要在入口加上: import json import ujson def monkey_patch_json(): json.__name__ = 'ujson' json.dumps = ujson.dumps json.loads = ujson.loads monkey_patch_json() # 之所以在入口处加，是因为模块在导入一次后，后续的导入便直接引用第一次的成果 #其实这种场景也比较多, 比如我们引用团队通用库里的一个模块, 又想丰富模块的功能, 除了继承之外也可以考虑用Monkey Patch.采用猴子补丁之后，如果发现ujson不符合预期，那也可以快速撤掉补丁。个人感觉Monkey Patch带了便利的同时也有搞乱源代码的风险!
pickle模块(rb模式读，rw模式写)
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('file.txt', 'wb') # 注意是w是写入str,wb是写入bytes,j是'bytes' f.write(j) # -------------------等价于pickle.dump(dic,f) f.close() # -------------------------反序列化 f = open('file.txt', 'rb') data = pickle.loads(f.read()) # 等价于data=pickle.load(f) print(data['age']) #23
# coding:utf-8 import pickle with open('a.pkl',mode='wb') as f: # 一：在python3中执行的序列化操作如何兼容python2 # python2不支持protocol>2，默认python3中protocol=4 # 所以在python3中dump操作应该指定protocol=2 pickle.dump('你好啊',f,protocol=2) with open('a.pkl', mode='rb') as f: # 二：python2中反序列化才能正常使用 res=pickle.load(f) print(res)
Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。
shelve模块
shelve模块比pickle模块简单，只有一个open函数，返回类似字典的对象，可读可写;key必须为字符串，而值可以是python所支持的数据类型
import shelve f=shelve.open(r'sheve.txt') # f['stu1_info']={'name':'egon','age':18,'hobby':['piao','smoking','drinking']} # f['stu2_info']={'name':'gangdan','age':53} # f['school_info']={'website':'http://www.pypy.org','city':'beijing'} print(f['stu1_info']['hobby']) f.close()
xml模块
xml是实现不同语言或程序之间进行数据交换的协议，跟json差不多，但json使用起来更简单，不过，古时候，在json还没诞生的黑暗年代，大家只能选择用xml呀，至今很多传统公司如金融行业的很多系统的接口还主要是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>
xml协议在各个语言里的都 是支持的，在python中可以用以下模块操作xml：
# print(root.iter('year')) #全文搜索 # print(root.find('country')) #在root的子节点找，只找一个 # print(root.findall('country')) #在root的子节点找，找所有
import xml.etree.ElementTree as ET tree = ET.parse("xmltest.xml") root = tree.getroot() print(root.tag) #遍历xml文档 for child in root: print('========>',child.tag,child.attrib,child.attrib['name']) for i in child: print(i.tag,i.attrib,i.text) #只遍历year 节点 for node in root.iter('year'): print(node.tag,node.text) #--------------------------------------- import xml.etree.ElementTree as ET tree = ET.parse("xmltest.xml") root = tree.getroot() #修改 for node in root.iter('year'): new_year=int(node.text)+1 node.text=str(new_year) node.set('updated','yes') node.set('version','1.0') tree.write('test.xml') #删除node for country in root.findall('country'): rank = int(country.find('rank').text) if rank > 50: root.remove(country) tree.write('output.xml')
#在country内添加（append）节点year2 import xml.etree.ElementTree as ET tree = ET.parse("a.xml") root=tree.getroot() for country in root.findall('country'): for year in country.findall('year'): if int(year.text) > 2000: year2=ET.Element('year2') year2.text='新年' year2.attrib={'update':'yes'} country.append(year2) #往country节点下添加子节点 tree.write('a.xml.swap')
自己创建xml文档：
import xml.etree.ElementTree as ET new_xml = ET.Element("infomation") friend1 = ET.SubElement(new_xml, "friend",) name1=ET.SubElement(friend1, "name") name1.text="egon" age = ET.SubElement(friend1, "age") age.text="18" sex = ET.SubElement(friend1, "sex") sex.text = 'man' friend2 = ET.SubElement(new_xml, "friend2",) name2=ET.SubElement(friend2, "name") name2.text="egon" age2 = ET.SubElement(friend2, "age") age2.text="18" sex2 = ET.SubElement(friend2, "sex") sex2.text = '33' et = ET.ElementTree(new_xml) # 生成文档对象 et.write("test.xml", encoding="utf-8", xml_declaration=True) ET.dump(new_xml) # 打印生成的格式
查看生成的xml文件（使用上面代码执行生成时是两行，通过手动换行拆分了一下）
<?xml version='1.0' encoding='utf-8'?> <infomation> <friend> <name>egon</name> <age>18</age> <sex>man</sex> </friend> <friend2> <name>egon</name> <age>18</age> <sex>33</sex> </friend2> </infomation>
configparser模块
配置文件如下：
[section1] k1=v1 k2=v2 user=egon age=18 is_admin=true salary=31 [section2] k1 = v1
读取：
import configparser config=configparser.ConfigParser() config.read('a.cfg',encoding="utf-8") #查看所有的标题 res=config.sections() #['section1', 'section2'] print(res) #查看标题section1下所有key=value的key options=config.options('section1') print(options) #['k1', 'k2', 'user', 'age', 'is_admin', 'salary'] #查看标题section1下所有key=value的(key,value)格式 item_list=config.items('section1') print(item_list) #[('k1', 'v1'), ('k2', 'v2'), ('user', 'egon'), ('age', '18'), ('is_admin', 'true'), ('salary', '31')] #查看标题section1下user的值=>字符串格式 val=config.get('section1','user') print(val) #egon #查看标题section1下age的值=>整数格式 val1=config.getint('section1','age') print(val1) #18 #查看标题section1下is_admin的值=>布尔值格式 val2=config.getboolean('section1','is_admin') print(val2) #True #查看标题section1下salary的值=>浮点型格式 val3=config.getfloat('section1','salary') print(val3) #31.0
改写：
import configparser config=configparser.ConfigParser() config.read('a.cfg',encoding='utf-8') #删除整个标题section2 config.remove_section('section2') #删除标题section1下的某个k1和k2 config.remove_option('section1','k1') config.remove_option('section1','k2') #判断是否存在某个标题 print(config.has_section('section1')) #判断标题section1下是否有user print(config.has_option('section1','')) #添加一个标题 config.add_section('egon') #在标题egon下添加name=egon,age=18的配置 config.set('egon','name','egon') config.set('egon','age',18) #报错,必须是字符串 #最后将修改的内容写入文件,完成最终的修改 config.write(open('a.cfg','w'))
import configparser config = configparser.ConfigParser() config["DEFAULT"] = {'ServerAliveInterval': '45', 'Compression': 'yes', 'CompressionLevel': '9'} config['bitbucket.org'] = {} config['bitbucket.org']['User'] = 'hg' config['topsecret.server.com'] = {} topsecret = config['topsecret.server.com'] topsecret['Host Port'] = '50022' # mutates the parser topsecret['ForwardX11'] = 'no' # same here config['DEFAULT']['ForwardX11'] = 'yes' with open('example.ini', 'w') as configfile: config.write(configfile)
hashlib模块
# 1、什么叫hash:hash是一种算法（3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法），该算法接受传入的内容，经过运算得到一串hash值 # 2、hash值的特点是： #2.1 只要传入的内容一样，得到的hash值必然一样=====>要用明文传输密码文件完整性校验 #2.2 不能由hash值返解成内容=======》把密码做成hash值，不应该在网络传输明文密码 #2.3 只要使用的hash算法不变，无论校验的内容有多大，得到的hash值长度是固定的
hash算法就像一座工厂，工厂接收你送来的原材料（可以用m.update()为工厂运送原材料），经过加工返回的产品就是hash值
因为update()的括号里不支持将字符串对象引入，因为哈希在字节上工作，而不在字符或字符串上工作。通俗点说就是，必须要将update括号里的字符串以一种编码格式(最好是utf-8)进行编码，转换为字节(bytes)格式
所以update后面的括号里的字符串必须进行编码，转换成字节encode()
import hashlib m=hashlib.md5()# m=hashlib.sha256() m.update('hello'.encode('utf8')) m.update('alvin'.encode('utf8')) print(m.hexdigest()) #92a7e713c30abbb0319fa07da2a5c4af m2=hashlib.md5() m2.update('helloalvin'.encode('utf8')) print(m2.hexdigest()) #92a7e713c30abbb0319fa07da2a5c4af ''' 注意：把一段很长的数据update多次，与一次update这段长数据，得到的结果一样 但是update多次为校验大文件提供了可能。 '''
以上加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key（加盐）再来做加密。
import hashlib # ######## 256 ######## hash = hashlib.sha256() salt = "898oaFs09f" passwd= 'alvin' hash.update(salt.encode("utf-8")) hash.update(passwd.encode("utf-8")) print(hash.hexdigest()) #e79e68f070cdedcfe63eaf1a2e92c83b4cfb1b5c6bc452d214c1b7e77cdfd1c7 ########md5 m1=hashlib.md5() salt = "898oaFs09f" passwd= 'alvin' m1.update(salt.encode("utf-8")) m1.update(passwd.encode("utf-8")) print(m1.hexdigest()) #d32d8fa4d77f37e03d492f023daccf65
import hashlib passwds=[ 'alex3714', 'alex1313', 'alex94139413', 'alex123456', '123456alex', 'a123lex', ] def make_passwd_dic(passwds): dic={} for passwd in passwds: m=hashlib.md5() m.update(passwd.encode('utf-8')) dic[passwd]=m.hexdigest() return dic def break_code(cryptograph,passwd_dic): for k,v in passwd_dic.items(): if v == cryptograph: print('密码是===> 33[46m%s 33[0m' %k) cryptograph='aee949757a2e698417463d47acac93df' break_code(cryptograph,make_passwd_dic(passwds))
python 还有一个 hmac 模块，它内部对我们创建 key 和 内容 进行进一步的处理然后再加密:
import hmac h1=hmac.new('hello'.encode('utf-8'),digestmod='md5') h1.update('world'.encode('utf-8')) print(h1.hexdigest()) #0e2564b7e100f034341ea477c23f283b
#要想保证hmac最终结果一致，必须保证： #1:hmac.new括号内指定的初始key一样 #2:无论update多少次，校验的内容累加到一起是一样的内容 # 操作一 import hmac h1=hmac.new('hello'.encode('utf-8'),digestmod='md5') h1.update('world'.encode('utf-8')) print(h1.hexdigest()) # 0e2564b7e100f034341ea477c23f283b # 操作二 import hmac h2=hmac.new('hello'.encode('utf-8'),digestmod='md5') h2.update('w'.encode('utf-8')) h2.update('orld'.encode('utf-8')) print(h1.hexdigest()) # 0e2564b7e100f034341ea477c23f283b
subprocess模块
subprocess.Popen
常用参数
args：shell命令，可以是字符串或者序列类型（如：list，元组） bufsize：缓冲区大小。当创建标准流的管道对象时使用，默认-1。 0：不使用缓冲区 1：表示行缓冲，仅当universal_newlines=True时可用，也就是文本模式 正数：表示缓冲区大小 负数：表示使用系统默认的缓冲区大小。 stdin, stdout, stderr：分别表示程序的标准输入、输出、错误句柄 preexec_fn：只在 Unix 平台下有效，用于指定一个可执行对象（callable object），它将在子进程运行之前被调用 shell：如果该参数为 True，将通过操作系统的 shell 执行指定的命令。 cwd：用于设置子进程的当前目录。 env：用于指定子进程的环境变量。如果 env = None，子进程的环境变量将从父进程中继承。
创建一个子进程，然后执行一个简单的命令:
>>> import subprocess >>> p = subprocess.Popen('ls -l', shell=True) >>> total 164 -rw-r--r-- 1 root root 133 Jul 4 16:25 admin-openrc.sh -rw-r--r-- 1 root root 268 Jul 10 15:55 admin-openrc-v3.sh ... >>> p.returncode >>> p.wait() 0 >>> p.returncode
这里也可以使用 p = subprocess.Popen(['ls', '-cl']) 来创建子进程。
Popen对象方法
poll(): 检查进程是否终止，如果终止返回 returncode，否则返回 None。
wait(timeout): 等待子进程终止。
communicate(input,timeout): 和子进程交互，发送和读取数据。communicate()返回一个元组(stdoutdata,stderrdata)
send_signal(singnal): 发送信号到子进程 。
terminate(): 停止子进程,也就是发送SIGTERM信号到子进程。
kill(): 杀死子进程。发送 SIGKILL 信号到子进程。
实例：（在windows上执行）
import subprocess def cmd(command): subp = subprocess.Popen(command,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE) subp.wait() #先等待,再判断命令执行状态 if subp.poll() == 0: print(subp.communicate()[0].decode("gbk")) #标准输出 else: print(subp.communicate()[1].decode("gbk")) #错误输出 print("失败") # cmd("dir") cmd("l'sls")
示例：
linux系统上：
#/etc/yum.repos.d/目录下内容 # ll /etc/yum.repos.d/ -rw-r--r--. 1 root root 2523 Jun 15 2018 CentOS-Base.repo -rw-r--r--. 1 root root 951 Oct 2 2017 epel.repo -rw-r--r--. 1 root root 1050 Oct 2 2017 epel-testing.repo
test.py文件内容：
#usr/bin/env python3 #encoding:utf-8 import subprocess ''' sh-3.2# ls /Users/egon/Desktop |grep txt$ mysql.txt tt.txt 事物.txt ''' #stdin表示子程序的标准输入，通过res1的输出输入给前面grep筛选 res1=subprocess.Popen('ls /etc/yum.repos.d/',shell=True,stdout=subprocess.PIPE) res=subprocess.Popen('grep repo$',shell=True,stdin=res1.stdout, stdout=subprocess.PIPE) print(res.stdout.read().decode('utf-8')) #等同于上面,但是上面的优势在于,一个数据流可以和另外一个数据流交互,可以通过爬虫得到结果然后交给grep res1=subprocess.Popen('ls /etc/yum.repos.d/ |grep repo$',shell=True,stdout=subprocess.PIPE) print(res1.stdout.read().decode('utf-8')) #=========================================== #执行文件,在文件当前目录下 #python3 test.py [root@localhost project_code]# python3 test.py CentOS-Base.repo epel.repo epel-testing.repo CentOS-Base.repo epel.repo epel-testing.repo
示例：widows系统：
#windows下:
import subprocess
obj=subprocess.Popen(r'dir E:oldboyclassworkshow_money',shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
# 命令正常执行的显示
print(obj)
res=obj.stdout.read() #stdout为正常显示
print(res.decode('gbk')) ##subprocess使用当前系统默认编码，得到结果为bytes类型，在windows下需要用gbk解码
#或写成print(obj.stdout.read().decode('gbk'))
#命令未正常执行的显示
# err_res=obj.stderr.read() #stderr为正常显示为错误显示
# print(err_res.decode('gbk'))
logging模块
1）、日志级别
CRITICAL = 50 #FATAL = CRITICAL
ERROR = 40
WARNING = 30 #WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0 #不设置
2）、默认级别为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
'''
3）、为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参数会被忽略。
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
4）、logging模块的logger、filter、handler、formatter对象
#logger：产生日志的对象 #Filter：过滤日志的对象 (几乎不用) #Handler：接收日志然后控制打印到不同的地方，FileHandler用来打印到文件中，StreamHandler用来打印到终端 #Formatter对象：可以定制不同的日志格式对象，然后绑定给不同的Handler对象使用，以此来控制不同的Handler的日志格式
import logging #1、Logger：产生日志 log1=logging.getLogger("访问日志") #标记是什么日志 #2020-03-29 22:03:13 - 访问日志 - DEBUG - 日志模块logging - debug测试信息 #2、Filter:几乎不用 #3、Handler：接收Logger传过来的日志，进行日志格式化，可以打印到屏幕，也可以打印到文件 sh=logging.StreamHandler() #打印到终端 fh=logging.FileHandler("access.log",encoding="utf-8") #打印到文件，文件名，或文件的绝对路径，可以指定字符编码 #4、Formatter：指定日志格式 formatter1=logging.Formatter( fmt="%(asctime)s - %(name)s - %(levelname)s - %(module)s - %(message)s", datefmt="%Y-%m-%d %X" ) #5、为Handler绑定日志格式 sh.setFormatter(formatter1) fh.setFormatter(formatter1) #6、为logger绑定handler log1.addHandler(sh) log1.addHandler(fh) #7、设置日志级别，可以在第一步log1设置，也可以在第三步sh、fh这两个handler设置 #logger对象的日志级别应该<=handle的日志级别 #方法一：通过级别的数字10,20,30,40,50 log1.setLevel(10) sh.setLevel(10) fh.setLevel(10) #方法二：设置一个变量控制 # LOGIN_LEVEL=logging.DEBUG # log1.setLevel(LOGIN_LEVEL) # sh.setLevel(LOGIN_LEVEL) # fh.setLevel(LOGIN_LEVEL) #8、测试 log1.debug("debug测试信息") log1.info("info测试信息") log1.warning("warning测试信息") log1.error("error测试信息") log1.critical("critical测试信息") #access.log内信息 """ 2020-03-29 22:03:13 - 访问日志 - DEBUG - 日志模块logging - debug测试信息 2020-03-29 22:03:13 - 访问日志 - INFO - 日志模块logging - info测试信息 2020-03-29 22:03:13 - 访问日志 - WARNING - 日志模块logging - warning测试信息 2020-03-29 22:03:13 - 访问日志 - ERROR - 日志模块logging - error测试信息 2020-03-29 22:03:13 - 访问日志 - CRITICAL - 日志模块logging - critical测试信息 """
5）、logger与handler的级别
logger是第一级过滤，然后才能到handler，我们可以给logger和handler同时设置level，但是需要注意的是，logger对象的日志级别应该<=handle的日志级别
import logging logger=logging.getLogger("access") ch=logging.StreamHandler() fomat=logging.Formatter( fmt="%(asctime)s - %(name)s - %(levelno)s - %(message)s %(module)s", datefmt="%Y-%m-%d %X" ) ch.setFormatter(fomat) logger.addHandler(ch) logger.setLevel(20) #如果logger设置20级别，那么会将20及以上的打印，handler再设置成10级别就没有用了（因为10级别的日志已经被过滤掉了） ch.setLevel(10) logger.debug("debug 这是debug信息") logger.info("info测试信息") logger.warning("warning测试信息") logger.error("error测试信息") logger.critical("critical测试信息") #打印结果 """ 2020-03-30 08:20:37 - access - 20 - info测试信息 日志模块logging 2020-03-30 08:20:37 - access - 30 - warning测试信息 日志模块logging 2020-03-30 08:20:37 - access - 40 - error测试信息 日志模块logging 2020-03-30 08:20:37 - access - 50 - critical测试信息 日志模块logging """
使用字典进行log模块配置，再导入配置（推荐使用）
目录：
#setting 配置字典 standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][日志名:%(name)s][%(filename)s:%(lineno)d]' '[%(levelname)s][%(message)s]' simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s' test_format = '%(asctime)s] %(message)s' # 3、日志配置字典 LOGGING_DIC = { 'version': 1, 'disable_existing_loggers': False, 'formatters': { 'standard': { 'format': standard_format }, 'simple': { 'format': simple_format }, 'test': { 'format': test_format }, }, 'filters': {}, 'handlers': { #打印到终端的日志，实际开发建议使用WARNING 'console': { 'level': 'DEBUG', 'class': 'logging.StreamHandler', # 打印到屏幕 'formatter': 'simple' }, #打印到文件的日志,收集info及以上的日志，实际开发建议使用ERROR 'default': { 'level': 'INFO', 'class': 'logging.handlers.RotatingFileHandler', # 保存到文件,日志轮转 'formatter': 'standard', # 可以定制日志文件路径 # BASE_DIR = os.path.dirname(os.path.abspath(__file__)) # log文件的目录 # LOG_PATH = os.path.join(BASE_DIR,'a1.log') 'filename': 'access.log', # 日志文件 'maxBytes': 1024*1024*5, # 日志大小 5M，默认单位字节，日志大小达到5M就将其内容剪切到其他文件备份 'backupCount': 5, #最大备份5份，备份文件名access.log.1，在filename名后.1或.2、.3。。。。 'encoding': 'utf-8', # 日志文件的编码，再也不用担心中文log乱码了 }, 'other': { 'level': 'DEBUG', 'class': 'logging.FileHandler', # 保存到文件 'formatter': 'test', 'filename': 'access.log', 'encoding': 'utf-8', }, }, 'loggers': { #logging.getLogger(__name__)拿到的logger配置 'kkk': { 'handlers': ['other', 'console'], # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕 'level': 'DEBUG', # loggers(第一层日志级别关限制)--->handlers(第二层日志级别关卡限制) 'propagate': False, # 是否让日志信息继续冒泡给其他的日志处理系统，默认为True，向上（更高level的logger）传递，通常设置为False即可，否则会一份日志向上层层传递 }, '专门的采集': { 'handlers': ['other',], 'level': 'DEBUG', 'propagate': False, }, '': { 'handlers': ['default','console'], #如果k为空，代表找不到k的时候用空k,并将日志名用这个空k 'level': 'DEBUG', 'propagate': False, }, }, } #show.py导入字典配置进行使用 # 注意logging是一个包，需要使用其下的config、getLogger，可以如下导入,也可以直接导入logging，然后以logging为前缀导入logging.getLogger,logging.config from logging import getLogger from logging import config """ 也可以使用如下导入 import logging.config # 这样连同logging.getLogger都一起导入了,然后使用前缀logging.config.
#导入配置
logging.config.dictConfig(setting.LOGGING_DIC) """ import setting config.dictConfig(setting.LOGGING_DIC) logger1=getLogger("用户交易") #如果字典中logger没有"用户交易的k,会默认使用那个空k" logger1.info("这是info测试信息")
re模块
1）什么是正则：
正则就是用一些具有特殊含义的符号组合到一起（称为正则表达式）来描述字符或者字符串的方法。或者说：正则就是用来描述一类事物的规则。（在Python中）它内嵌在Python中，并通过 re 模块实现。正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行。
生活中处处都是正则：
比如我们描述：4条腿
你可能会想到的是四条腿的动物或者桌子，椅子等
继续描述：4条腿，活的
就只剩下四条腿的动物这一类了
2）常用的匹配模式（元字符）
# =================================匹配模式================================= #一对一的匹配 # 'hello'.replace(old,new) # 'hello'.find('pattern') #正则匹配 import re #w与W print(re.findall('w','hello egon 123')) #['h', 'e', 'l', 'l', 'o', 'e', 'g', 'o', 'n', '1', '2', '3'] print(re.findall('W','hello egon 123')) #[' ', ' '] #s与S print(re.findall('s','hello egon 123')) #[' ', ' ', ' ', ' '] print(re.findall('S','hello egon 123')) #['h', 'e', 'l', 'l', 'o', 'e', 'g', 'o', 'n', '1', '2', '3'] # 都是空,都可以被s匹配 print(re.findall('s','hello egon 123')) #[' ', ' ', ' ', ' ', ' ', ' '] # 与 print(re.findall(r' ','hello egon 123')) #[' '] print(re.findall(r' ','hello egon 123')) #[' '] #d与D print(re.findall('d','hello egon 123')) #['1', '2', '3'] print(re.findall('D','hello egon 123')) #['h', 'e', 'l', 'l', 'o', ' ', 'e', 'g', 'o', 'n', ' '] #A与 print(re.findall('Ahe','hello egon 123')) #['he'],A==>^ print(re.findall('123','hello egon 123')) #['he'],==>$ #^与$ print(re.findall('^h','hello egon 123')) #['h'] print(re.findall('3$','hello egon 123')) #['3'] # 重复匹配：| . | * | ? | .* | .*? | + | {n,m} | #. print(re.findall('a.b','a1b')) #['a1b'] print(re.findall('a.b','a1b a*b a b aaab')) #['a1b', 'a*b', 'a b', 'aab'] print(re.findall('a.b','a b')) #[] print(re.findall('a.b','a b',re.S)) #['a b'] print(re.findall('a.b','a b',re.DOTALL)) #['a b']同上一条意思一样 #* print(re.findall('ab*','bbbbbbb')) #[] print(re.findall('ab*','a')) #['a'] print(re.findall('ab*','abbbb')) #['abbbb'] #? print(re.findall('ab?','a')) #['a'] print(re.findall('ab?','abbb')) #['ab'] #匹配所有包含小数在内的数字 print(re.findall('d+.?d*',"asdfasdf123as1.13dfa12adsf1asdf3")) #['123', '1.13', '12', '1', '3'] #.*默认为贪婪匹配 print(re.findall('a.*b','a1b22222222b')) #['a1b22222222b'] #.*?为非贪婪匹配：推荐使用 print(re.findall('a.*?b','a1b22222222b')) #['a1b'] #+ print(re.findall('ab+','a')) #[] print(re.findall('ab+','abbb')) #['abbb'] #{n,m} print(re.findall('ab{2}','abbb')) #['abb'] print(re.findall('ab{2,4}','abbb')) #['abb'] print(re.findall('ab{1,}','abbb')) #'ab{1,}' ===> 'ab+' print(re.findall('ab{0,}','abbb')) #'ab{0,}' ===> 'ab*' #[] print(re.findall('a[1*-]b','a1b a*b a-b')) #[]内的都为普通字符了，且如果-没有被转意的话，应该放到[]的开头或结尾 print(re.findall('a[^1*-]b','a1b a*b a-b a=b')) #[]内的^代表的意思是取反，所以结果为['a=b'] print(re.findall('a[0-9]b','a1b a*b a-b a=b')) #[]内的^代表的意思是取反，所以结果为['a=b'] print(re.findall('a[a-z]b','a1b a*b a-b a=b aeb')) #[]内的^代表的意思是取反，所以结果为['a=b'] print(re.findall('a[a-zA-Z]b','a1b a*b a-b a=b aeb aEb')) #[]内的^代表的意思是取反，所以结果为['a=b'] ## print(re.findall('a\c','ac')) #对于正则来说a\c确实可以匹配到ac,但是在python解释器读取a\c时，会发生转义，然后交给re去执行，所以抛出异常 print(re.findall(r'a\c','ac')) #r代表告诉解释器使用rawstring，即原生字符串，把我们正则内的所有符号都当普通字符处理，不要转义 print(re.findall('a\\c','ac')) #同上面的意思一样，和上面的结果一样都是['a\c'] #():分组 print(re.findall('ab+','ababab123')) #['ab', 'ab', 'ab'] print(re.findall('(ab)+123','ababab123')) #['ab']，匹配到末尾的ab123中的ab print(re.findall('(?:ab)+123','ababab123')) #findall的结果不是匹配的全部内容，而是组内的内容,?:可以让结果为匹配的全部内容 print(re.findall('href="(.*?)"','<a href="http://www.baidu.com">点击</a>'))#['http://www.baidu.com'] print(re.findall('href="(?:.*?)"','<a href="http://www.baidu.com">点击</a>'))#['href="http://www.baidu.com"'] #| print(re.findall('compan(?:y|ies)','Too many companies have gone bankrupt, and the next one is my company'))
# ===========================re模块提供的方法介绍=========================== import re #1 print(re.findall('e','alex make love') ) #['e', 'e', 'e'],返回所有满足匹配条件的结果,放在列表里 #2 print(re.search('e','alex make love').group()) #e,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。 #3 print(re.match('e','alex make love')) #None,同search,不过在字符串开始处进行匹配,完全可以用search+^代替match #4 print(re.split('[ab]','abcd')) #['', '', 'cd']，先按'a'分割得到''和'bcd',再对''和'bcd'分别按'b'分割 #5 print('===>',re.sub('a','A','alex make love')) #===> Alex mAke love，不指定n，默认替换所有 print('===>',re.sub('a','A','alex make love',1)) #===> Alex make love print('===>',re.sub('a','A','alex make love',2)) #===> Alex mAke love print('===>',re.sub('^(w+)(.*?s)(w+)(.*?s)(w+)(.*?)$',r'52341','alex make love')) #===> love make alex print('===>',re.subn('a','A','alex make love')) #===> ('Alex mAke love', 2),结果带有总共替换的个数 #6 obj=re.compile('d{2}') print(obj.search('abc123eeee').group()) #12 print(obj.findall('abc123eeee')) #['12'],重用了obj
分组内容进一步解释：
1、语法说明
每一段正则用一个加圆括起来时，便自动构成一个组，包括(?Ppattern)自定义命名组，也加入到分组序号中
如果后面有前面圆括中相同部分，则用数字序号表示匹配相同部分
r’(正则1)…(正则2)…(正则3) 。。。1….2….3…’,
这里出现1，表示匹配前面第1个圆括号正则内容，
这里出现2，表示匹配前面第2个圆括号正则内容
import re str=''' oracle:500:a:500, java:1550, bigdata:2000, php:500 <oracle>500</oracle> <java>1550</java> <bigdata>2000</bigdata> <php>500</php> ''' s1=re.findall(r'D+:(d+):w:1,?',str,re.I|re.S) #结果是:['500'] print(s1)
参考：
https://blog.csdn.net/isscollege/article/details/80138158
PrettyTable模块(优化输出)
PrettyTable说明
PrettyTable 是python中的一个第三方库，可用来生成美观的ASCII格式的表格，十分实用。
以下为官方介绍：
A simple Python library for easily displaying tabular data in a visually appealing ASCII table format.
PrettyTable is a simple Python library designed to make it quick and easy to represent tabular data in visually appealing ASCII tables. It was inspired by the ASCII tables used in the PostgreSQL shell psql. PrettyTable allows for selection of which columns are to be printed, independent alignment of columns (left or right justified or centred) and printing of “sub-tables” by specifying a row range.
PrettyTable安装
使用pip即可十分方便的安装PrettyTable，如下：
#pip install PrettyTable
PrettyTable使用示例
使用示例：
# -*- coding:utf-8 -*- from prettytable import PrettyTable x = PrettyTable(field_names=["name", "age", "sex", "money"]) x.align["name"] = "l" # 以name字段左对齐 x.padding_width = 1 # 填充宽度 x.add_row(["wang",20, "man", 1000]) x.add_row(["alex",21, "man", 2000]) x.add_row(["peiqi",22, "man", 3000]) #表排序 print(x.get_string(sortby="money", reversesort=True)) #自带样式打印风格，参数还可以选择“DEFAULT”、“PLAIN_COLUMNS” # print(x.set_style(MSWORD_FRIENDLY)) ''' +-------+-----+-----+-------+ | name | age | sex | money | +-------+-----+-----+-------+ | wang | 20 | man | 1000 | | alex | 21 | man | 2000 | | peiqi | 22 | man | 3000 | +-------+-----+-----+-------+ '''
实例2（按行和按列添加数据）
参考链接：https://www.cnblogs.com/Mr-Koala/p/6582299.html
from prettytable import PrettyTable ## 按行添加数据 tb =PrettyTable(field_names=["City name", "Area", "Population", "Annual Rainfall"]) tb.add_row(["Adelaide",1295, 1158259, 600.5]) tb.add_row(["Brisbane",5905, 1857594, 1146.4]) tb.add_row(["Darwin", 112, 120900, 1714.7]) tb.add_row(["Hobart", 1357, 205556,619.5]) print(tb)
## 按列添加数据 tb.add_column('index',[1,2,3,4]) print(tb)
## 使用不同的输出风格 tb.set_style(pt.MSWORD_FRIENDLY) print('--- style：MSWORD_FRIENDLY -----') print(tb) tb.set_style(pt.PLAIN_COLUMNS) print('--- style：PLAIN_COLUMNS -----') print(tb) ## 随机风格，每次不同 tb.set_style(pt.RANDOM) print('--- style：MSWORD_FRIENDLY -----') print(tb) tb.set_style(pt.DEFAULT) print('--- style：DEFAULT -----') print(tb)
## 不打印，获取表格字符串 s = tb.get_string() print(s) ## 可以只获取指定列或行 s = tb.get_string(fields=["City name", "Population"],start=1,end=4) print(s)
## 自定义表格输出样式 ### 设定左对齐 tb.align = 'l' ### 设定数字输出格式 tb.float_format = "2.2" ### 设定边框连接符为'*" tb.junction_char = "*" ### 设定排序方式 tb.sortby = "City name" ### 设定左侧不填充空白字符 tb.left_padding_width = 0 print(tb)
## 不显示边框 tb.border = 0 print(tb) ## 修改边框分隔符 tb.set_style(pt.DEFAULT) tb.horizontal_char = '+' print(tb)
pillow模块（图片相关的模块）
字体ttf文件下载链接：
安装模块
# pip3 install pillow
pillow模块重要方法
#导入模块 from PIL import Image,ImageDraw,ImageFont,ImageFilter """ Image:生成图片 ImageDraw:能够在图片上乱涂乱画 ImageFont:控制字体样式 ImageFilter:控制图片模糊度 """ # 生成图片对象 Image.new(模式, 大小, 颜色) img_obj = Image.new('RGB', (430, 35), "red") # Image.new(模式, 大小, 颜色)第二个参数图片尺寸(要和前端划定的尺寸一致),第三个参数还可以放三基色参数 # 保存文件 # Image.save(FP文件名(String), 格式) # 格式可选格式覆盖。如果省略，将从文件扩展名确定要使用的格式。如果使用的是文件对象而不是文件名，则应始终使用此参数。 img_obj.save(io_obj,"png") # 高斯模糊 # img_obj = img_obj.filter(ImageFilter.GaussianBlur) # 绘制文字 # text(xy, text, fill,font) """ xy：起点坐标 text：绘制的文本 fill：填充色。"red"、"blue"... font:字体 """ img_draw.text((i*45+100,-3),tmp,get_random(),img_font)
案例，随机验证码图片(结合内存管理模块实现)
""" 图片相关的模块 # pip3 install pillow """ from PIL import Image,ImageDraw,ImageFont,ImageFilter """ Image:生成图片 ImageDraw:能够在图片上乱涂乱画 ImageFont:控制字体样式 ImageFilter:控制图片模糊度 """ from io import BytesIO,StringIO """ 内存管理器模块 BytesIO：临时的帮你存储数据 返回的时候数据就是二进制格式 StringIO：临时的帮你存储数据 返回的时候数据就是字符串格式 """ import random def get_random(): return random.randint(0,255),random.randint(0,255),random.randint(0,255) def get_code(request): # 推导步骤1：直接获取后端现成的图片二进制数据发送给前端 # with open(r"static/img/111.jpg", "rb") as f: # data = f.read() # return HttpResponse(data) # # 推导步骤2：利用pillow模块动态产生图片（文件存储繁琐IO操作效率低） # img_obj = Image.new('RGB', (430, 35), "red") # 第二个参数图片尺寸(要和前端划定的尺寸一致),第三个参数还可以放三基色参数 # img_obj = Image.new('RGB', (430, 35), get_random()) # 先将图片对象保存起来 # with open("xxx.png",'wb') as f: # img_obj.save(f,"png") # 文件句柄，图片格式 # # 再将图片对象读取出来 # with open('xxx.png','rb') as f: # data = f.read() # return HttpResponse(data) # 推导步骤3：借助于内存管理模块 # img_obj = Image.new('RGB', (430, 35), get_random()) # io_obj = BytesIO() # 生成一个内存管理器对象，可以看成是文件句柄 # img_obj.save(io_obj,'png') # 要指定图片的格式 # return HttpResponse(io_obj.getvalue()) # io_obj.getvalue()读取出文件，返回的是二进制格式 # 最终步骤：绘制图片验证码 img_obj = Image.new('RGB', (430, 35), get_random()) img_draw = ImageDraw.Draw(img_obj) # 产生一个画笔对象 img_font = ImageFont.truetype("static/font/222.TTF",30) # 字体样式,以及字体大小 # 随机验证码 五位数的随机验证码 数字 小写字母 大写字母 code = '' for i in range(5): random_upper = chr(random.randint(65,90)) random_lower = chr(random.randint(97,122)) random_int = str(random.randint(0,9)) # 从上面三个里面随机选一个 tmp = random.choice([random_upper,random_lower,random_int]) # 将产生的随机字符串写入图片 """ 为什么一个个写而不是生成好了之后再写 因为一个个写能够控制每个字体的间隙 而生成好之后再写的话 间隙就没法控制了 """ img_draw.text((i*45+100,-3),tmp,get_random(),img_font) # 拼接随机字符串 code += tmp # print(code) # 随机验证码在登录的视图函数中需要用到 要比对，所以要找地方存起来且其他视图函数也能拿到（可以放在auth_session表中） request.session['code'] = code io_obj = BytesIO() # img_obj = img_obj.filter(ImageFilter.GaussianBlur) img_obj.save(io_obj,"png") return HttpResponse(io_obj.getvalue())