路飞学城Python-Day13

【2.常用模块-模块的种类和导入方法】

1.什么是模块？

在计算机程序的开发过程中，随着程序代码越写越多，在一个文件里代码就会越来越长、越来越不容易维护。

为了编写可维护的代码，我们把很多函数分组，分别放到不同的文件里，这样，每个文件包含的代码就相对较少，很多编程组织都采用这种代码方式，在Python中，一个.py文件就是一个模块(Moudle)

把各种功能写进文件里，把很多小文件模块互相调用。

2.使用模块有什么好处？

1）最大的好处就是提高了代码的可维护性，其次，编写代码不必从零开始，当一个模块编写完毕，就可以被其他地方引用，我们在编写程序的时候，也经常引用其他模块，包括Python内置的模块和来自第三方的模块

2）使用模块还可以避免函数名和变量名冲突，每个模块有独立的命令空间，因此相同名称的函数和变量完成可以分别存在不同的模块中，所以，我们在编写时，不必考虑名字会与其他模块冲突

总结：1.提高可维护性；2.可重用；3.避免函数名和变量名冲突

模块的分类：

1.内置标准模块（又称为标准库）执行help（modules）查看所有python自带模块列表

2.第三方开源模块，可通过pip insatall 模块名联网安装

3.自定义模块

导入模块的方式：import

python内置的模块有上百个，查询内置模块细节 help('modules')>>拿到自带的模块和第三方的模块，就是所有的模块

模块调用

import moudle

from * import moudle #用在一个模块里比较多的时候，只希望用某一个功能

from * import moudle as name #为导入的模块取一个别名

from moudle import * #导入模块里的所有py文件，不需要再写前缀了，但是尽量不要使用，因为不确定变量名会不会与函数名重复

注意：模块一旦被调用，就相当于执行了另外一个py文件里的代码

【3.常用模块-模块的导入路径】

自定义模块

创建一个py文件，就可以称为模块，可以在另外一个程序里导入

def sayhi():

print('hello')

import sayhi

模块查找路径

自己写的模块只能在当前路径下的程序里才能导入，换一个目录自己写的模块就会报错说找不到，这和导入的路径有关（sys.path）

默认先去当前目录去找py文件，然后按顺序依次去找文件，可以在sys.path里新增文件的导入路径

【4.常用模块-开源模块学习的安装方式】

python官方开源模块地址https://pypi.python.org/pypi,几乎涵盖了python所有可以做的任何功能，只需要注册账号就可以上传模块

1.下载源码，通过setup.py build安装

2.pip命令可以安装和删除(install&uninstall)

【5.常用模块-使用国内源下载模块】

国内下载国外的开源包 pip3 install moudle，由于是在国外，所以经常连接是会中断的

可以使用国内的豆瓣的python镜像，想用国内的豆瓣，只要加一个参数就可以了

sudo pip install -i http://pypi.douban.com/simple/moudle --trusted-host pypi.douban.com

使用

下载后，直接导入使用就可以了，跟自带的模块调用方法相同

import moudle

【6.常用模块-包及跨模块导入】

当模块文件越来越多的时候，就需要对模块文件进行划分，比如把负责跟数据库交互的都放一个文件夹中，把与页面交互相关的放一个文件夹

像上面这样，一个文件夹管理多个文件（模块），这个文件夹就可以称为包

那么不同模块之间的包是如何导入的呢？

包package也是可以导入的，直接import就是找当前目录下的文件，再按照sys.path找文件，如果找不到就报错

一个规范的包（package）一定包含一个py文件__init__.py，初始化文件，python就会拿到这个文件当做包

【7.常用模块-跨模块导入2】

import sys

sys.path.append('')

添加这个文件的环境变量里，而且这个环境变量的路径必须是相对路径，不能是绝对路径，如果是绝对路径就会影响使用

import os

import sys

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

sys.path.append(BASE_DIR)

程序在哪里执行，当前路径就在哪里，想要调用其他路径文件，就需要配置路径

【8.常用模块-相对导入】

在linux上进入一个路径，返回一层路径就可以用cd ..返回一层

同级目录下的互相调用

from . import moudel

在涉及到相对导入时，package所对应的文件夹必须正确的被python解释器视作package，而不是普通文件夹，否则由于不被视作package之间的嵌套关系实现python中包的相对导入。

1.文件夹中必须有__init__.py文件，该文件可以为空，但是必须存在该文件

2.不能作为顶层模块来执行文件夹中的py文件（即不能作为主函数的入口）

如果到了根目录，就不能再导入文件去执行了

【9.常用模块-time模块详解】

time.localtime([secs])：将一个时间戳转换为当前时区的struct_time。secs参数未提供，则以当前时间为准。
time.gmtime([secs])：和localtime()方法类似，gmtime()方法是将一个时间戳转换为UTC时区（0时区英国时间格式）的struct_time。
time.time()：返回当前时间的时间戳。
time.mktime(t)：将一个struct_time转化为时间戳。
time.sleep(secs)：线程推迟指定的时间运行。单位为秒。
time.asctime([t])：把一个表示时间的元组或者struct_time表示为这种形式：'Sun Oct 1 12:04:38 2017'。如果没有参数，将会将time.localtime()作为参数传入。
time.ctime([secs])：把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。如果参数未给或者为None的时候，将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。
time.strftime(format[, t])：把一个代表时间的元组或者struct_time（如由time.localtime()和time.gmtime()返回）转化为格式化的时间字符串。如果t未指定，将传入time.localtime()。

举例：time.strftime("%Y-%m-%d %X", time.localtime()) #输出'2017-10-01 12:14:23'

time.strptime(string[, format])：把一个格式化时间字符串转化为struct_time。实际上它和strftime()是逆操作。

注意：

1.常用的字符串 %Y-%m-%d %H:%M:%S

2.字符串反转时间戳time.strptime(%Y-%m-%d %H:%M:%S)

【10.常用模块-datetime模块详解】

相比于time模块，datetime模块的接口则更直观、更容易调用

datetime.date：表示日期的类。常用的属性有year, month, day；
datetime.time：表示时间的类。常用的属性有hour, minute, second, microsecond；
datetime.datetime：表示日期时间。
datetime.timedelta：表示时间间隔，即两个时间点之间的长度。
datetime.tzinfo：与时区有关的相关信息。（这里不详细充分讨论该类，感兴趣的童鞋可以参考python手册）

1.d=datetime.datetime.now() 返回当前的datetime日期类型

d.timestamp(),d.today(), d.year,d.timetuple()等方法可以调用

2.datetime.date.fromtimestamp(322222) 把一个时间戳转为datetime日期类型
3.时间运算(只支持days hours minutes seconds)

>>> datetime.datetime.now()

datetime.datetime(2017, 10, 1, 12, 53, 11, 821218)

>>> datetime.datetime.now() + datetime.timedelta(4) #当前时间 +4天

datetime.datetime(2017, 10, 5, 12, 53, 35, 276589)

>>> datetime.datetime.now() + datetime.timedelta(hours=4) #当前时间+4小时

datetime.datetime(2017, 10, 1, 16, 53, 42, 876275)

4.时间替换

>>> d.replace(year=2999,month=11,day=30)

datetime.date(2999, 11, 30)

【11.常用模块-random模块详解】

程序中有很多地方需要用到随机字符，比如登录网站的随机验证码，通过random模块可以很容易生成随机字符串

>>> random.randrange(1,10) #返回1-10之间的一个随机数，不包括10

>>> random.randint(1,10) #返回1-10之间的一个随机数，包括10

>>> random.randrange(0, 100, 2) #随机选取0到100间的偶数

>>> random.random() #返回一个随机浮点数

>>> random.choice('abce3#$@1') #返回一个给定数据集合中的随机字符

'#'

>>> random.sample('abcdefghij',3) #从多个字符中选取特定数量的字符

['a', 'd', 'b']

#生成随机字符串

>>> import string

>>> ''.join(random.sample(string.ascii_lowercase + string.digits, 6))

'4fvda1'

#洗牌

>>> a

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> random.shuffle(a)

>>> a

[3, 0, 7, 2, 1, 6, 5, 8, 9, 4]

【12.常用模块-os模块详解】

os 模块提供了很多允许你的程序与操作系统直接交互的功能

得到当前工作目录，即当前Python脚本工作的目录路径: os.getcwd()

返回指定目录下的所有文件和目录名:os.listdir()

函数用来删除一个文件:os.remove()

删除多个目录：os.removedirs（r“c：\python”）

检验给出的路径是否是一个文件：os.path.isfile()

检验给出的路径是否是一个目录：os.path.isdir()

判断是否是绝对路径：os.path.isabs()

检验给出的路径是否真地存:os.path.exists()

返回一个路径的目录名和文件名:os.path.split() e.g os.path.split('/home/swaroop/byte/code/poem.txt') 结果：('/home/swaroop/byte/code', 'poem.txt')

分离扩展名：os.path.splitext() e.g os.path.splitext('/usr/local/test.py') 结果：('/usr/local/test', '.py')

获取路径名：os.path.dirname()

获得绝对路径: os.path.abspath()

获取文件名：os.path.basename()

运行shell命令: os.system()

读取操作系统环境变量HOME的值:os.getenv("HOME")

返回操作系统所有的环境变量： os.environ

设置系统环境变量，仅程序运行时有效：os.environ.setdefault('HOME','/home/alex')

给出当前平台使用的行终止符:os.linesep Windows使用'\r\n'，Linux and MAC使用'\n'

指示你正在使用的平台：os.name 对于Windows，它是'nt'，而对于Linux/Unix用户，它是'posix'

重命名：os.rename（old， new）

创建多级目录：os.makedirs（r“c：\python\test”）

创建单个目录：os.mkdir（“test”）

获取文件属性：os.stat（file）

修改文件权限与时间戳：os.chmod（file）

获取文件大小：os.path.getsize（filename）

结合目录名与文件名：os.path.join(dir,filename)

改变工作目录到dirname: os.chdir(dirname)

获取当前终端的大小: os.get_terminal_size()

杀死进程: os.kill(10884,signal.SIGKILL)

【13.常用模块-sys模块详解】

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

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

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

sys.maxint 最大的Int值

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

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

sys.stdout.write('please:') #标准输出 , 引出进度条的例子，注，在py3上不行，可以用print代替

val = sys.stdin.readline()[:-1] #标准输入

sys.getrecursionlimit() #获取最大递归层数

sys.setrecursionlimit(1200) #设置最大递归层数

sys.getdefaultencoding() #获取解释器默认编码

sys.getfilesystemencoding #获取内存数据存到文件里的默认编码

【14.常用模块-shutil模块详解】

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

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

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

import shutil

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)

拷贝文件和权限

import shutil

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

shutil.copy2(src, dst)

拷贝文件和状态信息

import shutil

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

shutil.ignore_patterns(*patterns)

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

递归的去拷贝文件夹

import shutil

shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))

#目标目录不能存在，注意对folder2目录父级目录要有可写权限，ignore的意思是排除

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

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 两个模块来进行的，详细：

zipfile压缩&解压缩

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

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

【15.常用模块-序列化模块详解】

什么叫序列化？

序列化是指把内存里的数据类型转变成字符串，以使其能存储到硬盘或通过网络传输到远程，因为硬盘或网络传输时只能接受bytes

为什么要序列化？

你打游戏过程中，打累了，停下来，关掉游戏、想过2天再玩，2天之后，游戏又从你上次停止的地方继续运行，你上次游戏的进度肯定保存在硬盘上了，是以何种形式呢？游戏过程中产生的很多临时数据是不规律的，可能在你关掉游戏时正好有10个列表，3个嵌套字典的数据集合在内存里，需要存下来？你如何存？把列表变成文件里的多行多列形式？那嵌套字典呢？根本没法存。所以，若是有种办法可以直接把内存数据存到硬盘上，下次程序再启动，再从硬盘上读回来，还是原来的格式的话，那是极好的。

用于序列化的两个模块

json，用于字符串和 python数据类型间进行转换
pickle，用于python特有的类型和 python的数据类型间进行转换

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

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

import pickle

data = {'k1':123,'k2':'Hello'}

# pickle.dumps 将数据通过特殊的形式转换位只有python语言认识的字符串

p_str = pickle.dumps(data)

print(p_str)

#pickle.dump 将数据通过特殊的形式转换位只有python语言认识的字符串，并写入文件

with open('D:/result.pk','wb',encoding='utf8') as fp:

pickle.dump(data,fp)

import json

# json.dumps 将数据通过特殊的形式转换位所有程序语言都认识的字符串

j_str = json.dumps(data)

print(j_str)

#pickle.dump 将数据通过特殊的形式转换位只有python语言认识的字符串，并写入文件

with open('D:/result.json','wb',encoding='utf8') as fp:

json.dump(data,fp)

json vs pickle:

JSON:

优点：跨语言、体积小

缺点：只能支持int\str\list\tuple\dict

Pickle:

优点：专为python设计，支持python所有的数据类型

缺点：只能在python中使用，存储数据占空间大

【16.常用模块-序列化json模块详解】

【17.常用模块-序列化pickle模块详解】

【18.常用模块-序列化shelve模块详解】

shelve模块是一个简单的k,v将内存数据通过文件持久化的模块，可以持久化任何pickle可支持的python数据格式

序列化：

import shelve

f = shelve.open('shelve_test') # 打开一个文件

names = ["alex", "rain", "test"]

info = {'name':'alex','age':22}

f["names"] = names # 持久化列表

f['info_dic'] = info

f.close()

反序列化：

import shelve

d = shelve.open('shelve_test') # 打开一个文件

print(d['names'])

print(d['info_dic'])

#del d['test'] #还可以删除

【19.常用模块-xml模块详解】

xml是实现不同语言或程序之间进行数据交换的协议，跟json差不多，但json使用起来更简单，不过，古时候，在json还没诞生的黑暗年代，大家只能选择用xml呀，至今很多传统公司如金融行业的很多系统的接口还主要是xml。

xml的格式如下，就是通过<>节点来区别数据结构的:

<?xml version="1.0"?>

<data>

</country>

</country>

</country>

</data>

xml协议在各个语言里的都是支持的，在python中可以用以下模块操作xml 　

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)

for i in child:

print(i.tag,i.text)

#只遍历year 节点

for node in root.iter('year'):

print(node.tag,node.text)

修改和删除xml文档内容

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

tree.write("xmltest.xml")

#删除node

for country in root.findall('country'):

rank = int(country.find('rank').text)

if rank > 50:

root.remove(country)

tree.write('output.xml')

【20.常用模块-xml文档创建】

自己创建xml文档

import xml.etree.ElementTree as ET

new_xml = ET.Element("namelist")

name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})

age = ET.SubElement(name,"age",attrib={"checked":"no"})

sex = ET.SubElement(name,"sex")

sex.text = '33'

name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})

age = ET.SubElement(name2,"age")

age.text = '19'

et = ET.ElementTree(new_xml) #生成文档对象

et.write("test.xml", encoding="utf-8",xml_declaration=True)

ET.dump(new_xml) #打印生成的格式

【21.常用模块-configparser模块详解】

此模块用于生成和修改常见配置文档，当前模块的名称在 python 3.x 版本中变更为 configparser。

来看一个好多软件的常见配置文件格式如下

```cnf

[DEFAULT]

ServerAliveInterval = 45

Compression = yes

CompressionLevel = 9

ForwardX11 = yes

[bitbucket.org]

User = hg

[topsecret.server.com]

Port = 50022

ForwardX11 = no

```

解析配置文件

```py

>>> import configparser # 导入模块

>>> config = configparser.ConfigParser() #实例化(生成对象)

>>> config.sections() #调用sections方法

[]

>>> config.read('example.ini') # 读配置文件(注意文件路径)

['example.ini']

>>> config.sections() #调用sections方法(默认不会读取default)

['bitbucket.org', 'topsecret.server.com']

>>> 'bitbucket.org' in config #判断元素是否在sections列表内

True

>>> 'bytebong.com' in config

False

>>> config['bitbucket.org']['User'] # 通过字典的形式取值

'hg'

>>> config['DEFAULT']['Compression']

'yes'

>>> topsecret = config['topsecret.server.com']

>>> topsecret['ForwardX11']

'no'

>>> topsecret['Port']

'50022'

>>> for key in config['bitbucket.org']: print(key) # for循环 bitbucket.org 字典的key

...

user

compressionlevel

serveraliveinterval

compression

forwardx11

>>> config['bitbucket.org']['ForwardX11']

'yes'

```

其它增删改查语法

```python

[group1] # 支持的两种分隔符“=”, “:”

k1 = v1

k2:v2

[group2]

k1 = v1

import ConfigParser

config = ConfigParser.ConfigParser()

config.read('i.cfg')

# ########## 读 ##########

#secs = config.sections()

#print(secs)

#options = config.options('group2') # 获取指定section的keys

#print(options)

#item_list = config.items('group2') # 获取指定 section 的 keys & values ,key value 以元组的形式

#print(item_list)

#val = config.get('group1','key') # 获取指定的key 的value

#val = config.getint('group1','key')

# ########## 改写 ##########

#sec = config.remove_section('group1') # 删除section 并返回状态(true, false)

#config.write(open('i.cfg', "w")) # 对应的删除操作要写入文件才会生效

#sec = config.has_section('wupeiqi')

#sec = config.add_section('wupeiqi')

#config.write(open('i.cfg', "w")) #

#config.set('group2','k1',11111)

#config.write(open('i.cfg', "w"))

#config.remove_option('group2','age')

#config.write(open('i.cfg', "w"))

```

【22.常用模块-hashlib模块详解】

加密算法介绍

HASH

Hash，一般翻译做“散列”，也有直接音译为”哈希”的，就是把任意长度的输入（又叫做预映射，pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。

简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。

HASH主要用于信息安全领域中加密算法，他把一些不同长度的信息转化成杂乱的128位的编码里,叫做HASH值.也可以说，hash就是找到一种数据内容和数据存放地址之间的映射关系

MD5

什么是MD5算法

MD5讯息摘要演算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的密码杂凑函数，可以产生出一个128位的散列值（hash value），用于确保信息传输完整一致。MD5的前身有MD2、MD3和MD4。

MD5功能

输入任意长度的信息，经过处理，输出为128位的信息（数字指纹）；

不同的输入得到的不同的结果（唯一性）；

MD5算法的特点

压缩性：任意长度的数据，算出的MD5值的长度都是固定的
容易计算：从原数据计算出MD5值很容易
抗修改性：对原数据进行任何改动，修改一个字节生成的MD5值区别也会很大
强抗碰撞：已知原数据和MD5，想找到一个具有相同MD5值的数据（即伪造数据）是非常困难的。

MD5算法是否可逆？

MD5不可逆的原因是其是一种散列函数，使用的是hash算法，在计算过程中原文的部分信息是丢失了的。

MD5用途

防止被篡改：

比如发送一个电子文档，发送前，我先得到MD5的输出结果a。然后在对方收到电子文档后，对方也得到一个MD5的输出结果b。如果a与b一样就代表中途未被篡改。
比如我提供文件下载，为了防止不法分子在安装程序中添加木马，我可以在网站上公布由安装文件得到的MD5输出结果。
SVN在检测文件是否在CheckOut后被修改过，也是用到了MD5.

防止直接看到明文：

现在很多网站在数据库存储用户的密码的时候都是存储用户密码的MD5值。这样就算不法分子得到数据库的用户密码的MD5值，也无法知道用户的密码。（比如在UNIX系统中用户的密码就是以MD5（或其它类似的算法）经加密后存储在文件系统中。当用户登录的时候，系统把用户输入的密码计算成MD5值，然后再去和保存在文件系统中的MD5值进行比较，进而确定输入的密码是否正确。通过这样的步骤，系统在并不知道用户密码的明码的情况下就可以确定用户登录系统的合法性。这不但可以避免用户的密码被具有系统管理员权限的用户知道，而且还在一定程度上增加了密码被破解的难度。）

防止抵赖（数字签名）：

这需要一个第三方认证机构。例如A写了一个文件，认证机构对此文件用MD5算法产生摘要信息并做好记录。若以后A说这文件不是他写的，权威机构只需对此文件重新产生摘要信息，然后跟记录在册的摘要信息进行比对，相同的话，就证明是A写的了。这就是所谓的“数字签名”。

SHA-1

安全哈希算法（Secure Hash Algorithm）主要适用于数字签名标准（Digital Signature Standard DSS）里面定义的数字签名算法（Digital Signature Algorithm DSA）。对于长度小于2^64位的消息，SHA1会产生一个160位的消息摘要。当接收到消息的时候，这个消息摘要可以用来验证数据的完整性。

SHA是美国国家安全局设计的，由美国国家标准和技术研究院发布的一系列密码散列函数。

由于MD5和SHA-1于2005年被山东大学的教授王小云破解了，科学家们又推出了SHA224, SHA256, SHA384, SHA512，当然位数越长，破解难度越大，但同时生成加密的消息摘要所耗时间也更长。目前最流行的是加密算法是SHA-256 .

MD5与SHA-1的比较

由于MD5与SHA-1均是从MD4发展而来，它们的结构和强度等特性有很多相似之处，SHA-1与MD5的最大区别在于其摘要比MD5摘要长32 比特。对于强行攻击，产生任何一个报文使之摘要等于给定报文摘要的难度：MD5是2128数量级的操作，SHA-1是2160数量级的操作。产生具有相同摘要的两个报文的难度：MD5是264是数量级的操作，SHA-1 是280数量级的操作。因而,SHA-1对强行攻击的强度更大。但由于SHA-1的循环步骤比MD5多80:64且要处理的缓存大160比特:128比特，SHA-1的运行速度比MD5慢。

Python的提供的相关模块

用于加密相关的操作，3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

import hashlib

m = hashlib.md5()

m.update(b"Hello")

m.update(b"It's me")

print(m.digest())

m.update(b"It's been a long time since last time we ...")

print(m.digest()) #2进制格式hash

print(len(m.hexdigest())) #16进制格式hash

'''

def digest(self, *args, **kwargs): # real signature unknown

""" Return the digest value as a string of binary data. """

pass

def hexdigest(self, *args, **kwargs): # real signature unknown

""" Return the digest value as a string of hexadecimal digits. """

pass

'''

import hashlib

# ######## md5 ########

hash = hashlib.md5()

hash.update('admin')

print(hash.hexdigest())

# ######## sha1 ########

hash = hashlib.sha1()

hash.update('admin')

print(hash.hexdigest())

# ######## sha256 ########

hash = hashlib.sha256()

hash.update('admin')

print(hash.hexdigest())

# ######## sha384 ########

hash = hashlib.sha384()

hash.update('admin')

print(hash.hexdigest())

# ######## sha512 ########

hash = hashlib.sha512()

hash.update('admin')

print(hash.hexdigest())

【23.常用模块-subprocess模块详解】

【24.常用模块-subprocess模块详解2】

我们经常需要通过Python去执行一条系统命令或脚本，系统的shell命令是独立于你的python进程之外的，每执行一条命令，就是发起一个新进程，通过python调用系统命令或脚本的模块在python2有os.system，

>>> os.system('uname -a')

Darwin Alexs-MacBook-Pro.local 15.6.0 Darwin Kernel Version 15.6.0: Sun Jun 4 21:43:07 PDT 2017; root:xnu-3248.70.3~1/RELEASE_X86_64 x86_64

这条命令的实现原理是什么呢？(视频中讲，解释进程间通信的问题...)

除了os.system可以调用系统命令，,commands,popen2等也可以，比较乱，于是官方推出了subprocess,目地是提供统一的模块来实现对系统命令或脚本的调用

The subprocess module allows you to spawn new processes, connect to their input/output/error pipes, and obtain their return codes. This module intends to replace several older modules and functions:

os.system
os.spawn*

The recommended approach to invoking subprocesses is to use the run() function for all use cases it can handle. For more advanced use cases, the underlying Popen interface can be used directly.

The run() function was added in Python 3.5; if you need to retain compatibility with older versions, see the Older high-level API section.

三种执行命令的方法

subprocess.run(*popenargs, input=None, timeout=None, check=False, **kwargs) #官方推荐
subprocess.call(*popenargs, timeout=None, **kwargs) #跟上面实现的内容差不多，另一种写法
subprocess.Popen() #上面各种方法的底层封装

run()方法

Run command with arguments and return a CompletedProcess instance.The returned instance will have attributes args, returncode, stdout and stderr. By default, stdout and stderr are not captured, and those attributes will be None. Pass stdout=PIPE and/or stderr=PIPE in order to capture them.

If check is True and the exit code was non-zero, it raises a CalledProcessError. The CalledProcessError object will have the return code in the returncode attribute, and output & stderr attributes if those streams were captured.

If timeout is given, and the process takes too long, a TimeoutExpired exception will be raised.

The other arguments are the same as for the Popen constructor.

标准写法

subprocess.run(['df','-h'],stderr=subprocess.PIPE,stdout=subprocess.PIPE,check=True)

涉及到管道|的命令需要这样写

subprocess.run('df -h|grep disk1',shell=True)

#shell=True的意思是这条命令直接交给系统去执行，不需要python负责解析

call()方法

#执行命令，返回命令执行状态， 0 or 非0

>>> retcode = subprocess.call(["ls", "-l"])

#执行命令，如果命令结果为0，就正常返回，否则抛异常

>>> subprocess.check_call(["ls", "-l"])

0 #接收字符串格式命令，返回元组形式，第1个元素是执行状态，第2个是命令结果

>>> subprocess.getstatusoutput('ls /bin/ls')

(0, '/bin/ls')

#接收字符串格式命令，并返回结果

>>> subprocess.getoutput('ls /bin/ls')

'/bin/ls'

#执行命令，并返回结果，注意是返回结果，不是打印，下例结果返回给res

>>> res=subprocess.check_output(['ls','-l'])

>>> res

b'total 0\ndrwxr-xr-x 12 alex staff 408 Nov 2 11:05 OldBoyCRM\n'

Popen()方法

常用参数：

args：shell命令，可以是字符串或者序列类型（如：list，元组）
stdin, stdout, stderr：分别表示程序的标准输入、输出、错误句柄
preexec_fn：只在Unix平台下有效，用于指定一个可执行对象（callable object），它将在子进程运行之前被调用
shell：同上
cwd：用于设置子进程的当前目录
env：用于指定子进程的环境变量。如果env = None，子进程的环境变量将从父进程中继承。

下面这2条语句执行会有什么区别？

a=subprocess.run('sleep 10',shell=True,stdout=subprocess.PIPE)

a=subprocess.Popen('sleep 10',shell=True,stdout=subprocess.PIPE)区别是Popen会在发起命令后立刻返回，而不等命令执行结果。这样的好处是什么呢？

如果你调用的命令或脚本需要执行10分钟，你的主程序不需卡在这里等10分钟，可以继续往下走，干别的事情，每过一会，通过一个什么方法来检测一下命令是否执行完成就好了。

Popen调用后会返回一个对象，可以通过这个对象拿到命令执行结果或状态等，该对象有以下方法

poll()

Check if child process has terminated. Returns returncode

wait()

Wait for child process to terminate. Returns returncode attribute.

terminate()终止所启动的进程Terminate the process with SIGTERM

kill() 杀死所启动的进程 Kill the process with SIGKILL

communicate()与启动的进程交互，发送数据到stdin,并从stdout接收输出，然后等待任务结束

>>> a = subprocess.Popen('python3 guess_age.py',stdout=subprocess.PIPE,

stderr=subprocess.PIPE,stdin=subprocess.PIPE,shell=True)

>>> a.communicate(b'22')

(b'your guess:try bigger\n', b'')

send_signal(signal.xxx)发送系统信号

pid 拿到所启动进程的进程号

【25.常用模块-logging模块详解】

【26.常用模块-logging模块详解2】

【27.常用模块-logging模块日志过滤和日志文件截取】

【28.常用模块-re正则表达式】

【29.常用模块-re语法】

【30.常用模块-re表达式详解1】

【31.常用模块-re表达式详解2】

【32.常用模块-re表达式详解3】

【34.常用模块-re表达式详解4】

【35.常用模块-re表达式详解5】

【36.常用模块-re表达式详解6】

【37.常用模块-软件开发目录规范1】

【38.常用模块-软件开发目录规范2】