Nine-常用模块

模块

　常用模块一

　　　　re模块

　　　　collection模块

　　　　时间模块

　　　　random模块

　　　　os模块

　　　　sys模块

　　　　序列化模块

　　常用模块二

　　　　hashlib模块

　　　　configparse模块

　　　　logging模块

正则

　　　正则表达式本身跟python没有什么关系，就是匹配字符串内容的一种规则

　　正则表达式

　　字符组 ： [字符组]

　　　在同一个位置可能出现的各种字符组成了一个字符组，在正则表达式中用[]表示

　　　字符分为很多类，比如数字、字母、标点等等。

　　　假如你现在要求一个位置"只能出现一个数字",那么这个位置上的字符只能是0、1、2...9这10个数之一

　 

　　 字符

　　量词

　　

　　.^$

　　　　

　　*+?{}

　　*+{}都是贪婪匹配，也就是尽可能匹配，后面加？使其变成惰性匹配

　　

　　字符集[ ][^]

　　分组()与 | [^]

　　转义符 \

　　贪婪匹配

　　在满足匹配时，匹配尽可能长的字符串，默认情况下，采用贪婪匹配

　

　　re模块

import re
ret = re.findall(r'\d', r'eva7 egon yuan')  # 返回所有满足匹配条件的结果,放在列表里
print(ret) #结果 : ['a', 'a']

　　search

ret = re.search('a', 'eva egon yuan')
if ret:
    print(ret.group())
#search从左到右依次找，找到一个就回来，需要使用group()获取返回值
#如果re.search找不到，就返回None。使用group会报错

　　match

ret = re.match('a', 'bva egon yuan')
print(ret.group())
#match从头开始匹配，匹配上了需要使用group来获取返回值
#匹配不上返回None，使用group会报错

　　split

'a,b'.split(',')  #[a,b]
ret = re.split('[ac]', 'abcd')  # 先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割
print(ret)  # ['', '', 'cd']

　　sub

ret = re.sub('\d', 'H', 'eva3egon4yuan4',1)   #replace(old,new,count)
                                              #sub(re,new,str,count)
print(ret)

　　subn

ret = re.subn('\d', 'H', 'eva3egon4yuan4')#将数字替换成'H'，返回元组(替换的结果,替换了多少次)
print(ret)

　　compile

obj = re.compile('\d{3}')  #将正则表达式编译成为一个 正则表达式对象，规则要匹配的是3个数字
ret = obj.search('abc123eeee') #正则表达式对象调用search，参数为待匹配的字符串
print(ret.group())  #结果 ： 123
#
# re.search('\d{3}','abc123eeee').group()
# re.search('\d{3}','bcd123eeee')
# re.search('\d{3}','efg123eeee')
# re.search('\d{3}','xyz123eeee')

　　finditer

ret = re.finditer('\d', 'ds3sy4784a')   #finditer返回一个存放匹配结果的迭代器
print(ret)  # <callable_iterator object at 0x10195f940>
for i in ret:
    print(i.group())
# print(next(ret).group())  #查看第一个结果
# print(next(ret).group())  #查看第二个结果
# print([i.group() for i in ret])  #查看剩余的左右结果　

　表示先匹配[1-9]\d{16}[0-9x]如果没有匹配上就匹配[1-9]\d{14}
 
　collections模块

在内置数据类型（dict、list、set、tuple）的基础上，collections模块还提供了几个额外的数据类型：Counter、deque、defaultdict、namedtuple和OrderedDict等。

　　1.namedtuple: 生成可以使用名字来访问元素内容的tuple

　　2.deque: 双端队列，可以快速的从另外一侧追加和推出对象

　　3.Counter: 计数器，主要用来计数

　　4.OrderedDict: 有序字典

　　5.defaultdict: 带有默认值的字典

　　namedtuple

from collections import Iterator  #迭代器
from collections import Iterable  #可迭代对象
from collections import namedtuple
point1 = (1,1)
x = point1[0]
y = point1[1]
P = namedtuple('Point',['x','y'])
p1 = P(1,2)
p2 = P(3,4)
print(p1.x)
print(p1.y)
print(p2.x)
print(p2.y)
# 描述一类东西的时候，这一类东西都有相同的特征。
# 想直接用特征的名字就描述这个值的时候，就可以用可命名元祖

　　deque 

使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低

deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈

import queue   #队列_多线程多进程
q = queue.Queue()
q.put([1])
q.put(2)      #处理任务
q.put(300)
q.put('aaa')
q.put('wahaha')
print(q.qsize())
print(q.get())
print(q.get())
print(q.get())
print(q.get())
print(q.get())   #hold住的功能
print(q.qsize())
print(q.get_nowait())  #如果没有不会hold住，且会报错

from collections import deque
dq = deque()
dq.append('a')
dq.append('b')
dq.appendleft('c')
print(dq.popleft())

　　OrderedDict

使用dict时，Key是无序的。在对dict做迭代时，我们无法确定Key的顺序。

如果要保持Key的顺序，可以用OrderedDict

注意，OrderedDict的Key会按照插入的顺序排列，不是Key本身排序

from collections import OrderedDict
od = OrderedDict([('a', [1,2,3,4]), ('b', 2), ('c', 3)])
for k in od:
    print(k,od[k])

l = [11,22,33,44,55,66,77,88,99,90]
dic = {}
for i in l:
    if i > 66:
        if 'k1' in dic:
            dic['k1'].append(i)
        else:
            dic['k1'] = []
            dic['k1'].append(i)

　defaultdict
使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict

from collections import defaultdict
def func():
    return 0
my_dict = defaultdict(func)
my_dict = {}
print(my_dict['k'])

　　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})

　  时间模块

　  表示时间的三种方式

　  在Python中，通常有这三种方式来表示时间：时间戳、元祖（struct_time）、格式化的时间字符串

　　（1）时间戳（timestamp）：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量，我们运行“type（time.time()）”，返回的是float类型

　　（2）格式化的时间字符串（Format String）：“1999-12-06”

%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身

　　（3）元祖（struct_time）：struct_time元祖共有九个元素：（年，月，日，时，分，秒，一年中的第几周，一年中的第几天等）

索引（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

#导入时间模块
>>>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)

　几种格式之间的转换

#时间戳-->结构化时间
#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

　　

#结构化时间-->字符串时间
#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)

　

#结构化时间 --> %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 %d %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' 

　　

import time
true_time=time.mktime(time.strptime('2017-09-11 08:30:00','%Y-%m-%d %H:%M:%S'))
time_now=time.mktime(time.strptime('2017-09-12 11:00:00','%Y-%m-%d %H:%M:%S'))
dif_time=time_now-true_time
struct_time=time.gmtime(dif_time)
print('过去了%d年%d月%d天%d小时%d分钟%d秒'%(struct_time.tm_year-1970,struct_time.tm_mon-1,
                                       struct_time.tm_mday-1,struct_time.tm_hour,
                                       struct_time.tm_min,struct_time.tm_sec))

　　random模块

>>> 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]

　　生成随机验证码

import random
def v_code():
    code = ''
    for i in range(6):
        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())

　 os模块

　　os模块是与操作系统交互的一个接口

os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd
os.curdir  返回当前目录: ('.')
os.pardir  获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2')    可生成多层递归目录
os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()  删除一个文件
os.rename("oldname","newname")  重命名文件/目录
os.stat('path/filename')  获取文件/目录信息
os.sep    输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep    输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")  运行shell命令，直接显示
os.popen("bash command).read()  运行shell命令，获取执行结果
os.environ  获取系统环境变量

os.path
os.path.abspath(path) 
返回path规范化的绝对路径 os.path.split(path) 将path分割成目录和文件名二元组返回 
os.path.dirname(path) 返回path的目录。
其实就是os.path.split(path)的第一个元素 
os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。
即os.path.split(path)的第二个元素

os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)  如果path是绝对路径，返回True
os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)  返回path所指向的文件或者目录的最后访问时间
os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小

 

　　注意：os.stat('path/filename')  获取文件/目录信息 的结构说明

stat 结构:

st_mode: inode 保护模式
st_ino: inode 节点号。
st_dev: inode 驻留的设备。
st_nlink: inode 的链接数。
st_uid: 所有者的用户ID。
st_gid: 所有者的组ID。
st_size: 普通文件以字节为单位的大小；包含等待某些特殊文件的数据。
st_atime: 上次访问的时间。
st_mtime: 最后一次修改的时间。
st_ctime: 由操作系统报告的"ctime"。在某些系统上（如Unix）是最新的元数据更改的时间，
在其它系统上（如Windows）是创建时间（详细信息参见平台的文档）。

　   sys模块

　　sys模块是与python解释器交互的一个接口

sys.argv           命令行参数List，第一个元素是程序本身路径
sys.exit(n)        退出程序，正常退出时exit(0),错误退出sys.exit(1)
sys.version        获取Python解释程序的版本信息
sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称

　异常处理

import sys
try:
    sys.exit(1)
except SystemExit as e:
    print(e)

　　序列化模块

　　序列化就是将原本的字典、列表等内容转换成一个字符串的过程

　　序列化的目的

　　1、以某种存储形式使自定义对象持久化

　　2、将一个对象从一个地方传递到另一个地方

　　3，是程序更具维护性

　　用于序列化的两个模块　

　　　　1、json，用于字符串和python数据类型间进行转换

　　　　　　优点：json是一种所有语言都可以识别的数据结构

　　　　　　缺点：可以转换的数据类型有限

　　　　2、pickle，用于python特有的类型和python的数据类型间进行转换

　　　　　　优点：pickle支持python所有数据类型之间的转换

　　　　　　缺点：仅限于python，不支持其他语言

　　json

　　json模块提供了四个功能：dumps、dump、loads、load

　　loads和dumps

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'}]　

　　load和dump

import json
f = open('json_file','w')
dic = {'k1':'v1','k2':'v2','k3':'v3'}
json.dump(dic,f)  #dump方法接收一个文件句柄，直接将字典转换成json字符串写入文件
f.close()

f = open('json_file')
dic2 = json.load(f)  #load方法接收一个文件句柄，直接将文件中的json字符串转换成数据结构返回
f.close()
print(type(dic2),dic2)

　　ensure_ascii关键字参数

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()

　　其他参数

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.

　　json的格式化输出

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)

　　pickle模块

　　piclkle模块同样提供了四个功能：dumps、dump（序列化，存）、loads（反序列化、读）、load（不仅可以序列化字典，列表，可以把python中任意的数据类型序列化）

import pickle
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = pickle.dumps(dic)
print(str_dic)  #一串二进制内容

dic2 = pickle.loads(str_dic)
print(dic2)    #字典

import time
struct_time  = time.localtime(1000000000)
print(struct_time)
f = open('pickle_file','wb')
pickle.dump(struct_time,f)
f.close()

f = open('pickle_file','rb')
struct_time2 = pickle.load(f)
print(struct_time2.tm_year)

　　shelve

　　shelve也是python提供给我们的序列化工具，比pickle用起来更简单一些。

　　shelve只提供给我们一个open方法，是用key来访问的，使用起来和字典类似

import shelve
f = shelve.open('shelve_file')
f['key'] = {'int':10, 'float':9.5, 'string':'Sample data'}  #直接对文件句柄操作，就可以存入数据
f.close()

import shelve
f1 = shelve.open('shelve_file')
existing = f1['key']  #取出数据的时候也只需要直接用key获取即可，但是如果key不存在会报错
f1.close()
print(existing)

　　这个模块有个限制，它不支持多个应用同一时间往同一个DB进行写操作。所以当我们知道我们的应用如果只进行读操作，我们可以让shelve通过只读方式打开DB

import shelve
f = shelve.open('shelve_file', flag='r')
existing = f['key']
f.close()
print(existing)

　　由于shelve在默认情况下是不会记录待持久化对象的任何修改的，所以我们在shelve.open()时候需要修改默认参数，否则对象的修改不会保存

import shelve
f1 = shelve.open('shelve_file')
print(f1['key'])
f1['key']['new_value'] = 'this was not here before'
f1.close()

f2 = shelve.open('shelve_file', writeback=True)
print(f2['key'])
f2['key']['new_value'] = 'this was not here before'
f2.close()

　　writeback方式有优点也有缺点。优点是减少了我们出错的概率，并且让对象的持久化对用户更加的透明了；但这种方式并不是所有的情况下都需要，首先，使用writeback以后，shelf在open()的时候会增加额外的内存消耗，并且当DB在close()的时候会将缓存中的每一个对象都写入到DB，这也会带来额外的等待时间。因为shelve没有办法知道缓存中哪些对象修改了，哪些对象没有修改，因此所有的对象都会被写入

　　hashlib模块

　　算法介绍

　　python的hashlib提供了常见的算法，如MD5，SHA1等等

　　摘要算法又称哈希算法、散列算法。它通过一个函数，把任意长度的数据转换为一个长度固定的数据串（通常用16进制的字符串表示）

　　摘要算法就是通过摘要函数 f()对任意长度的数据data计算出固定长度的摘要digest，目的是为了发现原始数据是否被人篡改过

　　摘要算法之所以能指出数据是否被篡改过，就是因为摘要函数是一个单向函数，计算 f(data)很容易，但通过digest反推data却非常困难。而且，对原始数据做一个bit的修改，都会导致计算出的摘要完全不同

　　我们以常见的摘要算法MD5为例，计算出一个字符串的MD5值

import hashlib
md5 = hashlib.md5()
md5.update('how to use md5 in python hashlib?'.encode())
print(md5.hexdigest())
print(md5.digest())


计算结果如下：
d26a53750bc40b38b65a520292f69306
b'\xd2jSu\x0b\xc4\x0b8\xb6ZR\x02\x92\xf6\x93\x06'

　　如果数据量很大，可以分块多次调用update()，最后计算结果是一样的

import hashlib
md5 = hashlib.md5()
md5.update('how to use md5 '.encode())
md5.update('in python hashlib?'.encode())
print(md5.hexdigest())


计算结果如下：
d26a53750bc40b38b65a520292f69306

　　任何允许用户登录的网站都会存储用户登录的用户名和口令，如果以明文保存用户口令，如果数据库泄露，所有用户的口令就落入黑客手里，因此正确的保存口令方式是不存储用户的明文口令，而是存储用户的口令摘要，如MD5

username | password
---------+---------------------------------
michael  | e10adc3949ba59abbe56e057f20f883e
bob      | 878ef96e86145580c38c87f0410ad153
alice    | 99b1c2188db85afee403b1536010c2c9

　　

用户登录

import hashlib
usr = input('username :')
pwd = input('password : ')
with open('userinfo') as f:
    for line in f:
        user,passwd,role = line.split('|')
        md5 = hashlib.md5()
        md5.update(bytes(pwd,encoding='utf-8'))
        md5_pwd = md5.hexdigest()
        if usr == user and md5_pwd == passwd:
            print('登录成功')　

　　撞库

　　撞库是黑客通过收集互联网已泄露的用户和密码信息，生成对应的字典表，尝试批量登录其他网站后，得到一系列可以登录的用户，很多用户在不同网站使用的是相同的账号密码，因此黑客可以通过获取用户在A网站的账户从而尝试登录B网站，这就可以理解为撞库攻击

　　加盐

　　加盐加密是一种对系统登录口令的加密方式，它的实现方式是将每一个口令同一个叫做"盐"(salt)的n位随机数相关联，无论何时只要口令改变，随机数就改变，随机数以未加密的方式存放在口令文件中，这样每个人都可以读，不再只保存加密过的口令，而是先将口令和随机数连接起来然后一同加密，加密后的结果放在口令文件中

加盐

import hashlib   
md5 = hashlib.md5(bytes('盐',encoding='utf-8'))
md5.update(b'123456')
print(md5.hexdigest())

　　

动态加盐

用户名 密码
使用用户名的一部分或者直接使用整个用户名作为盐
import hashlib  
md5 = hashlib.md5(bytes('盐',encoding='utf-8')+b'')
md5.update(b'123456')
print(md5.hexdigest())

　　MD5是最常见的摘要算法，速度很快，生成结果是固定的128bit字节，通常用一个32位的16进制字符串表示。另一种常见摘要算法是SHA1，调用SHA1和调用MD5完全类似

import hashlib
sha1 = hashlib.sha1()
sha1.update('how to use sha1 in python hashlib?'.encode())
print(sha1.hexdigest())


计算结果如下：
2c76b57293ce30acef38d98f6046927161b46a44

　　SHA1的结果是160bit字节，通常用一个40位的16进制字符串表示。比SHA1更安全的算法是SHA256和SHA512，不过越安全的算法越慢，而且摘要长度更长

　　configparse模块

　　cofigparse模块适用于配置文件的格式与windows ini文件类似，可以包含一个或多个节(section)，每个节可以有多个参数(键=值)

　　logging模块

 

转载于:https://www.cnblogs.com/gumo/p/7826599.html