python基础—常用模块
一、什么是模块?
模块的本质:一个模块就是一个包含了python定义和声明的文件,文件名就是模块名字加上.py的后缀。
1.模块和包的概念:
模块
随着程序代码越写越多,在一个文件里代码就会越来越长,越来越不容易维护。
为了编写可维护的代码,我们把很多函数分组,分别放到不同的文件里。
这样,每个文件包含的代码就相对较少,很多编程语言都采用这种组织代码的方式。
在Python中,一个.py文件就称之为一个模块(Module)
包
如果不同的人编写的模块名相同怎么办?为了避免模块名冲突,Python又引入了按目录来组织模块的方法,称为包(Package)。
每一个包目录下面都会有一个__init__.py的文件,这个文件是必须存在的,否则,Python就把这个目录当成普通目录(文件夹),而不是一个包。__init__.py可以是空文件,也可以有Python代码,因为__init__.py本身就是一个模块,而它的模块名就是对应包的名字。
更多相关内容:http://www.cnblogs.com/Eva-J/articles/7292109.html
二、常用模块(一)
1.collections模块
在内置数据类型(dict、list、set、tuple)的基础上,collections模块还提供了几个额外的数据类型:Counter、deque、defaultdict、namedtuple和OrderedDict等。
- namedtuple: 生成可以使用名字来访问元素内容的tuple
- deque: 双端队列,可以快速的从另外一侧追加和推出对象
- Counter: 计数器,主要用来计数
- OrderedDict: 有序字典
- defaultdict: 带有默认值的字典
namedtuple 命名元组
我们知道tuple可以表示不变集合,例如,一个点的二维坐标就可以表示成:
p = (1,2)
但是,看到(1, 2),很难看出这个tuple是用来表示一个坐标的。
这时,nametuple就派上了用场:nametuple可以为元素的每一个元素名一个名字,这样可以区分元组中的每个元素的意义
from collections import namedtuple Point = namedtuple('Point', ['x', 'y']) # 获得一个命名元组类 p = Point(1, 2) # 为这个类实例化一个对象 p.x 通过名字取值 p.y
tu = namedtuple('ryxiong',['name','age','gender','hobby']) # 获得一个类 t = tu('ryxiong',29,'male', 'programing, prography') # 实例化一个对象 print(t) print(t.name)
deque 双端队列
使用list存储数据时,按索引访问元素很快,但是插入和删除元素就很慢了,因为list是线性存储,数据量大的时候,插入和删除效率很低。
双端队列和列表的区别:
- 效率不同
- 底层的数据结构上,列表先进先出(FIFO),栈先进后出(LIFO)
两者的特点:
- 双端队列:链表式数据结构,存入值速度快
- 列表:取值,根据索引,双端队列要一个一个往下找。
使用场景:
- 从中间插入或者删除比较频繁,使用双端队列
- 单纯的append和pop最后一个元素的时候,用列表。
列表的用法,尽量只用append和pop
from collections import deque d = deque([1,2,3,4]) # 右侧添加 d.append(5) # deque([1, 2, 3, 4, 5]) # print(d) # 左侧添加 d.appendleft(10) # deque([10, 1, 2, 3, 4, 5]) # print(d) # 插入 d.insert(2,99) # deque([10, 1, 99, 2, 3, 4, 5]) # print(d) # 删除 d.remove(3) # 指定元素删除 d.pop() # 不可根据索引删除,因为是双向的
deque除了实现list的append()
和pop()
外,还支持appendleft()
和popleft()
,这样就可以非常高效地往头部添加或删除元素。
OrderedDict 顺序字典
在py3.6版本前,字典中的键是没有顺序的,如果我们要保持key的顺序,可以使用OrderDict:
>>> from collections import OrderedDict >>> d = dict([('a', 1), ('b', 2), ('c', 3)]) >>> d # dict的Key是无序的 {'a': 1, 'c': 3, 'b': 2} >>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)]) >>> od # OrderedDict的Key是有序的 OrderedDict([('a', 1), ('b', 2), ('c', 3)])
注意,OrderedDict
的Key会按照插入的顺序排列,不是Key本身排序:
defaultdict 默认字典
# 默认字典 d = defaultdict(list) # defaultdict(<class 'list'>, {}) # print(d) d['name'] # defaultdict(<class 'list'>, {'name': []}) print(d)
有如下值集合 [11,22,33,44,55,66,77,88,99,90...],将所有大于 66 的值保存至字典的第一个key中,将小于 66 的值保存至第二个key的值中。
即: {'k1': 大于66 , 'k2': 小于66}
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
values = [11, 22, 33,44,55,66,77,88,99,90] my_dict = {} for value in values: if value>66: if my_dict.has_key('k1'): my_dict['k1'].append(value) else: my_dict['k1'] = [value] else: if my_dict.has_key('k2'): my_dict['k2'].append(value) else: my_dict['k2'] = [value]
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
from collections import defaultdict values = [11, 22, 33,44,55,66,77,88,99,90] my_dict = defaultdict(list) for value in values: if value>66: my_dict['k1'].append(value) else: my_dict['k2'].append(value)
使用dict时,如果引用的Key不存在,就会抛出KeyError。如果希望key不存在时,返回一个默认值,就可以用defaultdic:
默认字典使用场景:当遇到很多列表类型数据,发现他们的首个元素相同,要合并他们后面的元素进行相应操作,用defaultdict,相当好用。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
>>> from collections import defaultdict >>> dd = defaultdict(lambda: 'N/A') >>> dd['key1'] = 'abc' >>> dd['key1'] # key1存在 'abc' >>> dd['key2'] # key2不存在,返回默认值 'N/A'
# 默认字典中设置默认的具体值 d = defaultdict(lambda :5) print(['a'])
Counter 计数
Counter类的目的是用来跟踪值出现的次数。它是一个无序的容器类型,以字典的键值对形式存储,其中元素作为key,其计数作为value。计数值可以是任意的Interger(包括0和负数)。Counter类和其他语言的bags或multisets很相似。
c = Counter('abcdeabcdabcaba') print c 输出:Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1}) 总结:没有什么大用处
2.时间模块
在处理和时间相关的问题时候我们需要用到时间模块,时间模块有很多种,这里介绍三种:time模块,datetime模块,dateutil模块
但是本质上,datetime和dateutil都是基于time模块上实现的。
时间相关概念
时间戳
- 时间是格林威治时间1970年01月01日00时00分00秒
时区:
- 世界各地根据经度的不同划分为24个时区,以英国为零时区,向东向西各划分12个
UTC时间:
协调世界时(coordinated Universal Time,简称UTC)是最主要的世界时间标准,以原子时秒长为标准,在时刻上尽量接近格林威治时间。
- 比如本地时间比UTC快,如大陆比UTC时间快8小时,则会写作UTC+8,相反写做UTC-10
time模块
python中的时间
1.时间戳(timestamp):通常来说,时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”,返回的是float类型。
2.结构化时间(struct_time):struct_time元组共有9个元素共九个元素:(年,月,日,时,分,秒,一年中第几周,一年中第几天,夏令时)
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
索引(Index) 属性(Attribute) 值(Values) 0 tm_year(年) 比如2011 1 tm_mon(月) 1 - 12 2 tm_mday(日) 1 - 31 3 tm_hour(时) 0 - 23 4 tm_min(分) 0 - 59 5 tm_sec(秒) 0 - 60 6 tm_wday(weekday) 0 - 6(0表示周一) 7 tm_yday(一年中的第几天) 1 - 366 8 tm_isdst(是否是夏令时) 默认为0
3.格式化时间(format_time):如2015-02-14 10:25:00
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
格式化时间字符串化对应表 %Y Year with century as a decimal number. %m Month as a decomal number [01,12]. %d Day of the month as a decomal number [01, 31]. %H Hour (24-hour clock) as a decimal number [00,23]. %M Minute as a decimal number [00,59]. %S Second as a decimal number [00,61]. %z Time zone offset from UTC. %a Locale's abbreviated weekday name. # 星期的缩写 %A Locale's full weekday name. # 星期的全写 %b Locale's abbreviated month name. # 月份的缩写 %B Locale's full month name. # 月份的全写 %X Locale's appropriate time representation. # 冒号分割的时间
time模块的常用方法
- time.time(): 获得当前时间的时间戳
- time.localtime(timestamp): 获得当前时间的结构化时间,参数默认当前时间的时间戳,可以自己给
- time.strftime(format,struct_time): 将结构化时间,转成格式化时间格式,format可以任意规定,当时要根据对应表
- time.strptime(string_time,format): 将格式化时间转换成结构化时间struct_time
- time.mktime(struct_time): 将结构化时间转换成时间戳
- time.sleep(second): 休眠多少秒。
- time.gmtime([sec]): 和localtime方法类似,gmtime是将一个时间转换为UTC时区的struct_time
常用方法:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#导入时间模块 >>>import time #时间戳 >>>time.time() 1500875844.800804 #时间字符串 >>>time.strftime("%Y-%m-%d %X") '2017-07-24 13:54:37' >>>time.strftime("%Y-%m-%d %H-%M-%S") '2017-07-24 13-55-04' #时间元组: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)
小结:时间戳是计算机能够识别的时间;时间字符串是人能够看懂的时间;元组则是用来操作时间的。
几种格式之间的转换
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#时间戳-->结构化时间 #time.gmtime(时间戳) #UTC时间,与英国伦敦当地时间一致 #time.localtime(时间戳) #当地时间。例如我们现在在北京执行这个方法:与UTC时间相差8小时,UTC时间+8小时 = 北京时间 >>>time.gmtime(1500000000) 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(1500000000) time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=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) 1500000000.0
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#结构化时间-->字符串时间 #time.strftime("格式定义","结构化时间") 结构化时间参数若不传,则显示当前时间 >>>time.strftime("%Y-%m-%d %X") '2017-07-24 14:55:36' >>>time.strftime("%Y-%m-%d",time.localtime(1500000000)) '2017-07-14' #字符串时间-->结构化时间 #time.strptime(时间字符串,字符串对应格式) >>>time.strptime("2017-03-16","%Y-%m-%d") time.struct_time(tm_year=2017, tm_mon=3, tm_mday=16, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=75, tm_isdst=-1) >>>time.strptime("07/24/2017","%m/%d/%Y") time.struct_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)
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#结构化时间 --> %a %b %d %H:%M:%S %Y串 #time.asctime(结构化时间) 如果不传参数,直接返回当前时间的格式化串 >>>time.asctime(time.localtime(1500000000)) 'Fri Jul 14 10:40:00 2017' >>>time.asctime() 'Mon Jul 24 15:18:33 2017' #时间戳 --> %a %b %d %H:%M:%S %Y串 #time.ctime(时间戳) 如果不传参数,直接返回当前时间的格式化串 >>>time.ctime() 'Mon Jul 24 15:19:07 2017' >>>time.ctime(1500000000) 'Fri Jul 14 10:40:00 2017'
datetime模块
官方文档:http://devdocs.io/python~3.6/library/datetime https://docs.python.org/3/library/time.html#strftime-and-strptime-behavior
由于time模块在时间的加减上很不友好,所以有人写出的datetime模块,time模块是datetime模块的底层模块
datetime包中常用的几个模块
- from datetime import datetime
- from datetime import timedelta
- from datetime import date
from datetime import datetime # datetime.now(): 获取当前时间 print(datetime.now()) # 2019-03-20 11:38:31.423739 # datetime.timestamp(): 将当前时间转成时间戳 time_stamp = datetime.timestamp(datetime.now()) print(time_stamp) # datetime.strftime(struct_time,format):将结构化时间转换成格式化字符串时间 f = datetime.strftime(datetime.now(),'%Y-%m-%d %X') print(f) # datetime.strptime(string_time,format): 将字符串时间转换成格式化时间。 t = datetime.strptime(f,'%Y-%m-%d %H:%M:%S') print(t)
使用timedelta生成时间间隔,用时间的计算
from datetime import timedelta d = timedelta(days=1,hours=5) # 根据参数,生成多少间隔的一个时间间隔对象 print(d) # 1 day, 5:00:00 # timedelta(): 获取时间差额,用于datetime的增减计算。用时间对象与timedelta运算。 print(datetime.now()-timedelta(days=2)) # 2019-03-18 16:45:04.427857
date模块
from datetime import date,timedelta today = date.today() d = timedelta(days=1, hours=5) future = today + d print(future)
dateutil模块
第三方库:pip install python-dateutil
官方文档:https://dateutil.readthedocs.io/en/stable/examples.html#relativedelta-examples
原因:timedelta不够用,处理跨星期,跨月,跨年的计算麻烦
- class datetime.timedelta(days=0, seconds=0, microseconds=0,milliseconds=0, minutes=0, hours=0, weeks=0)
# 下周的星期三是几号 from datetime import datetime from dateutil.relativedelta import relativedelta from dateutil.rrule import * # MO,TU,WE,TH,FR d = datetime.now() print(d + relativedelta(weekday=WE)) # 这周 print(d + relativedelta(weekday=WE, weeks=+1)) # 下周 print(d + relativedelta(weekday=WE, weeks=-1)) # 上周
计算过了一个月,或者三个月后是哪一天?不能简单+30
from datetime import date date(2018, 1, 31) + relativedelta(months=+1) date(2018,1,25) + relativedelta(months=-10)
3.random模块
随机数模块:产生随机数
random的常用方法:
- random.random(): 返回0-1之间的随机小数
- random.randint(a,b): 返回从a到b之间的随机整数,闭区间
- random.uniform(a,b): 返回a
- random.randrange(m,n,k): 返回m到n步长为k的整数,前开后闭区间
- random.choice(有序的iterable): 从有序的可迭代对象中随机选择一个元素
- random.choices(有序的iterable,k=num): 从有序的可迭代对象中随机选取多个元素,个数可指定,元素之间可重复
- random.sample(有序的iterabel,k=num): 从有序的可迭代对象中随机选取多个元素,个数可指定,元素之间不重复
- random.shuffle(iterable): 将有序可迭代对象中的元素打乱顺序。
>>> import random #随机小数 >>> random.random() # 大于0且小于1之间的小数 0.7664338663654585 >>> random.uniform(1,3) #大于1小于3的小数 1.6270147180533838 #恒富:发红包 #随机整数 >>> random.randint(1,5) # 大于等于1且小于等于5之间的整数 >>> random.randrange(1,10,2) # 大于等于1且小于10之间的奇数 #随机选择一个返回 >>> random.choice([1,'23',[4,5]]) # #1或者23或者[4,5] #随机选择多个返回,返回的个数为函数的第二个参数 >>> random.sample([1,'23',[4,5]],2) # #列表元素任意2个组合 [[4, 5], '23'] #打乱列表顺序 >>> item=[1,3,5,7,9] >>> random.shuffle(item) # 打乱次序 >>> item [5, 1, 3, 7, 9] >>> random.shuffle(item) >>> item [5, 9, 7, 1, 3]
练习:生成随机验证码
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import random def v_code(): code = '' for i in range(5): num=random.randint(0,9) alf=chr(random.randint(65,90)) add=random.choice([num,alf]) code="".join([code,str(add)]) return code print(v_code())
4.os模块
概念:内置模块,是与当前电脑操作系统做交互的一个接口
常用方法
1.文件相关
os.makedirs('dirname1/dirname2') 可生成多层递归目录 os.removedirs('dirname1') 若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依此类推 os.mkdir('dirname') 生成单级目录;相当于shell中mkdir dirname os.rmdir('dirname') 删除单级空目录,若目录不为空则无法删除,报错;相当于shell中rmdir dirname os.listdir('dirname') 列出指定目录下的所有文件和子目录,包括隐藏文件,并以列表方式打印
2.文件相关
os.remove() 删除一个文件 os.rename("oldname","newname") 重命名文件/目录 os.stat('path/filename') 获取文件/目录信息
3.环境相关
os.system("bash command") 运行shell命令,直接显示 os.popen("bash command).read() 运行shell命令,获取执行结果 os.getcwd() 获取当前工作目录,即当前python脚本工作的目录路径 os.chdir("dirname") 改变当前脚本工作目录;相当于shell下cd
4.路径相关(重要)
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/filename') 获取文件/目录信息 的结构说明
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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)是创建时间(详细信息参见平台的文档)。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
os.sep 输出操作系统特定的路径分隔符,win下为"\\",Linux下为"/" os.linesep 输出当前平台使用的行终止符,win下为"\r\n",Linux下为"\n" os.pathsep 输出用于分割文件路径的字符串 win下为;,Linux下为: os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
5.sys模块
概念:sys模块是与python解释器交互的一个接口
常用方法
-
sys.argv: 实现从程序外部向程序传递参数。
-
sys.exit([arg]): 程序中间的退出,arg=0为正常退出。
-
sys.path: 返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
-
sys.platform: 获取当前系统平台。
-
sys.version:获取Python解释程序的版本信息
- sys.modules 返回系统导入的模块字段,key是模块名,value是模块
-
sys.stdout, sys.stdin, sys.stderror:分别和输出输入,错误输出相关。sys.stdout.write和print 都是输出相关的函数print内部也是调用的sys.stdout,sys.stdout默认输出是屏幕。
sys.argv方法
在外部向程序内部传递参数,sys.argv是命令行参数列表,第一个元素是程序本身
# 当我们在命令行cmd中运行某一个文件,后面可以附带参数,这些附带的参数就可以通过sys.argv获得。 比如我们在cmd中输入 python test.py post C://test ,然后我们在test.py文件中打印sys.argv就可以拿到后面的参数post和C://test import sys print(sys.argv)
# 运行结果 ['D:/PyCharmProject/python全栈S20/01-test/test.py', post, C://test] # 列表第一个参数是脚本本身
sys.exit(n)
功能:执行到主程序末尾,解释器自动退出,但是如果需要中途退出程序,可以调用sys.exit函数,带有一个可选的整数参数返回给调用它的程序,表示你可以在主程序中捕获对sys.exit的调用。(0是正常退出,其他为异常)
import sys print('hello') sys.exit(0) print('python') # 运行程序后发现在,程序输出hello后并没有继续输出python。因为在执行到sys.exit(0)的时候程序就结束了。
sys.stdout()
import sys sys.stdout.write(str)
sys.stdout.write()的打印会将结果先缓存,知道所有结果都在缓存中然后一起打印,如果想挨个显示自己的,可以使用sys.stdout.flush()来逐个刷新。没打印一个就刷新屏幕显示。
sys.stdout和print
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import sys s = 'test stdout' print('--') sys.stdout.write(s) print('--') class A(object): pass print(A) # 正常 sys.stdout.write(A) # 报错
注意:print 什么类型都可以输出,但是sys.stdout.write只可以输出字符串类型,否则报错。print默认是最后换行,但是sys.stdout.write默认不换行。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import sys file = sys.stdout # 存储原始的输出对象 sys.stdout = open('1.txt', 'w') # 重定向所有的写入内容到 1.txt 文件, print('Citizen_Wang') # 写入到 1.txt 文件中,在上一行语句中改变了输出流到文件中 print('Always fall in love with neighbours') # 继续写入到文件中 sys.stdout.close() # 其实就是 open 文件之后的关闭 sys.stdout = file # 将 print 命令的结果返回给控制台 print('输出信息返回在控制台') # 该信息会在控制台也显示
6.序列化模块
什么叫序列化——将原本的字典、列表等内容转换成一个字符串的过程就叫做序列化。
我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化,在Python中叫pickling,
在其他语言中也被称之为serialization,marshalling,flattening等等,都是一个意思。
序列化之后,就可以把序列化后的内容写入磁盘,或者通过网络传输到别的机器上。
反过来,把变量内容从序列化的对象重新读到内存里称之为反序列化,即unpickling。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
''' 比如,我们在python代码中计算的一个数据需要给另外一段程序使用,那我们怎么给? 现在我们能想到的方法就是存在文件里,然后另一个python程序再从文件里读出来。 但是我们都知道,对于文件来说是没有字典这个概念的,所以我们只能将数据转换成字典放到文件中。 你一定会问,将字典转换成一个字符串很简单,就是str(dic)就可以办到了,为什么我们还要学习序列化模块呢? 没错序列化的过程就是从dic 变成str(dic)的过程。现在你可以通过str(dic),将一个名为dic的字典转换成一个字符串, 但是你要怎么把一个字符串转换成字典呢? 聪明的你肯定想到了eval(),如果我们将一个字符串类型的字典str_dic传给eval,就会得到一个返回的字典类型了。 eval()函数十分强大,但是eval是做什么的?e官方demo解释为:将字符串str当成有效的表达式来求值并返回计算结果。 BUT!强大的函数有代价。安全性是其最大的缺点。 想象一下,如果我们从文件中读出的不是一个数据结构,而是一句"删除文件"类似的破坏性语句,那么后果实在不堪设设想。 而使用eval就要担这个风险。 所以,我们并不推荐用eval方法来进行反序列化操作(将str转换成python中的数据结构) '''
序列化的目的:
如果只是普通的字符串或者是数值等简单的数据类型,不需要序列化,也能完成保存或者是网络传输.
![](https://img2018.cnblogs.com/blog/1614731/201903/1614731-20190326213119023-860509787.png)
json模块
json数据:用于多种语言交互,编程语言通用数据内置的,不需要安装,直接导入使用,数据持久化
json的四种方法:
- dumps():序列化,将一个字典转换成一个字符串
- loads():反序列化,将一个字符串格式的字典转换成一个字典
- dump(对象,文件句柄):接收一个文件句柄,直接将字典转换成json字符串写入文件
- load(文件句柄):接收一个文件句柄,直接将文件中的json字符串转换成数据结构返回
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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)
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import json f = open('file','w') json.dump({'国籍':'中国'},f) ret = json.dumps({'国籍':'中国'}) f.write(ret+'\n') json.dump({'国籍':'美国'},f,ensure_ascii=False) ret = json.dumps({'国籍':'美国'},ensure_ascii=False) f.write(ret+'\n') f.close()
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
Serialize obj to a JSON formatted str.(字符串表示的json对象) Skipkeys:默认值是False,如果dict的keys内的数据不是python的基本类型(str,unicode,int,long,float,bool,None),设置为False时,就会报TypeError的错误。此时设置成True,则会跳过这类key ensure_ascii:,当它为True的时候,所有非ASCII码字符显示为\uXXXX序列,只需在dump时将ensure_ascii设置为False即可,此时存入json的中文即可正常显示。) If check_circular is false, then the circular reference check for container types will be skipped and a circular reference will result in an OverflowError (or worse). If allow_nan is false, then it will be a ValueError to serialize out of range float values (nan, inf, -inf) in strict compliance of the JSON specification, instead of using the JavaScript equivalents (NaN, Infinity, -Infinity). indent:应该是一个非负的整型,如果是0就是顶格分行显示,如果为空就是一行最紧凑显示,否则会换行且按照indent的数值显示前面的空白分行显示,这样打印出来的json数据也叫pretty-printed json separators:分隔符,实际上是(item_separator, dict_separator)的一个元组,默认的就是(‘,’,’:’);这表示dictionary内keys之间用“,”隔开,而KEY和value之间用“:”隔开。 default(obj) is a function that should return a serializable version of obj or raise TypeError. The default simply raises TypeError. sort_keys:将数据根据keys的值进行排序。 To use a custom JSONEncoder subclass (e.g. one that overrides the .default() method to serialize additional types), specify it with the cls kwarg; otherwise JSONEncoder is used.
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import json data = {'username':['李华','二愣子'],'sex':'male','age':16} json_dic2 = json.dumps(data,sort_keys=True,indent=2,separators=(',',':'),ensure_ascii=False) print(json_dic2)
json注意点:
1.json写入时,只能一次性写入,无论多少数据只能套入一个字典中写入,所以不支持追加写入
2.json在文件中不认单引号。
3.无论数据怎么创建,只要满足json格式,就可以用json.loads出来。
pickle模块
json和pickle的区别
-
json,用于json字符串 和 字典数据类型进行转换
-
pickle,用于python中所有类型数据的文本化,持久化
pickle模块提供了四个功能:
dumps、dump(序列化,存)、loads(反序列化,读)、load (不仅可以序列化字典,列表...可以把python中任意的数据类型序列化)
- dumps(): 将python对象转换成字节数据
- loads(): 将字节数据转换成python对象
- dump(obj,文件句柄):将python对象转换成字节数据并写入文件,注意写入方式要用'wb',而且不能指定编码。
- load(文件句柄): 将文件中的字节数据读取出来并转换成python对象
注:dump,load有持久化特点,将代码存入文件永久保存。
# dumps(): 将对象(字典数据)转换成字节数据 dic = {'name': 'ryxiong', 'age': 18} print(pickle.dumps(dic)) # b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x07\x00\x00\x00ryxiongq\x02X\x03\x00\x00\x00ageq\x03K\x12u.' # loads(): 将字节数据的数据转换成对象(字典数据) b = b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x07\x00\x00\x00ryxiongq\x02X\x03\x00\x00\x00ageq\x03K\x12u.' print(pickle.loads(b)) # dump(obj,文件句柄):将对象(字典数据)转换成字节数据并写入文件,注意写入方式要用'wb',而且不能指定编码。 pickle.dump(dic,open('pickle.txt', 'wb')) # load(文件句柄): 将文件中的字节数据读取出来并转换成对象(字典数据) data = pickle.load(open('pickle.txt','rb')) print(data)
这时候机智的你又要说了,既然pickle如此强大,为什么还要学json呢?
这里我们要说明一下,json是一种所有的语言都可以识别的数据结构。
如果我们将一个字典或者序列化成了一个json存在文件里,那么java代码或者js代码也可以拿来用。
但是如果我们用pickle进行序列化,其他语言就不能读懂这是什么了~
所以,如果你序列化的内容是列表或者字典,我们非常推荐你使用json模块
但如果出于某种原因你不得不序列化其他的数据类型,而未来你还会用python对这个数据进行反序列化的话,那么就可以使用pickle。
shelve模块
shelve:返回类似字典的对象,可读可写,key必须是字符串,值可是任何类型
shelve只有一个方法:
- open():返回类似字典的对象,可读可写,key必须是字符串,值可是任何类型
import shelve f = shelve.open(r'shelve.txt') f['name'] = 'ryxiong' f['age'] = 26 f['hobby'] = {'hobby1':'prograhpy', 'hobby2':'reading'} print(f['name']) print(f['hobby']) f.close() # print(f['hobby']) # 报错,文件已关闭,无法操作 # 注:如果遇到字典写不进去的问题,在open()参数中增加参数writeback=True。 f = shelve.open(r'shelve.txt',writeback=True)
三、常用模块(二)
1.logging模块
日志的作用:
用来记录程序中的重要的操作,或者检测程序是否和预想一样执行
logging两种方法:函数式简单配置,logger对象配置
函数式简单配置
import logging logging.debug('debug message') logging.info('info message') logging.warning('warning message') logging.error('error message') logging.critical('critical message')
默认情况下Python的logging模块将日志打印到了标准输出中,且只显示了大于等于WARNING级别的日志,这说明默认的日志级别设置为WARNING(日志级别等级CRITICAL > ERROR > WARNING > INFO > DEBUG),默认的日志格式为日志级别:Logger名称:用户输出消息。
简单配置法缺点:
中文显示乱码
不能同时输出到文件和屏幕
灵活配置日志级别,日志格式,输出位置:
默认级别为warning,默认打印到终端
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')
为logging模块指定全局配置,针对所有logger有效,控制打印到文件中
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
可在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:用户输出的消息 logging.basicConfig()
logger对象配置
''' logger对象法 步骤: 1.创建logger对象 2.创建一个文件操作符 3.创建一个屏幕操作符 4.创建一个格式 5.logger 绑定文件操作符 6.logger 绑定屏幕操作符 7.文件操作符 绑定格式 8.屏幕操作符 绑定格式 '''
import logging # 1.创建logger对象 logger = logging.getLogger() logger.setLevel(logging.DEBUG) # 2.创建一个文件操作符 fh = logging.FileHandler('log',encoding='utf-8') # 3.创建一个屏幕操作符 sh = logging.StreamHandler() # 4.创建一个格式 fmt = logging.Formatter('%(asctime)s-%(name)s-%(levelname)s-%(message)s') # 5.给logger绑定文件操作符 logger.addHandler(fh) # 6.给logger绑定屏幕操作符 logger.addHandler(sh) # 7.给文件操作符绑定格式 fh.setFormatter(fmt) # 8.给屏幕操作符绑定格式 sh.setFormatter(fmt) 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指定日志显示格式。另外,可以通过:logger.setLevel(logging.Debug)设置级别,当然,也可以通过
fh.setLevel(logging.Debug)单对文件流设置某个级别。
logging模块的Formatter,Handler,Logger,Filter对象
#logger:产生日志的对象 #Filter:过滤日志的对象 #Handler:接收日志然后控制打印到不同的地方,FileHandler用来打印到文件中,StreamHandler用来打印到终端 #Formatter对象:可以定制不同的日志格式对象,然后绑定给不同的Handler对象使用,以此来控制不同的Handler的日志格式
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
''' 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,但是需要注意的是
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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的继承(了解)
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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 '''
应用
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
""" 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()
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
""" 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()
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
注意注意注意: #1、有了上述方式我们的好处是:所有与logging模块有关的配置都写到字典中就可以了,更加清晰,方便管理 #2、我们需要解决的问题是: 1、从字典加载配置:logging.config.dictConfig(settings.LOGGING_DIC) 2、拿到logger对象来产生日志 logger对象都是配置到字典的loggers 键对应的子字典中的 按照我们对logging模块的理解,要想获取某个东西都是通过名字,也就是key来获取的 于是我们要获取不同的logger对象就是 logger=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=''的配置
2.configparser模块
使用类似键值对套键值对的方式在文件中储存数据。文件是一个大字典,每一块是字典的键,每一块下面的键值对又是一个字典,作为每一个块的值。
配置文件样式如下
# 注释1 # 注释2 [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') #查看所有的标题 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'))
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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)
3.hashlib模块
'''概念''' 1、什么叫hash:hash是一种算法(3.x里代替了md5模块和sha模块,主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ,MD5 算法),该算法接受传入的内容,经过运算得到一串hash值 2、hash值的特点是: 只要传入的内容一样,得到的hash值必然一样=====>要用明文传输密码文件完整性校验 不能由hash值返解成内容=======》把密码做成hash值,不应该在网络传输明文密码 只要使用的hash算法不变,无论校验的内容有多大,得到的hash值长度是固定的
hash算法就像一座工厂,工厂接收你送来的原材料(可以用m.update()为工厂运送原材料),经过加工返回的产品就是hash值
md5和sha的区别:
md5:速度快,但是现在容易被破解
sha:密文长,更安全,但是速度慢
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
''' md5加密 ''' import hashlib m = hashlib.md5() # m=hashlib.sha256() # 选择加密方式,获取一个加密对象 print(m) # <md5 HASH object @ 0x000001F0F0807558> m.update('hello'.encode('utf-8')) # 将明文转成字节然后加密 print(m.hexdigest()) # 5d41402abc4b2a76b9719d911017c592
注意:把一段很长的数据update多次,与一次update这段长数据,得到的结果一样
但是update多次为校验大文件提供了可能。
以上加密算法虽然依然非常厉害,但时候存在缺陷,即:通过撞库可以反解。所以,有必要对加密算法中添加自定义key再来做加密。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
''' md5加密+加盐 ''' m1 = hashlib.md5('盐'.encode('utf-8')) # 这一步相当于给密码加盐 m1.update('passwd'.encode('utf-8')) ''' 256加密 ''' sha = hashlib.sha256('hello'.encode('utf-8')) # 这一步相当于给密码加盐 sha.update('alex'.encode('utf-8')) print(sha.hexdigest())
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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('密码是===>\033[46m%s\033[0m' %k) cryptograph='aee949757a2e698417463d47acac93df' break_code(cryptograph,make_passwd_dic(passwds))
python 还有一个 hmac 模块,它内部对我们创建 key 和 内容 进行进一步的处理然后再加密:
import hmac h = hmac.new('alvin'.encode('utf8')) h.update('hello'.encode('utf8')) print (h.hexdigest())#320df9832eab4c038b6c1d7ed73a5940
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#要想保证hmac最终结果一致,必须保证: #1:hmac.new括号内指定的初始key一样 #2:无论update多少次,校验的内容累加到一起是一样的内容 import hmac h1=hmac.new(b'egon') h1.update(b'hello') h1.update(b'world') print(h1.hexdigest()) h2=hmac.new(b'egon') h2.update(b'helloworld') print(h2.hexdigest()) h3=hmac.new(b'egonhelloworld') print(h3.hexdigest()) ''' f1bf38d054691688f89dcd34ac3c27f2 f1bf38d054691688f89dcd34ac3c27f2 bcca84edd9eeb86f30539922b28f3981 '''
4.suprocess模块
import subprocess ''' sh-3.2# ls /Users/egon/Desktop |grep txt$ mysql.txt tt.txt 事物.txt ''' res1=subprocess.Popen('ls /Users/jieli/Desktop',shell=True,stdout=subprocess.PIPE) res=subprocess.Popen('grep txt$',shell=True,stdin=res1.stdout, stdout=subprocess.PIPE) print(res.stdout.read().decode('utf-8')) #等同于上面,但是上面的优势在于,一个数据流可以和另外一个数据流交互,可以通过爬虫得到结果然后交给grep res1=subprocess.Popen('ls /Users/jieli/Desktop |grep txt$',shell=True,stdout=subprocess.PIPE) print(res1.stdout.read().decode('utf-8')) #windows下: # dir | findstr 'test*' # dir | findstr 'txt$' import subprocess res1=subprocess.Popen(r'dir C:\Users\Administrator\PycharmProjects\test\函数备课',shell=True,stdout=subprocess.PIPE) res=subprocess.Popen('findstr test*',shell=True,stdin=res1.stdout, stdout=subprocess.PIPE) print(res.stdout.read().decode('gbk')) #subprocess使用当前系统默认编码,得到结果为bytes类型,在windows下需要用gbk解码