Python模块02/序列化/os模块/sys模块/haslib加密/collections

Python模块02/序列化/os模块/sys模块/haslib加密/collections

内容大纲

1.序列化

2.os模块

3.sys模块

4.haslib加密

5.collections

1.序列化

1.1 什么是序列化

# 什么是序列化 -- json
序列化模块就是将一个常见的数据结构转化成一个特殊的序列，并且这个特殊的序列还可以反解回去。它的主要用途：文件读写数据，网络传输数据。
# lit = [1,22,3,3,45]  # [1,22,3,3,45]
# s_lst = str(lit)
# print(s_lst,type(s_lst))
# print(list(s_lst))
# print(eval(s_lst))  # 禁止使用

1.2 json模块(重点)

json序列化只支持部分Python数据结构：
dict,list, tuple,str,int, float,True,False,None

json模块是将满足条件的数据结构转化成特殊的字符串，并且也可以反序列化还原回去。

用于网络传输：dumps、loads
用于文件写读：dump、load

1.dumps loads
            dumps 将对象转换(序列化)成字符串
            loads 将字符串转换(反序列化)成对象

		   将列表类型转换成字符串类型
            # lit = [1,22,3,3,45]
            # print(json.dumps(lit),type(json.dumps(lit)))
            # str_lst = json.dumps(lit)
            将字符串类型的字典转换成列表类型
            # lst = json.loads(str_lst)
            # print(lst,type(lst))

            将字典类型转换成字符串类型
            # dic = {'username':'宝元'}
            # str_dic = json.dumps(dic)  # 序列化
            # str_dic = json.dumps(dic,ensure_ascii=False)
            ensure_ascii=False 关闭ascii码
            # print(str_dic,type(str_dic))
            将字符串类型的字典转换成字典类型
            # dic1 = json.loads(str_dic)  # 反序列化
            # print(dic1,dic1["username"])
2.dump、load
           dump: 将对象转换(序列化)成字符串,写入文件
           load: 将文件中字符串转换(反序列)成对象
            
           将对象转换成字符串写入到文件当中
           #import json
	       #f = open('json_file.json','w')
	       #dic = {'k1':'v1','k2':'v2','k3':'v3'}
		   #json.dump(dic,f)
        
        	将文件中的字符串类型的字典转换成字典
             import json
			f = open('json_file.json')
			dic2 = json.load(f)  
			f.close()
			print(type(dic2),dic2)
		    f.close()
dump方法接收一个文件句柄，直接将字典转换成json字符串写入文件
load方法接收一个文件句柄，直接将文件中的json字符串转换成数据结构返回



json序列化存储多个数据到同一个文件中
# 对于json序列化，存储多个数据到一个文件中是有问题的，
#默认一个json文件只能存储一个json数据，但是也可以解决，
#举例说明：
            # import json
            # lit = [1,22,3,3,45]
            # 同时写多个内容 进行序列化
            # lst = [1,2,3,4,56,]
            # f = open("info","w",encoding="utf-8")
            # f.write(json.dumps(lst) + "
")
            # f.write(json.dumps(lst) + "
")
            # f.write(json.dumps(lst) + "
")
            # f.write(json.dumps(lst) + "
")
            # f.write(json.dumps(lst) + "
")
            # f.close()
            
            # 同时读多个内容进行反序列
            # f1 = open("info","r",encoding="utf-8")
            # for i in f1:
            #     l = json.loads(i)
            #     print(l)
            # f1.close()
总结:
    ensure_ascii:，当它为True的时候，所有非ASCII码字符显示为uXXXX序列，只需在dump时将ensure_ascii设置为False即可，此时存入json的中文即可正常显示。

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

1.3pickle模块

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

python所有对象进行转换
python自带的(只有python可以用)
# 两组4个方法:
#1. dumps loads
        # import pickle

        # lst = [12,3,4,5,768]
        # t_list = pickle.dumps(lst) # 转换成类似字节
        # print(t_list)
        # print(pickle.loads(t_list)[-1])

        # dic = {"user":"郭宝元"}
        # t_list = pickle.dumps(dic) # 转换成类似字节
        # print(t_list)
        # print(pickle.loads(t_list))

        # def func():
        #     print(111)

        # import json
        # fun = json.dumps(func)
        # print(fun)

        # fun = pickle.dumps(func)
        # print(fun)
        # pickle.loads(fun)()

#2. dump  load
# import pickle
# dic = {"usern":"baoyuian"}
# dic = {"usern":"宝元"}
# pickle.dump(dic,open("info","wb"))
# print(pickle.load(open("info","rb")))

# import pickle
# dic = {"user":"123"}
# pickle.dump(dic,open("info","ab"))

# import pickle
# dic = {"1":2}
# f = open("info","wb")
# s = "
".encode("utf-8")
# f.write(pickle.dumps(dic)+ s)
# f.write(pickle.dumps(dic)+ s)
# f.write(pickle.dumps(dic)+ s)
# f.close()
#
# f1 = open("info","rb")
# for i in f1:
#     print(pickle.loads(i))

推荐使用json
#   json是各种语言通用的
#   pickle(python私有)
# asdfasd

2.os模块

程序员通过python向操作系统发送指令(与操作系统交互的接口)
# os模块四组:
1.工作目录
# import os
# os.chdir("F:s24day06") # 路径切换
# print(os.curdir)  # 当前
# print(os.pardir)  # 父级
print(os.getcwd()) # 当前工作路径  ***

2.文件夹
# import os
os.mkdir("ttt") # 创建一个文件夹  ***
os.rmdir("ttt") # 删除一个文件夹  ***
os.makedirs("ttt/sss/ddd/ee")  # 递归创建文件夹     ***
os.removedirs("ttt/sss/ddd/ee")  # 递归删除文件夹   ***
print(os.listdir(r"F:s24day17"))  ***

3.文件
# import os
os.rename()  # 修改名字   ***
os.remove("info") # 删除文件  ***

4.路径
import os
print(os.path.abspath(r"01 今日内容.py"))  # 通过相对路径获取绝对路径  ***
# print(os.path.split(os.path.abspath(r"01 今日内容.py")))  #将路径以最后一个切割(路径,文件名)
print(os.path.dirname(r"F:s24day171 今日内容.py"))  # 获取路径 ***
# print(os.path.basename(r"F:s24day171 今日内容.py")) # 获取文件名 **
print(os.path.exists(r"F:s24day171 今日内容.py"))  # 判断这个路径是否存在  ***
print(os.path.isdir(r"F:s24day17"))     # 判断是不是路径  ***
print(os.path.isfile(r"01 今日内容.py"))  # 判断是不是文件  ***
# print(os.path.isabs(r"F:s24day171 今日内容.py"))     # 判断是不是绝对路径
print(os.path.join("D:\\","ttt","bbb"))    # 路径拼接 *****
# import time
# print(time.time())
# print(os.path.getatime(r"F:s24day174 序列化.py"))      # 最后的修改时间
# print(os.path.getctime(r"F:s24day174 序列化.py"))      # 最后的访问时间
# print(os.path.getmtime(r"F:s24day174 序列化.py"))      # 最后的访问时间
print(os.path.getsize(r"F:s24day09")) # 获取当前文件的大小***

3.sys模块

与python解释器交互的接口

# import sys
# if sys.argv[-1] == "alex":
#     print("dsb")
# else:
#     print("李业dsb")

print(sys.argv[-1]) # *** 当前文件运行['F:/s24/day17/06 sys.py']

# import sys
# print(sys.exit(1))   

# import sys
# print(sys.version)  # 获取解释器版本

import sys
print(sys.path)     # 添加自定义模块查找路径 *****

import sys
print(sys.platform)   # *** 区分操作系统然后进行相关逻辑操作

4.hashlib 加密模块

4.1 密码的加密

1.hashlib 加密:
你的密码是明文的，如果有人可以窃取到这个文件，那么你的密码就会泄露了。所以，一般我们存储密码时都是以密文存储,此模块有人称为摘要算法，也叫做加密算法，或者是哈希算法，散列算法等
2.工作原理简述:
通过一个函数，把任意长度的数据按照一定规则转换为一个固定长度的数据串
3.应用:
密码的加密
文件一致性校验

# alex:alex123
# alex:23lw23jky321jh4gqyt1234gj8b7t  # 加密后
# {"1234":23lw23jky321jh4gqyt1234gj8b7t}

md5,sha1,sha256,sha512
1.只要明文相同密文就是相同的
2.只要明文不相同密文就是不相同的
3.不能反逆(不能解密) -- md5中国人破解了

# alex:alex123
# alex:b75bd008d5fecb1f50cf026532e8ae67

# print(len("b75bd008d5fecb1f50cf026532e8ae67"))

加密:
    1.加密的内容
    2.将要加密的内容转成字节

# import hashlib
# md5 = hashlib.md5()
# md5.update("alex123".encode("utf-8"))
# print(md5.hexdigest())
#
# md5 = hashlib.md5()
# md5.update("alex".encode("utf-8"))
# print(md5.hexdigest())

# md5 = hashlib.md5()
# md5.update("alex123".encode("gbk"))
# print(md5.hexdigest())

# md5 = hashlib.md5()
# md5.update("alex123".encode("shift-jis"))
# print(md5.hexdigest())

# import hashlib
# sha1 = hashlib.sha256()
# sha1.update("alex123".encode("utf-8"))
# print(sha1.hexdigest())

# md5 = hashlib.md5()
# md5.update("alex123".encode("utf-8"))
# print(md5.hexdigest())

最常用是的md5,平时加密的时候使用sha1

加盐

加固定盐
# import hashlib
# md5 = hashlib.md5("常鑫".encode("utf-8"))
# md5.update("alex123".encode("utf-8"))
# print(md5.hexdigest())
#
# md5 = hashlib.md5()
# md5.update("alex123".encode("utf-8"))
# print(md5.hexdigest())


动态加盐

# user = input("username:")
# pwd = input("password")
#
# import hashlib
# md5 = hashlib.md5(user.encode("utf-8"))
# md5.update(pwd.encode("utf-8"))
# print(md5.hexdigest())

# md5 = hashlib.md5()
# md5.update(pwd.encode("utf-8"))
# print(md5.hexdigest())

# 767db14ed07b245e24e10785f9d28e29

# f = open(r"F:s24day17python-3.6.6-amd64.exe","rb")
# import hashlib
# md5 = hashlib.md5()
# md5.update(f.read())
# print(md5.hexdigest())

# ss = "baoyuanalextaibai"
# s = "baoyuan"
# s1 = "alex"
# s2 = "taibai"
# import hashlib
# md5 = hashlib.md5()
# md5.update(ss.encode("utf-8"))
# print(md5.hexdigest())
#
#
# md5 = hashlib.md5()
# md5.update(s.encode("utf-8"))
# md5.update(s1.encode("utf-8"))
# md5.update(s2.encode("utf-8"))
# print(md5.hexdigest())

# 节省内存

4.2 文件的一致性校验

#在我们下载一个软件时，往往都带有一个MD5或者shax值，当我们下载完成这个应用程序时你要是对比大小根本看不出什么问题，你应该对比他们的md5值，如果两个md5值相同，就证明这个应用程序是安全的，如果你下载的这个文件的MD5值与服务端给你提供的不同，那么就证明你这个应用程序肯定是植入病毒了（文件损坏的几率很低），那么你就应该赶紧删除，不应该安装此应用程序。

# f = open(r"F:s24day17python-3.6.6-amd64.exe","rb")
# import hashlib
# md5 = hashlib.md5()
# while True:
#     msg = f.read(1024)
#     if msg:
#         md5.update(msg)
#     else:
#         print(md5.hexdigest())
#         break

5.collections模块

# 1.namedtuple: 生成可以使用名字来访问元素内容的tuple
# 2.deque: 双端队列，可以快速的从另外一侧追加和推出对象
# 3.OrderedDict: 有序字典
# 4.defaultdict: 带有默认值的字典
5.Counter: 计数器，主要用来计数


from collections import namedtuple,deque
# Point = namedtuple('tu',["a","b","c"]) # 第一个参数是元组的名字,第二参数是元组中元素的[名字,名字]
# p = Point({"keu":(1,2,3,4)}, 20,10)
# print(p)
# tu = (1,2,32,34,4)
# print(tu)

# lst = deque([1,2,3,4,5,6,7])
# lst.append(8)
# lst.appendleft(0)
# lst.pop()
# lst.popleft()
# print(lst[4])

# 队列:先进先出
# 栈:先进后出  --  栈顶

# lst = [1,2,3,4]
# lst.append(5)
# lst.pop(0)

# 5.defaultdict: 带有默认值的字典
# from collections import defaultdict
# dic = defaultdict(list)
# dic["k1"].append(12)
# print(dic)

# li = [11,22,33,44,55,77,88,99,90]
# result = {"key1":[],"key2":[]}
# result = {}
# for row in li:
#     if row > 66:
#         if 'key1' not in result:
#             result['key1'] = []
#         result['key1'].append(row)
#     else:
#         if 'key2' not in result:
#             result['key2'] = []
#         result['key2'].append(row)
# print(result)

# from collections import defaultdict
# dic = defaultdict(set)
# li = [11,22,33,44,55,77,88,99,90]
# for i in li:
#     if i > 66:
#         dic["k1"].add(i)
#     else:
#         dic["k2"].add(i)
# print(dic)

from collections import Counter
# s = "1112233344aaa"
# s = [1,1,2,2,3,3]
# s = (1,2,3,3,4,5,6,7,78)
# print(dict(Counter(s)))  # ***
# 统计元素出现的次数

6.今日总结

"""
1.序列化:
    json:
        dumps loads  对象转成字符串
        dump load    对象转成字符串写入文件
        
    pickle:
        dumps loads  对象转成类似字节
        dump  load    对象转成类似字节写入文件
2.os
    工作目录:
        os.getcwd()
        os.chdir()
    文件夹
        os.mkdir()
        os.rmdir()
        os.makedirs() 
        os.removedirs()
        os.listdir()
    文件
        os.rename
        os.remove
    路径
        os.path.abspath()
        os.path.join()
        os.path.dirname()
        os.path.basename()
        os.path.isabs()
        os.path.isfile()
        os.path.isdir()
        os.path.exists() 
        os.path.getsize() 
        
3.sys:
    sys.argv 当做脚本执行的时候能够携带参数
    sys.exit()
    sys.path()
    sys.platform()
    
4.hashlib:
    md5,sha1,sha256,sha512
    加密 - 校验
    
    import hashlib
    md5 = hashlib.md5()
    md5.update(b"alex")
    md5.hexdigest()
    
    加盐: 加固定盐,动态盐
    import hashlib
    md5 = hashlib.md5(b"wusir")
    md5.update(b"alex")
    md5.hexdigest()

5.collections
    1.命名元组
    2.默认字典参数
    3.双端队列
    4.计数器 ***   
""""