一，什么是模块？

   常见的场景：一个模块就是一个包含了python定义和声明的文件，文件名就是模块名字加上.py的后缀。

   但其实import加载的模块分为四个通用类别：

　　1 使用python编写的代码（.py文件）

　　2 已被编译为共享库或DLL的C或C++扩展

　　3 包好一组模块的包

　　4 使用C编写并链接到python解释器的内置模块

1.1为何要使用模块？

如果你退出python解释器然后重新进入，那么你之前定义的函数或者变量都将丢失，因此我们通常将程序写到文件中以便永久保存下来，需要时就通过python test.py方式去执行，此时test.py被称为脚本script。

随着程序的发展，功能越来越多，为了方便管理，我们通常将程序分成一个个的文件，这样做程序的结构更清晰，方便管理。这时我们不仅仅可以把这些文件当做脚本去执行，还可以把他们当做模块来导入到其他的模块中，实现了功能的重复利用。

二  time与datetime模块

在Python中，通常有这几种方式来表示时间：

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

格式化的时间字符串(Format String)

结构化的时间(struct_time)：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时)

1 import time

2 #--------------------------我们先以当前时间为准,让大家快速认识三种形式的时间

3 print(time.time()) # 时间戳:1487130156.419527

4 print(time.strftime("%Y-%m-%d %X")) #格式化的时间字符串:'2017-02-15 11:40:53'

5 print(time.localtime()) #本地时区的struct_time

6 print(time.gmtime())    #UTC时区的struct_time

%a Locale’s abbreviated weekday name.

%A    Locale’s full weekday name.   

%b    Locale’s abbreviated month name.   

%B    Locale’s full month name.   

%c    Locale’s appropriate date and time representation.   

%d    Day of the month as a decimal number [01,31].   

%H    Hour (24-hour clock) as a decimal number [00,23].   

%I    Hour (12-hour clock) as a decimal number [01,12].   

%j    Day of the year as a decimal number [001,366].   

%m    Month as a decimal number [01,12].   

%M    Minute as a decimal number [00,59].   

%p    Locale’s equivalent of either AM or PM.    (1)

%S    Second as a decimal number [00,61].    (2)

%U    Week number of the year (Sunday as the first day of the week) as a decimal number [00,53]. All days in a new year preceding the first Sunday are considered to be in week 0.    (3)

%w    Weekday as a decimal number [0(Sunday),6].   

%W    Week number of the year (Monday as the first day of the week) as a decimal number [00,53]. All days in a new year preceding the first Monday are considered to be in week 0.    (3)

%x    Locale’s appropriate date representation.   

%X    Locale’s appropriate time representation.   

%y    Year without century as a decimal number [00,99].   

%Y    Year with century as a decimal number.   

%z    Time zone offset indicating a positive or negative time difference from UTC/GMT of the form +HHMM or -HHMM, where H represents decimal hour digits and M represents decimal minute digits [-23:59, +23:59].   

%Z    Time zone name (no characters if no time zone exists).   

%%    A literal '%' character.

其中计算机认识的时间只能是'时间戳'格式，而程序员可处理的或者说人类能看懂的时间有: '格式化的时间字符串'，'结构化的时间' ，于是有了下图的转换关系

1 #--------------------------按图1转换时间

2 # localtime([secs])

3 # 将一个时间戳转换为当前时区的struct_time。secs参数未提供，则以当前时间为准。

4 time.localtime()

5 time.localtime(1473525444.037215)

6

7 # gmtime([secs]) 和localtime()方法类似，gmtime()方法是将一个时间戳转换为UTC时区（0时区）的struct_time。

8

9 # mktime(t) : 将一个struct_time转化为时间戳。

10 print(time.mktime(time.localtime()))#1473525749.0

11

12

13 # strftime(format[, t]) : 把一个代表时间的元组或者struct_time（如由time.localtime()和

14 # time.gmtime()返回）转化为格式化的时间字符串。如果t未指定，将传入time.localtime()。如果元组中任何一个

15 # 元素越界，ValueError的错误将会被抛出。

16 print(time.strftime("%Y-%m-%d %X", time.localtime()))#2016-09-11 00:49:56

17

18 # time.strptime(string[, format])

19 # 把一个格式化时间字符串转化为struct_time。实际上它和strftime()是逆操作。

20 print(time.strptime('2011-05-05 16:37:06', '%Y-%m-%d %X'))

21 #time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=6,

22 #  tm_wday=3, tm_yday=125, tm_isdst=-1)

23 #在这个函数中，format默认为："%a %b %d %H:%M:%S %Y"。

1 #--------------------------按图2转换时间

2 # asctime([t]) : 把一个表示时间的元组或者struct_time表示为这种形式：'Sun Jun 20 23:21:05 1993'。

3 # 如果没有参数，将会将time.localtime()作为参数传入。

4 print(time.asctime())#Sun Sep 11 00:43:43 2016

5

6 # ctime([secs]) : 把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。如果参数未给或者为

7 # None的时候，将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。

8 print(time.ctime())  # Sun Sep 11 00:46:38 2016

9 print(time.ctime(time.time()))  # Sun Sep 11 00:46:38 2016

1 #--------------------------其他用法

2 # sleep(secs)

3 # 线程推迟指定的时间运行，单位为秒。

#时间加减

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(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)) #时间替换

三  random模块

1 import random

2 

3 print(random.random())#(0,1)----float    大于0且小于1之间的小数

4 

5 print(random.randint(1,3))  #[1,3]    大于等于1且小于等于3之间的整数

6 

7 print(random.randrange(1,3)) #[1,3)    大于等于1且小于3之间的整数

8 

9 print(random.choice([1,'23',[4,5]]))#1或者23或者[4,5]

10 

11 print(random.sample([1,'23',[4,5]],2))#列表元素任意2个组合

12 

13 print(random.uniform(1,3))#大于1小于3的小数，如1.927109612082716

14 

15 

16 item=[1,3,5,7,9]

17 random.shuffle(item) #打乱item的顺序,相当于"洗牌"

18 print(item)

生成随机验证码：

import random

def make_code(n):

    res=''

    for i in range(n):

        s1=chr(random.randint(65,90))

        s2=str(random.randint(0,9))

        res+=random.choice([s1,s2])

    return res

print(make_code(9))

四 os模块

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

os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径

os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd

os.curdir  返回当前目录: ('.')

os.pardir  获取当前目录的父目录字符串名：('..')

os.makedirs('dirname1/dirname2')    可生成多层递归目录

os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推

os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname

os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname

os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印

os.remove()  删除一个文件

os.rename("oldname","newname")  重命名文件/目录

os.stat('path/filename')  获取文件/目录信息

os.sep    输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"

os.linesep    输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"

os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:

os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'

os.system("bash command")  运行shell命令，直接显示

os.environ  获取系统环境变量

os.path.abspath(path)  返回path规范化的绝对路径

os.path.split(path)  将path分割成目录和文件名二元组返回

os.path.dirname(path)  返回path的目录。其实就是os.path.split(path)的第一个元素

os.path.basename(path)  返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素

os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False

os.path.isabs(path)  如果path是绝对路径，返回True

os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False

os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False

os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

os.path.getatime(path)  返回path所指向的文件或者目录的最后存取时间

os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间

os.path.getsize(path) 返回path的大小

在Linux和Mac平台上，该函数会原样返回path，在windows平台上会将路径中所有字符转换为小写，并将所有斜杠转换为反斜杠。

>>> os.path.normcase('c:/windows\\system32\\') 

'c:\\windows\\system32\\' 

规范化路径，如..和/

>>> os.path.normpath('c://windows\\System32\\../Temp/') 

'c:\\windows\\Temp' 

>>> a='/Users/jieli/test1/\\\a1/\\\\aa.py/../..'

>>> print(os.path.normpath(a))

/Users/jieli/test1

os路径处理

#方式一：不推荐使用

import os

#具体应用

import os,sys

possible_topdir = os.path.normpath(os.path.join(

    os.path.abspath(__file__),

    os.pardir, #上一级

    os.pardir,

    os.pardir

))

sys.path.insert(0,possible_topdir)

#方式二：推荐使用

os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

五 sys模块

1 sys.argv 命令行参数List，第一个元素是程序本身路径

2 sys.exit(n)        退出程序，正常退出时exit(0)

3 sys.version        获取Python解释程序的版本信息

4 sys.maxint        最大的Int值

5 sys.path          返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

6 sys.platform      返回操作系统平台名称

打印进度条

#=========知识储备==========

#进度条的效果

[#            ]

[##            ]

[###          ]

[####          ]

#指定宽度

print('[%-15s]' %'#')

print('[%-15s]' %'##')

print('[%-15s]' %'###')

print('[%-15s]' %'####')

#打印%

print('%s%%' %(100)) #第二个%号代表取消第一个%的特殊意义

#可传参来控制宽度

print('[%%-%ds]' %50) #[%-50s]

print(('[%%-%ds]' %50) %'#')

print(('[%%-%ds]' %50) %'##')

print(('[%%-%ds]' %50) %'###')

#=========实现打印进度条函数==========

import sys

import time

def progress(percent,width=50):

    if percent >= 1:

        percent=1

    show_str=('[%%-%ds]' %width) %(int(width*percent)*'#')

    print('\r%s %d%%' %(show_str,int(100*percent)),file=sys.stdout,flush=True,end='')

#=========应用==========

data_size=1025

recv_size=0

while recv_size < data_size:

    time.sleep(0.1) #模拟数据的传输延迟

    recv_size+=1024 #每次收1024

    percent=recv_size/data_size #接收的比例

    progress(percent,width=70) #进度条的宽度70

六 shutil模块

高级的 文件、文件夹、压缩包 处理模块

shutil.copyfileobj(fsrc, fdst[, length])

将文件内容拷贝到另一个文件中

1 import shutil

2 

3 shutil.copyfileobj(open('old.xml','r'), open('new.xml', 'w'))

shutil.copyfile(src, dst)

拷贝文件

shutil.copyfile('f1.log','f2.log')#目标文件无需存在

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)

拷贝文件和权限

1 import shutil

2 

3 shutil.copy('f1.log', 'f2.log')

shutil.copy2(src, dst)

拷贝文件和状态信息

1 import shutil

2 

3 shutil.copy2('f1.log', 'f2.log')

shutil.ignore_patterns(*patterns)

shutil.copytree(src, dst, symlinks=False, ignore=None)

递归的去拷贝文件夹

1 import shutil

2 

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

递归的去删除文件

1 import shutil

2 

3 shutil.rmtree('folder1')

shutil.move(src, dst)

递归的去移动文件，它类似mv命令，其实就是重命名。

1 import shutil

2 

3 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对象

1 #将 /data 下的文件打包放置当前程序目录

2 import shutil

3 ret = shutil.make_archive("data_bak", 'gztar', root_dir='/data')

4 

5 

6 #将 /data下的文件打包放置 /tmp/目录

7 import shutil

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

zipfile压缩解压缩

tarfile压缩解压缩

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

tarfile压缩解压缩

七  json&pickle模块

我们用过eval内置方法可以将一个字符串转成python对象，不过，eval方法是有局限性的，对于普通的数据类型，json.loads和eval都能用，但遇到特殊类型的时候，eval就不管用了,所以eval的重点还是通常用来执行一个字符串表达式，并返回表达式的值。

1 import json

2 x="[null,true,false,1]"

3 print(eval(x)) #报错，无法解析null类型，而json就可以

4 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(type(j))#<class 'str'>

f=open('序列化对象','w')

f.write(j)  #-------------------等价于json.dump(dic,f)

f.close()

#-----------------------------反序列化<br>

import json

f=open('序列化对象')

data=json.loads(f.read())#  等价于data=json.load(f)

python2与python3 pickle兼容性问题

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

python2与python3的pickle兼容性问题

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

十 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', 'tang'), ('age', '18'), ('is_admin', 'true'), ('salary', '31')]

#查看标题section1下user的值=>字符串格式

val=config.get('section1','user')

print(val) #tang

#查看标题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'))

基于上述模块给一个ini文档

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模块

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?')

print md5.hexdigest()

计算结果如下：

d26a53750bc40b38b65a520292f69306

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

md5 = hashlib.md5()

md5.update('how to use md5 in ')

md5.update('python hashlib?')

print md5.hexdigest()

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

import hashlib

sha1 = hashlib.sha1()

sha1.update('how to use sha1 in ')

sha1.update('python hashlib?')

print sha1.hexdigest()

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

摘要算法应用

任何允许用户登录的网站都会存储用户登录的用户名和口令。如何存储用户名和口令呢？方法是存到数据库表中：

name | password

--------+----------

michael | 123456

bob    | abc999

alice  | alice2008

如果以明文保存用户口令，如果数据库泄露，所有用户的口令就落入黑客的手里。此外，网站运维人员是可以访问数据库的，也就是能获取到所有用户的口令。正确的保存口令的方式是不存储用户的明文口令，而是存储用户口令的摘要，比如MD5：

username | password

---------+---------------------------------

michael  | e10adc3949ba59abbe56e057f20f883e

bob      | 878ef96e86145580c38c87f0410ad153

alice    | 99b1c2188db85afee403b1536010c2c9

考虑这么个情况，很多用户喜欢用123456，888888，password这些简单的口令，于是，黑客可以事先计算出这些常用口令的MD5值，得到一个反推表：

'e10adc3949ba59abbe56e057f20f883e': '123456'

'21218cca77804d2ba1922c33e0151105': '888888'

'5f4dcc3b5aa765d61d8327deb882cf99': 'password'

这样，无需破解，只需要对比数据库的MD5，黑客就获得了使用常用口令的用户账号。

对于用户来讲，当然不要使用过于简单的口令。但是，我们能否在程序设计上对简单口令加强保护呢？

由于常用口令的MD5值很容易被计算出来，所以，要确保存储的用户口令不是那些已经被计算出来的常用口令的MD5，这一方法通过对原始口令加一个复杂字符串来实现，俗称“加盐”：

hashlib.md5("salt".encode("utf8"))

经过Salt处理的MD5口令，只要Salt不被黑客知道，即使用户输入简单口令，也很难通过MD5反推明文口令。

但是如果有两个用户都使用了相同的简单口令比如123456，在数据库中，将存储两条相同的MD5值，这说明这两个用户的口令是一样的。有没有办法让使用相同口令的用户存储不同的MD5呢？

如果假定用户无法修改登录名，就可以通过把登录名作为Salt的一部分来计算MD5，从而实现相同口令的用户也存储不同的MD5。

摘要算法在很多地方都有广泛的应用。要注意摘要算法不是加密算法，不能用于加密（因为无法通过摘要反推明文），只能用于防篡改，但是它的单向计算特性决定了可以在不存储明文口令的情况下验证用户口令。

 hash算法就像一座工厂，工厂接收你送来的原材料（可以用m.update()为工厂运送原材料），经过加工返回的产品就是hash值

import hashlib

m=hashlib.md5()# m=hashlib.sha256()

m.update('hello'.encode('utf8'))

print(m.hexdigest())  #5d41402abc4b2a76b9719d911017c592

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('898oaFs09f'.encode('utf8'))

hash.update('alvin'.encode('utf8'))

print (hash.hexdigest())#e79e68f070cdedcfe63eaf1a2e92c83b4cfb1b5c6bc452d214c1b7e77cdfd1c7

模拟撞库：

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

h1=hmac.new('hello'.encode('utf-8'),digestmod='md5')

h1.update('world'.encode('utf-8'))

print(h1.hexdigest())

注意：

#要想保证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

十二 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解码