Python常用模块(二)

一、OS模块（重要）

OS作为计算机系统资源的管理者，主要跟当前程序所在的操作系统打交道

	基本格式
		import os
	os模块主要用来创建文件、目录、修改名字、删除文件、获取路径、判断是否是文件夹及文件

OS模块	作用
os.mkdir(r’文件名’)	创建单级目录(文件夹)
os.makedirs(r’父文件夹\子文件夹’)	创建多层目录(创建多层文件夹)
os.rmdir(r’文件名’)	删除单个文件夹，若文件夹下还有文件则报错
os.removedirs(r’父文件夹\子文件夹’)	删除多层文件夹，若文件夹下还有文件则报错
os.listdir()	获取当前执行文件所在的目录所有文件、子目录、隐藏文件，并以列表形式输出
os.listdir(r’D:\\')	获取指定的目录下的所有文件，并以列表形式输出
os.remove(r’文件名’)	删除所选中的文件
os.rename(r’文件名’)	重命名所选中的文件
os.getwcd()	获取当前执行文件所在的目录
os.chdir(r’…')	获取上一层级的目录
os.path.abspath(file)	获取当前执行文件的绝对路径
os.path.dirname(file)	获取当前执行文件所在的当前目录
os.path.exists(r’文件夹’)	获取当前选择的文件是否是文件夹 是返回True 否则False
os.path.exists(r’文件’)	获取当前选择的文件是否是文件 是返回True 否则False
os.path.isdir()	获取当前选择的文件是否是文件夹 是返回True 否则False
os.path.isfile()	获取当前选择的文件是否是文件 是返回True 否则False
os.path.join(文件名1,文件名2)	主要用来添加拼接路径就需要用到+号了
os.path.getsize(r’文件名+后缀’)	获取文件大小 英文一个字符 中文三个字符 以bytes为单位

	import os  # operate system

	'''创建目录(文件夹)'''
	os.mkdir(r'test')  # 相对路径 在执行文件所在的路径下创建目录 创建单级目录
	os.mkdir(r'd1\d2\d222')  # 不可以创建多级目录
	os.makedirs(r'd1\d2\d222')  # 可以创建多层递归目录
	os.makedirs(r'd3')  # 也可以创建单级目录
	
	'''删除目录(文件夹)'''
	os.rmdir(r'test')  # 可以删除单级目录
	os.rmdir(r'd1\d2\d222')  # 不可以一次性删除多级目录 会默认删除最后一个目录
	os.removedirs(r'd1\d2')  # 可以删除多级目录
	os.removedirs(r'd3')  # 只能删除空的多级目录，若有文件则报错
	os.rmdir(r'd3')  # 只能删除空的单级目录
	
	
	'''列举指定路径下的内容名称'''
	print(os.listdir())  # 列出指定目录下的所有文件和子目录，包含隐藏文件，并以列表打印出来
	print(os.listdir(r'D:\\'))  #指定列出目录所有文件、子目录、隐藏文件，以列表打印
	
	
	'''删除/重命名文件'''
	os.rename(r'd3\test.py',r'd3\test1.py')  # 重命名文件
	os.remove(r'd3\test1.py')  # 删除文件
	print(os.stat(r'd3\test.py'))  # 获取文件/目录信息
	
	'''获取/切换当前工作目录'''
	print(os.getcwd())  # 获取当前工作目录
	print(os.chdir('..'),os.getcwd())  # 切换到上一级目录
	os.mkdir(r'd2')
	
	'''动态获取项目根路径(重要)'''
	print(os.path.abspath(__file__))  # 获取执行文件的绝对路径
	print(os.path.dirname(__file__))  # 获取执行文件所在的当前目录
	print(os.path.split(__file__))  # 将路径分割成目录和文件名并以元组形式输出
	
	'''判断路径是否存在(文件、目录)'''
	print(os.path.exists(r'import time.py'))  # 判断文件路径是否存在 存在返回True否则False
	print(os.path.exists(r'd3'))  # 判断目录是否存在 存在返回True否则False
	print(os.path.isdir(r'd3'))  # 判断是否是目录 是则返回True否则False
	print(os.path.isfile(r'import time.py'))  # 判断是否是文件 是则返回True否则False
	print(os.path.isabs(r'd3'))  # 判断是否是绝对路径，是则返回True否则False
	
	'''路径接口(重要)'''
	s1 = r'E:\Pycharm Project Test'
	s2 = r'test.py'
	print(f'{s1}\{s2}')  # E:\Pycharm Project Test\test.py
	'''会自动检测是什么系统 windows\\ Linux//'''
	'''路径的拼接不要自己去打，因为不同的操作系统路径分隔符不一样'''
	print(os.path.join(s1,s2))  # E:\Pycharm Project Test\test.py
	print(os.path.join(s1,'d3','test.py'))  # 将多个路径组合拼接
	# E:\Pycharm Project Test\d3\test.py
	
	'''获取文件大小(字节)'''
	print(os.path.getsize(r'd3\test.py'))  # 获取指向的文件的大小
	print(os.path.getmtime(r'd3\test.py'))  # 返回指向的目录或文件最后修改的时间
	print(os.path.getatime(r'd3\test.py'))  # 返回指向的目录或文件最后访问的时间

三、sys模块

sys模块主要是与python解释器交互的一个接口
sys模块主要是跟python解释器打交道，可以查看路径、解释器版本信息、平台信息、编码信息

	import sys

	print(sys.path)  # 获取执行文件的sys.path
	print(sys.getrecursionlimit())  # 获取python解释器最大递归深度
	print(sys.setrecursionlimit(2000))  # 修改python解释器最大递归深度 自定义
	print(sys.version)  # 查看解释器版本信息
	print(sys.platform)  # 操作系统平台信息
	
	print(sys.argv)  # 命令行参数list，第一个元素是程序本身路径

四、序列化模块

1.序列化概念

当我们在编写Python程序时，经常需要把Python对象转换为可以存储或传输的格式，这个过程称为序列化。而将序列化后的数据再转换为Python对象的过程则称为反序列化。序列化模块就是用来处理这种对象与序列化数据之间的转换关系。

什么是序列？就是字符串
什么是序列化？：将原本的字典、列表等内容转换成一个字符串的过程叫做序列化
什么是反序列化？：把jason字符串转为其他数据类型的过程就是反序列化

序列化的目的:
1.以某种存储形式使自定义对象持久化
2.将对象从一个地方传递另一个地方
3.使程序更具维护性

Python中常用的序列化模块有pickle和json，它们分别支持不同的序列化格式和功能。下面我将详细介绍这两个模块的使用以及一些相关知识。

2.json模块

2.1、json的概念

json模块也称为序列化模块，序列化可以打破语言限制实现不同编程语言之间的数据交互
也是在我们不同编程语言之间数据交互必备的模块，意思就是在所有的语言中都有json模块，是通用的
不过只有一部分数据类型可以通过Json转成字符串类型。
我们每个语言之间交互都会乱码，而json模块在中间就是起到了翻译的角色，所以可以互通

2.2、json格式的数据是什么？

我们都知道数据信息都是基于网络二进制传输的，那么在python中只有字符串可以调用encode方法转换成二进制数据，所以json格式的数据也属于字符串

2.3、json的特征

json格式的数据有一个非常明显的特征，首先肯定是字符串形式、其次主要的标志性特征就是双引号。
我们直接打出来的双引号本质上输入的值还是单引号并且去掉也不会报错，只有json的双引号才是双引号，去掉会报错

dumps()	将其它数据类型转换成json格式字符串
loads()	将jason格式字符串转换成其它的数据类型
dump()	将其它数据以json格式字符串写入文件
load()	将文件中json格式字符串读取出来并转换成其它数据类型

	'''1.json模块'''
	import json
	
	d = {'name':'chen','gender':'male'}
	# 序列化
	res = json.dumps(d)
	print(res,type(res))  # <class 'str'> 转成为json字符串格式了
	# {"name": "chen", "gender": "male"}json格式的数据特点：里面都变成了双引号
	'上述这种情形就是json模式，要求是字符串类型并且引号都是双引号'
	
	# 反序列化
	res1 = json.loads(res)
	print(res1,type(res1))  # <class 'dict'> 转化为dict类型了
	# {'name': 'chen', 'gender': 'male'}
	
	
	'''通过网络传输的数据一定是二进制'''
	d = b'{"name":"chen","gender":"male"}'
	print(d,type(d))  # <class 'bytes'>
	
	'''把二进制数据转成python的字典'''
	print(d.decode('utf-8'),type(d.decode('utf-8')))
	res = d.decode('utf-8')  # 这里转换成json格式的字符串了
	#
	# 在通过反序列化loads使它转换回来
	print(json.loads(res),type(json.loads(res)))  # <class 'dict'>
	# {'name': 'chen', 'gender': 'male'}
	#
	#可以试一下是否和字典功能相同
	res1 = json.loads(res)
	print(res1['name'])  # chen 可以看到直接可以通过字典的key值取出对应的value值
	
	
	
	'''写入文件'''
	# 1.把字典格式的数据写入到文件中
	d = {'name':'chen','gender':'male'}
	## 写入的必须是二进制或者字符串
	with open(r'user.txt','a',encoding='utf-8')as f:
	    f.write(json.dumps(d))
	
	# 2.从文件中读取数据并且要是字典格式
	with open(r'user.txt','r',encoding='utf-8')as f1:
	    res = json.loads(f1.read())
	    print(res,type(res))
	
	res1 = json.loads(res)  # 通过反序列化把json格式字符串转化为dict格式
	print(res1,type(res1))  # {'name': 'chen', 'gender': 'male'} <class 'dict'>
	
	
	# 3.从文件中读取json格式的字符串。
	with open(r'user.txt','r',encoding='utf-8')as f:
	    # 先反序列化，然后再读取出来
	    res = json.load(f.read())
	    print(res,type(res))  # {'name': 'chen', 'gender': 'male'} <class 'dict'>
	
	
	# 4.非常方便的一种写入文件的方式
	with open(r'user.txt','w',encoding='utf-8')as f:
	    #先把数据序列化，然后把数据write进去
	    json.dump(d,f)

	'''取消中文自动转码'''
	d  = {'name':'chen','nation':'汉'}
	res = json.dumps(d) # 针对中文会自动转码 我们在查看的时候会不方便
	print(res)  # {"name": "chen", "nation": "\u6c49"}
	
	'''可以通过json.dumps()括号内的参数来，ensure_ascii，让它不转码'''
	res1 = json.dumps(d,ensure_ascii=False)
	print(res1)  # {"name": "chen", "nation": "汉"}

2.4、其他参数说明

ensure_ascii：当它为True的时候，所有非ASCII码字符显示为\uXXXX序列，只需在dump时将ensure_ascii设置为False即可，此时存入json的中文即可正常显示。

separators：分隔符，实际上是(item_separator, dict_separator)的一个元组，默认的就是(😅；这表示dictionary内keys之间用“,”隔开，而KEY和value之间用“：”隔开。

sort_keys：将数据根据keys的值进行排序。

Python编码为JSON类型转换对应表

Python	json
int/float	number(int/real)
list/tuple	array
str	string
dict	object
True	true
False	false
None	null

3.pckle模块

pickle模块实现了基本的数据序列化和反序列化，和json的功能类似。
但是pickle是Python特有的，无法和其他语言数据交互,并且几乎可以序列化所有数据类型，匿名函数不能序列化

pickle模块是将Python所有的数据结构以及对象等转化为bytes类型，然后还可以反序列化还原回去

	'''pickle模块在使用上和json模块是一样的，同样的两对四种方法'''
	
	'''pickle的使用方式跟json一样，json中两对四种方式，pick也是这四种'''
	
	'''
	能够被序列化的数据类型不一样，json能够序列化的数据类型是有限的：
	int/float/str/list/tuple/dict/True/False/None
	
	pickle能够序列化的类型：所有数据类型:
	但是它不好的地方在于，被pickle处理之后的数据只能够在Python中使用
	另外pickle序列化之后的结果是二进制格式的
	'''
	import pickle
	d = {'a':1,'b':12}
	ll = [1,2,3,4,5]
	'''序列化'''
	print(pickle.dumps(d))
	# b'\x80\x04\x95\x11\x00\x00\x00\x00\x00\x00\x00}\x94(\x8c\x01a\x94K\x01\x8c\x01b\x94K\x0cu.'
	res1 = pickle.dumps(d)
	
	print(pickle.dumps(ll))
	# b'\x80\x04\x95\x0f\x00\x00\x00\x00\x00\x00\x00]\x94(K\x01K\x02K\x03K\x04K\x05e.'
	res2 = pickle.dumps(ll)
	
	'''反序列化'''
	res = pickle.loads(res1)
	print(res)  # {'a': 1, 'b': 12}
	
	res3 = pickle.loads(res2)
	print(res3)  # [1, 2, 3, 4, 5]
	
	'''文件写入'''
	with open(r'user.txt','wb')as f:  # 因为是序列化后是二进制，所以得用b模式
	    pickle.dump(d,f)
	
	'''文件读取'''
	with open(r'user.txt','rb')as f1:
	    vls = pickle.load(f1)
	    print(vls)  # {'a': 1, 'b': 12}

五、hashlib模块(加密模块)

hashlib模块就是加密算法，摘要算法。什么是摘要算法？摘要算法又称之为哈希算法、散列算法。
它是通过一个函数，把任意长度的数据转换成一个长度固定的数据串(通常用16进制的字符串表示)。

1.什么是加密？

将明文数据处理成秘闻数据，让人无法看懂

2.为什么要加密？

为了保证数据的安全，防止让重要的数据泄露给别人(银行卡密码、支付宝密码)

3.如何判断当前数据是否是加密的

一般情况下是一串没有规则的字符串(数字、字母、符号)的组合而成的加密之后的结果

4.密文的长短有何讲究

密文越长表示使用的加密算法(数据的处理过程)越复杂

5.常见的加密算法有哪些

md5、base64、hmac、sha系列（帮密文产生函数）

6.加密算法的基本操作

	'''加密算法基本操作'''
	import hashlib
	
	'''1.选择加密算法'''
	md5 = hashlib.md5()
	
	'''2.传入明文数据'''
	md5.update(b'hello ')
	
	'''3.获取加密密文'''
	res = md5.hexdigest()
	print(res)  # f814893777bcc2295fff05f00e508da6

7.加密补充说明

	
	1.加密算法不变，内容如果相同，那么结果一定相同
	md5 = hashlib.md5()
	md5.update(b'hello-world-good-night-world')
	res = md5.hexdigest()
	print(res)  # f6f110331b4b4f3afe5a78dc1c3be6c9
	
	md51 = hashlib.md5()
	md51.update('hello-world-'.encode('utf-8'))
	md51.update(b'good-night-')
	md51.update(b'world')
	
	res1 = md51.hexdigest()
	print(res1)  # 0ba608f509d48763d0d07a9f185f3db2
	
	
	2.加密之后的结果是无法反解密的
	'''
	只能从明文到密文正向推导，无法从密文到明文反向推导
	常见的解密过程其实是提前猜测了很多种结果存入库中，等到用是比对而已
	'''
	
	3.加盐处理
	'''在明文中添加一些额外的干扰项'''
	# 1.选择加密算法
	md5 = hashlib.md5()
	# 2.传入明文数据
	md5.update('%@#$@#$@#%sdkfaj'.encode('utf-8'))
	md5.update(b'goodmorning')
	res = md5.hexdigest()
	print(res)
	'''在加密的明文中加一些额外的干扰项，加大数据的安全性，尽量加大被别人解密的可能性'''
	
	
	'''可以添加随机盐'''
	# 1.添加加密算法(md5/sha1/sha256)
	md5 = hashlib.md5()
	
	# 2.导入随机数模块
	import random # 导入随机数模块
	def sui(n):
	    count = ''
	    for i in range(n):
	        # 为了拼接所以把int类型转换为字符串类型
	        random_int = str(random.randint(1,9))  # 随机生成一个1到9之间的整数
	        random_upper = chr(random.randint(65,90))  # 用chr转换为ASICC码
	        random_lower = chr(random.randint(96,122))
	        res = random.choice([random_int,random_upper,random_lower])
	        count += res
	
	    return count
	
	rel = sui(4)
	
	
	# 3.传入明文数据+随机生成数盐
	md5.update(('hello'+rel).encode('utf-8'))
	vls = md5.hexdigest()
	print(vls)

8.加密实战操作

	'''注册功能'''
	import hashlib
	import random
	
	username = input('username>>>:').strip()
	password = input('password>>>:').strip()
	
	# 添加盐
	m = hashlib.md5('achen666'.encode('utf-8'))
	# 加密密码
	m.update(password.encode('utf-8'))
	
	res = m.hexdigest()[:16]  # 切割一下加密的数据
	
	date = '%s|%s' % (username,res)  # 存储
	with open(r'count.txt','w',encoding='utf-8')as f:
	    f.write(date)  # 写入
	
	
	'''登录功能'''
	username = input('username>>>:').strip()
	password = input('password>>>:').strip()
	
	m = hashlib.md5('achen666'.encode('utf-8'))
	m.update(password.encode('utf-8'))
	res = m.hexdigest()[:16]
	
	with open(r'count.txt','r',encoding='utf-8')as f1:
	    rel_name,rel_password = f1.read().split('|')
	    if username == rel_name and res == rel_password:
	        print('登录成功')
	    else:
	        print('用户名或密码错误')
	
	
	''''''
	
	
	'''最终玩法'''
	
	'''做随机盐'''
	import random
	import hashlib
	'''随机盐'''
	def yan(n):
	    count  = ''
	    for i in range(n):
	        random_int = str(random.randint(1,9))  # 随机生成一个1到9之间的整数
	        random_upper = chr(random.randint(65,90))  # 随机生成一个A-Z之间的字母
	        random_lower = chr(random.randint(96,122))  # 随机生成一个a-z之间的字母
	        random_chioce = random.choice([random_int,random_upper,random_lower])  # 从三个变量中随机生成一个变量的随机值
	        count += random_chioce
	
	    return count
	
	'''注册'''
	username = input('username>>>:').strip()
	password = input('password>>>:').strip()
	
	md5 = hashlib.md5()  #
	
	rel = yan(4)  # 把随机盐赋值给rel
	m_password = password+rel
	
	md5.update(m_password.encode('utf-8'))  # 生成加密
	res = md5.hexdigest()[:16]
	cun = '%s|%s|%s\n' % (username,res,rel)
	
	with open(r'count.txt','w',encoding='utf-8')as f:
	    f.write(cun)
	
	
	
	'''登录'''
	username = input('username>>>:').strip()
	password = input('password>>>:').strip()
	
	with open(r'count.txt','r',encoding='utf-8')as f1:
	    # rel_name,rel_password,rel_number = f1.read().split('|')
	    vls = f1.read().split('|')
	    rel_name,rel_password,rel_number = vls[0],vls[1],vls[2].strip()
	
	m_password = password+rel_number
	md5 = hashlib.md5()
	md5.update(m_password.encode('utf-8'))
	
	res = md5.hexdigest()[:16]
	
	if username == rel_name and res == rel_password:
	    print('登录成功')
	else:
	    print('用户名或密码错误')