Python_模块

Posted 2022-04-27 tangxuecheng

模块 module
01. 什么是模块:
模块是一个包含有一系列变量，函数，类等组成的程序组
模块是一个文件，模块文件通常以.py结尾
作用：
01. 让一些相关的变量，函数，类等有逻辑的组织在一起，使逻辑结构更加清晰
02. 模块中的变量，函数和类可提供给其它模块使用

02. 模块的分类:
内置模块(biultins), 在解释器的内部可以直接使用
标准库模块,安装python时已安装且可直接使用
第三方模块(通常为开源), 需要自己安装
用户自己编写的模块(可以作为其它人的第三方模块)

03. 模块的导入 import
import 语句
语法:
import 模块名1 [as 模块新名1][,模块名2 [as 模块新名2], ....]
示例:
import math # 导入数学模块
import sys, os # 导入 sys,os模块
作用：
　　将某模块整体导入到当前模块中
用法：
模块名.属性名
help(模块名) 查看模块内的变量，函数，类等

模块的导入顺序:
01. 先导入内置模块
02. 再导入第三方模块
03. 最后导入自定义模块

04. from import 语句:
语法:
from 模块名 import 模块属性名1 [as 属性新名1], 模块属性名2 [as 属性新名2], ...
作用：
将某模块内的一个或多个属性导入到当前模块的作用域
示例:
from math import pi, sqrt
from math import factorial as fac
from math import sin
area = pi * 10 ** 2 # 可以直接使用导入的函数名或变量名

05. from import *语句:
语法:
from 模块名 import *
作用：
将某模块的所有属性导入到当前模块
示例:
from math import *
print(sin(pi/2))
print(factorial(10))

06. 导入模块时的路径索引顺序:
01. 索引程序的运行时路径(当前路径)
02. 搜索 sys.path里提供的路径
03. 搜索内置模块

07. 模块化编程的优点:
01. 有利于多人合作开发
02. 使代码更加易于维护
03. 提高代码的复用率
04. 模块化编程有助于解决函数名和变量名冲突(重名)问题，模块内的变量的作用域为模块内全局

08. 模块的加载过程:
01. 在模块导入时，模块的所有语句都会执行
02. 如果一个模块已经导入，则再次导入时不会重新执行模块内的语句

09. 模块的重新加载:
import imp
imp.reload(mymod) # 重新加载已经加载过的mymod模块

10. 模块被导入和执行的过程:
01. 先搜索相关路径找模块(.py)
02. 判断是否有此模块对应的.pyc文件，如果没有此文件，则用.py文件 生成相应的.pyc文件再进行加载
03. 如果文件已经存在，则判断.pyc文件和.py文件的修改时间，再决定是否重新生成.pyc文件

11. 模块的编译 compile:
编译 解释执行
mymod.py --->> mymod.pyc ---> python3

12. 模块的文档字符串:
模块内第一行没有赋值给任何变量的字符串为文档字符
此文档字符串可以用help函数查看
说明：
模块的文档字符串被绑定在模块的 __doc__属性上

13. __file__属性:
用来绑定模块对应的文件路径名
示例:
import mymod2
print(mymod2.__file__)

14. 模块的 __name__ 属性:
用来记录模块自身的名字
作用：
01. 记录模块名
02. 用来判断是否为主模块
__name__ 说明：
01. 当此模块作为主模块(也就是第一个运行的模块)运行时,__name__绑定‘__main__‘
02. 当此模块不是主模块时，模块为文件名去掉‘.py‘

15. 模块的 __all__列表:
模块中的__all__列表是一个用来存放可导出属性的字符串列表
作用：
当用from import * 语句导入模块时，只导入 __all__ 列表内的属性

16. 模块的隐藏属性:
模块中以‘_‘ 开头的属性，在from import * 语句导入时，将不会导入，通常称这些属性为隐藏属性

17. 包(模块包) package:
包是将模块以文件夹的组织形式进行分组管理的方法
作用:
1. 将一系列模块进行分类管理，有利于防止命名冲突
2. 可以在需要时加载一个或部分模块而不是全部模块
包示例:
mypack/
__init__.py
menu.py
games/
__init__.py
contra.py # 魂斗罗
supermario.py # 超级玛丽
tanks.py # 坦克大战
office/
__init__.py
excel.py
word.py
powerpoint.py
包的导入语法:
如果是直接导入一个包,那么相当于执行了这个包中的__init__文件
并不会帮你把这个包下面的其他包以及py文件自动的导入到内存
如果你希望直接导入包之后,所有的这个包下面的其他包以及py文件都能直接通过包来引用
那么你要自己处理__init__文件
import 包名 [as 包别名]
import 包名.模块名 [as 模块新名]
import 包名.子包名.模块名 [as　模块新名]
from 包名 import 模块名 as 模块新名
from 包名.子包名 import 模块名 [as 模块新名]
from 包名.子包名.模块名 import 属性名[as 属性新名]
from 包名 import *
from 包名.模块名 import *

18. __init__.py 文件:
是常规包内必须存在的文件,__init__.py会在导入包时被自动调用
作用：
01. 编写此包的内容
02. 在内部添加包的文档字符串
03. 在__init__.py 文件内可以加载此包所依懒的其它模块

19. 包的__all__列表:
作用：
用来记录此包中有哪儿些子包或模块需要导入
当用from 包 import * 语句导入时，只查 找__all__中的模块或子包
说明:
__all__列表只在from xxx import *语句时起作用
说明：
当子包或子包内的模块被导入时，上一层的包也会被先导入
例如:
import mypack.games.contra
实质会先导入mypack,再导入games,再导入contra

20. 包的相对导入:
包的相对导入是指包内的模块的相互导入
语法:
from 相对路径包或模块 import 属性或模块名
或
from 相对路径包或模块 import *
相对路径:
在 from xxxx import 语句中，xxxx 部分可以使用相对路径
. 代表当前目录
.. 代表上一级目录
... 代表上二级目录
.... 以此类推
注：
1. 相对导入时不能超出包的外部
2. 相的导入要避免循环导入

21. 标准输入输出文件:
sys.stdin # 标准输入
sys.stdout # 标准输出
sys.stderr # 标准错误输出
模块名: sys
说明:
每一个python程序启动后都会有以上三个文件已经打开供我们使用
Linux下　Ctrl + D输入文件结束符

示例1:
# 此示例示意sys.stdin的用法
import sys
print("请输开始输入:")

# s = sys.stdin.read(10) # 默认从键盘获取数据
# print(s)
# s2 = sys.stdin.read(10)
# print(s2)

s = sys.stdin.read()
print("您刚才输入的是:", s)

示例2:
# 此程序示意标准输出sys.stdout 和标准错误输出 sys.stderr
import sys # 导入sys模块

sys.stdout.write("hello world\n")
# 等同于 print(‘hello world‘, end=‘\n‘)

# 以下程序会出错
# sys.stdout.close()
# print("程序结束!")
sys.stderr.write("我的出现是个错误！\n")


Python常用模块:

01. time 时间模块:
import time

# time()取时间戳-->做计算
print(time.time()) # 1553274079.3324106秒-->1970年凌晨到现在的时间秒

# localtime结构化时间-->当地时间
t = time.localtime() # 默认参数time.time()
print(t)
print(t.tm_year) # 打印年

# gmtime结构化时间-->UTC世界标准时间, 比中国时间慢8小时
print(time.gmtime()) # 格林时间

# mktime结构化时间转换成时间戳
print(time.mktime(t))

# strftime结构化时间转换成字符串时间
print(time.strftime("%Y-%m-%d %X", t)) # Y年 m月 d日 X时分秒 t结构化时间

# strptime将字符串时间转换成结构化时间
print(time.strptime("2019:03:23:01:26:11", "%Y:%m:%d:%X"))

# asctime()将结构化时间转换成固定的字符串表达方式-->默认参数取当前结构化时间
print(time.asctime()) # 周月日时分秒年

# ctime()将时间戳时间转换成固定的字符串表达方式-->默认参数取当前时间戳
print(time.ctime()) # 周月日时分秒年

# sleep()线程推迟指定时间运行，单位秒
time.sleep(1) # 睡一秒

# 日常时间显示
import datetime
print(datetime.datetime.now()) # 2019-03-23 01:54:52.165174

02. random 随机模块:
# random随机模块
import random
ret = random.random() # (0,1)随机取浮点数
ret = random.randint(1, 3) # [1, 3]随机取整数
ret = random.randrange(1, 3) # [1, 3)随机取整数
ret = random.choice([11, 22, 33]) # [可迭代序列]取随机值
ret = random.sample([11, 22, 33], 2) # [可迭代序列]取随机2个值
ret = random.uniform(1,3) # (1, 3)取指定范围的浮点数
print(ret)
item = [1, 2, 3, 4, 5]
random.shuffle(item) # 随机打乱列表的序列
print(item)

03. os 模块:
# os模块是与操作系统交互的一个模块
import os

# getcwd获取当前工作目录，即当前python脚本工作目录路径
print(os.getcwd()) # G:\PycharmProjects\11_模块\lnh_massage

# chdir改变当前脚本的工作目录，相当于shell下的cd命令
os.chdir("test1")
print(os.getcwd()) # G:\PycharmProjects\11_模块\lnh_massage\test1
os.chdir("..")
print(os.getcwd()) # G:\PycharmProjects\11_模块\lnh_massage

# curdir返回当前目录
print(os.curdir) # .

# pardir获取当前父目录字符串名
print(os.pardir) # ..

# makedirs 可递归创建文件夹
os.makedirs("makir1/mkdir2")

# removedirs 文件夹为空则可递归删除文件夹，知道非空为止
os.removedirs("makir1/mkdir2")

# mkdir 生成前单级目录
os.mkdir("test2")

# rmdir 删除单级空目录，目录不为空则无法删除
os.rmdir("test2")

# listdir 列出指定文件下的所有文件和子目录，包含影藏文件,返回一个列表
print(os.listdir("test1"))

# remove 删除一个文件
os.remove("test1/111")

# rename 重命名文件/目录
os.rename("test1", "test1")

# stat 获取文件/目录信息
print(os.stat(r"G:\PycharmProjects\11_模块\lnh_massage"))

# sep 查看操作系统的特定路径分割符
print(os.sep) # Windows为：“\”，Linux为：“/”

# linesep 查看当前平台使用的终止符
print("终止符", os.linesep) # win下“\r\n”,linux下“\n”

# pathsep 查看用于分割文件路径的字符串
print("分隔文件", os.pathsep) # win下“;”,linux下“:”

# name 以字符串指示查看当前使用平台
print("使用平台", os.name) # win下“nt”,linux下“posix”

# system 运行shell命令，直接显示
os.system("ping 127.0.0.1")

# environ 获取系统环境变量
print(os.environ)

# path.abspath() 返回规范化的path绝对路径
print(os.path.abspath(r"G:\PycharmProjects\11_模块\lnh_massage\test1")) # G:\PycharmProjects\11_模块\lnh_massage\test1

# path.split 将path分割成目录和文件名，返回元组
print(os.path.split(r"G:\PycharmProjects\11_模块\lnh_massage\test1")) # (‘G:\\PycharmProjects\\11_模块\\lnh_massage‘, ‘test1‘)

# path.dirname 返回path.abspath()的第一个元素，目录
print(os.path.dirname(r"G:\PycharmProjects\11_模块\lnh_massage\test1")) # G:\PycharmProjects\11_模块\lnh_massage

# basename 返回path.abspath()的第二个元素，文件名
print(os.path.basename(r"G:\PycharmProjects\11_模块\lnh_massage\test1")) # test1

# path.exists 判断path是否存在，返回布尔值
print(os.path.exists(r"G:\PycharmProjects\11_模块\lnh_massage\test1")) # True

# path.isabs 判断path是否是绝对路径，返回布尔值
print(os.path.isabs(r"G:\PycharmProjects\11_模块\lnh_massage\test1")) # True

# path.isfile 判断path是否是一个存在的文件，返回布尔值
print(os.path.isfile(r"G:\PycharmProjects\11_模块\lnh_massage\test1")) # False

# path.isdir 判断path是否是一个存在的目录
print(os.path.isdir(r"G:\PycharmProjects\11_模块\lnh_massage\test1")) # True

# path.join 路径拼接，会自动去找当前操作系统的路径分割符拼接
a = r"G:\PycharmProjects"
b = r"11_模块\lnh_massage\test1"
print(os.path.join(a, b)) # G:\PycharmProjects\11_模块\lnh_massage\test1

# path.getatime 返回path所指向的文件或目录最后一次存取时间
print(os.path.getatime(r"G:\PycharmProjects\11_模块\lnh_massage\test1")) # 1553962262.1905563

# path.getmtime 返回path所指向的文件或目录最后一次修改时间
print(os.path.getmtime(r"G:\PycharmProjects\11_模块\lnh_massage\test1")) # 1553962262.1905563

# path.getsize 返回path所指向的文件的大小， 单位为字节
print(os.path.getsize(r"G:\PycharmProjects\11_模块\lnh_massage\test1")) # 397

模块导入添加path路径示例:
import sys
import os
# lst = __file__.split(‘/‘)
# # base_path = ‘/‘.join(lst[:-2])
base_path = os.path.dirname(os.path.dirname(__file__))
sys.path.append(base_path)
from core import main

04. sys 模块:
# sys模块与python解释器交互的一个模块
import sys, time

# eixt(0) 退出程序
print(sys.exit(0))

# argv 命令行参数，返回列表，第一个元素是程序本身路径
print(sys.argv) # [‘D:\\ProgramData\\Anaconda3\\Scripts\\ipython‘]

# version 获取python解释器版本信息
print(sys.version) # 3.7.1 (default, Dec 10 2018, 22:54:23) [MSC v.1915 64 bit (AMD64)]

# path 返回模块的搜索路径
print(sys.path)

# platform 返回操作系统平台名称
print(sys.platform) # win32

# 进度条
for i in range(100):
sys.stdout.write("#") # 向屏幕显示相应的内容
time.sleep(0.1)
sys.stdout.flush() # 刷新缓存

05. json&pickle 模块:
import json # 序列化模块，将数据转换成json的字符串

dic = "name": "coco"
data = json.dumps(dic) # 转换成所有语言都支持的json的字符串
print(data)
print(type(data))
f = open("test2", "w")
# data = json.dump(dic, f) # 直接转化写入文件
f.write(data)
f.close()

f_read = open("test2", "r")
data1 = json.loads(f_read.read()) # 将json处理的字符串还原原来的数据类型
# data1 = json.load(f) # 直接读取还原
print(data1)
print(type(data1))
f_read.close()

# pickle 序列化模块，将数据转换成字节，还支持函数和类的转换
import pickle

dic1 = "name": "coco"
data2 = pickle.dumps(dic1) # 转换成所有语言都支持的pickle的bytes
print(data2)
print(type(data2))
f1 = open("test3", "wb")
# data = pickle.dump(dic1, f) # 直接转化写入文件
f1.write(data2)
f1.close()

f1_read = open("test3", "rb")
data3 = pickle.loads(f1_read.read()) # 将pickle处理的bytes还原原来的数据类型
# data3 = pickle.load(f) # 直接读取还原
print(data3)
print(type(data3))
f_read.close()

06. shelve 模块:
常用方式:
文件改动的比较少, 读文件的操作比较多
且大部分读取都需要基于某个key获得某个value
import shelve

f = shelve.open(r"shelve.txt") # 生成一个空文本
f["stu1_info"] = "name": "coco", "age": "26" # 将字典放入文本
f["stu2_info"] = "name": "angels", "age": "18"

f.close()
print(f.get("stu1_info")["age"]) # 26

07. xml 模块:
import xml.etree.ElementTree as ET # as 取别名

tree = ET.parse("xml_lesson") # parse解析xml,返回一个解析对象
root = tree.getroot() # getroot 取根节点
print(root.tag) # tag 拿到根节点的标签名

# 遍历xml文档
for child in root:
print(child.tag, child.attrib) # tag标签名，attrib标签属性
for i in child:
print(i.tag, i.text) # text标签的内容

# 只遍历year节点
for node in root.iter("year"): # iter指定拿root根下的某个节点
print(node.tag, node.text)

# 修改
for node in root.iter("year"):
new_year = int(node.text) + 1 # 修改year标签内容
node.text = str(new_year) # 重新赋值修改内容
node.set("updated", "yes") # 为year标签添加属性
tree.write("xml_lesson") # 把修改后内容从新写一个文件，同名则覆盖原文件

# 删除
for country in root.findall("country"): # findall 找root的所有country标签
rank = int(country.find("rank").text) # find 找country下的rank标签
if rank >= 50:
root.remove(country)
tree.write("xml_output") # 把修改后内容从新写一个文件，同名则覆盖原文件

# 创建一个xml
new_xml = ET.Element("namelist") # Element 创建根节点
name = ET.SubElement(new_xml, "name", attrib="enrolled": "yes")
age = ET.SubElement(name, "age", attrib="checked": "no")
sex = ET.SubElement(name, "sex")
sex.text = "26"

et = ET.ElementTree(new_xml) # 生成文档对象
et.write("xml_text.xml", encoding="utf-8", xml_declaration=True) # 写出到文档
ET.dump(new_xml) # 打印生成格式

08. re 正则模块:
import re

# 普通字符 findall("匹配规则", "匹配内容")
# findall会优先显示分组中的内容,要想取消分组优先,(?:正则表达式)
print(re.findall("coco", "my name is coco hao are you"))

# 元字符：. ^ $ * + ? [] | () \
# .通配符，除了\n以外的所有字符都可以用.代替,一个点代指1个字符
print(re.findall("m.....e", "my name is coco hao are you"))

# ^只能在字符串开头匹配内容
print(re.findall("^m..n", "my name is coco hao are you"))

# $只能在字符串结尾匹配内容
print(re.findall("e...u$", "my name is coco hao are you"))

# *匹配0-无穷次的内容
print(re.findall("^d*", "dddddefghddd"))

# +匹配1-无穷次的内容
print(re.findall("d+", "dddddefghddd"))

# ?匹配0次或者1次的内容
print(re.findall("ghf?", "dddddefghddd"))

# 匹配指定次数的内容
print(re.findall("ghd0,2", "dddddefghddd"))

# []字符集,字符集里的功能符号只有- ^ \
print(re.findall("x[yz]", "xyaaaxz"))
print(re.findall("x[a-z]", "xyappxcappxzapp")) # -范围
print(re.findall("x[^a-z]", "xyappxcappxzappx1")) # ^非
print(re.findall("\([^()]*\)", "1+(2*3+5-(2-(5-4)))")) # \转义

# \转义元字符
print(re.findall("5\*3\+2", "5*3+2-10"))
# \d：匹配任意十进制数，相当于[0-9]
print(re.findall("\d+", "1+(2*3+5-(2-(5-4)))"))
# \D：匹配任意非十进制数,相当于[^0-9]
print(re.findall("\D+", "1+(2*3+5-(2-(5-4)))"))
# \s：匹配任何空白字符，相当于[\t\r\f\v]
print(re.findall("\s+", "hello world"))
# \S：匹配任何非空白字符，相当于[^\t\r\f\v]
print(re.findall("\S+", "hello world"))
# \w：匹配任何字母数字，相当于[a-zA-z0-9_]
print(re.findall("\w+", "hello world 12345"))
# \W：匹配任何非字母数字，相当于[^a-zA-z0-9_]
print(re.findall("\W+", "hello world 12345"))
# \b：匹配一个特殊字符边界，如空格 & # 等
print(re.findall(r"lo\b", "hello hello#hello&")) # r 后面的内容pythonIDE不解释，交给re解释

# |管道符-->或
print(re.findall("ac|b", "123ac566546b"))

# ()分组
print(re.findall("(abc)+", "abc11abc22abc33"))
# search 如果search中有分组的话,通过group(n)就能够拿到group中的匹配的内容
# (?P<name>正则表达式) 表示给分组起名字
ret = re.search("(?P<name>[a-z]+)(?P<age>\d+)","coco26alex30").group("name")
print(ret) # coco

# mach查找方法
ret = re.match("a", "abc").group() # 通search，不同在以字符串开始出进行匹配
print(ret) # a

# split分割方法, 遇到分组 会保留分组内被切掉的内容
ret = re.split("[ab]", "abcd") # 先按a分割得""和"bcd"再对""和"bcd"按b分割
print(ret) # [‘‘, ‘‘, ‘cd‘]

# sub替换方法
ret = re.sub("\d+", "A", "d22d33sd44", 2)
print(ret) # dAdAsd44

# subn替换方法
ret = re.subn("\d+", "A", "d22d33sd44")
print(ret) # (‘dAdAsdA‘, 3)

# compile编译方法
# 节省时间:只有在多次使用某一个相同的正则表达式的时候,这个compile才会帮助我们提高程序的效率
com = re.compile("\d+")
ret = com.findall("avc11sss22ssgg33")
print(ret) # [‘11‘, ‘22‘, ‘33‘]

# finditer方法处理后返回迭代器, 空间效率
ret = re.finditer("\d+", "asd22sa33")
print(ret) # <callable_iterator object at 0x0000000003548BE0>
print(next(ret).group()) # 22
print(next(ret).group()) # 33

# ?:去优先级
ret= re.findall("www\.(baidu|163)\.com", "aawww.baidu.combb")
print(ret) # [‘baidu‘]
ret= re.findall("www\.(?:baidu|163)\.com", "aawww.baidu.combb")
print(ret) # [‘www.baidu.com‘]

09. logging 日志模块:
import logging

# basicConfig定义日志
logging.basicConfig(
level=logging.DEBUG, # 设置显示日志级别
filename="logger.log", # 设置追加写出日志
filemode="w", # 覆盖写入
format="%(asctime)s %(filename)s [line:%(lineno)d] %(message)s" # 设置写出格式
)

# 日志的五个级别
logging.debug("debug message") # 调试模式
logging.info("info message") # 基础信息
logging.warning("warning massage") # 警告
logging.error("error massage") # 错误
logging.critical("critical massage") # 严重错误

# getLogger创建对象定义日志
def logget():
logget = logging.getLogger() # 创建一个logger对象
fh = logging.FileHandler("logger1.log") # 创建一个文件管理操作符,向文件发送日志
ch = logging.StreamHandler() # 创建一个屏幕管理操作符,向屏幕发送日志

fm = logging.Formatter("%(asctime)s %(message)s") # 创建一个日志输出的格式,定义日志格式
fh.setFormatter(fm) # 文件管理操作符 绑定一个 格式
ch.setFormatter(fm) # 屏幕管理操作符 绑定一个 格式

logget.addHandler(fh) # logger对象 绑定 文件管理操作符
logget.addHandler(ch) # logger对象 绑定 屏幕管理操作符
logget.setLevel("DEBUG") # 设置日志显示级别
return logget

logget = logget()
logget.debug("debug message")
logget.info("info message")
logget.warning("warning massage")
logget.error("error massage")
logget.critical("critical massage")

10. configparser 配置文件模块:
import configparser

config = configparser.ConfigParser()

config["DEFAULT"] =
"Sever": "45",
"Compression": "yes",
"CompressionLevel": "9"

config["bt.org"] =
config["bt.org"]["User"] = "coco"

config["sever.com"] =
top = config["sever.com"]
top["Host Ip"] = "127.0.0.1"
top["Host Port"] = "8080"

with open("example.ini", "w") as configfile:
config.write(configfile)

# 查配置文件
config.read("example.ini")
print(config.sections()) # 读除默认块以外的块名[‘bt.org‘, ‘sever.com‘]
print(config["bt.org"]["user"]) # coco
for key in config:
print(key)

print(config.options("bt.org")) # [‘user‘, ‘sever‘, ‘compression‘, ‘compressionlevel‘]
print(config.items("bt.org")) # [(‘sever‘, ‘45‘), (‘compression‘, ‘yes‘), (‘compressionlevel‘, ‘9‘), (‘user‘, ‘coco‘)]
print(config.get("bt.org", "user")) # coco

# 添加，修改，删除
config.add_section("yun") # 添加块
config.set("yun", "k1", "11") # 添加键值对，同名覆盖即修改
config.remove_option("sever.com", "host port") # 删除块下的某个键值对
config.remove_section("sever.com") # 删除块及块里面的的所有键值对

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

11. hashlib 算法摘要模块:
import hashlib

# md5
# md5是一个算法,32位的字符串,每个字符都是一个十六进制
# md5算法 效率快 算法相对简单
obj = hashlib.md5("ssasdf".encode(encoding="utf8")) # 自定义加盐
obj.update("coco".encode(encoding="utf8")) # 原生md5加密
print(obj.hexdigest()) # 516dacada2fea0112265e3a474dee5fe

# sha256
obj = hashlib.sha256("ssasdf".encode(encoding="utf8")) # 自定义加盐
obj.update("coco".encode(encoding="utf8")) # 原生md5加密
print(obj.hexdigest()) # 577cce053410c4bf7ccee892b3d92c55f20c56b773276a326777a4535a021909

# sha1也是一个算法,40位的字符串,每个字符都是一个十六进制
# 算法相对复杂 计算速度也慢
md5_obj = hashlib.sha1()
md5_obj.update(s1.encode(‘utf-8‘))
res = md5_obj.hexdigest()
print(res,len(res),type(res))

# 动态加盐
username = input(‘username : ‘)
passwd = input(‘password : ‘)
md5obj = hashlib.md5(username.encode(‘utf-8‘))
md5obj.update(passwd.encode(‘utf-8‘))
print(md5obj.hexdigest()) # ee838c58e5bb3c9e687065edd0ec454f

# 文件的一致性校验
md5_obj = hashlib.md5()
with open(‘5.序列化模块_shelve.py‘,‘rb‘) as f:
md5_obj.update(f.read())
ret1 = md5_obj.hexdigest()

md5_obj = hashlib.md5()
with open(‘5.序列化模块_shelve.py.bak‘,‘rb‘) as f:
md5_obj.update(f.read())
ret2 = md5_obj.hexdigest()
print(ret1,ret2)

# 大文件的已执行校验
md5_obj = hashlib.md5()
with open(‘5.序列化模块_shelve.py.bak‘,‘rb‘) as f:
md5_obj.update(f.read())
# 循环 循环的读取文件内容
# 循环的来update
print(md5_obj.hexdigest())