Python全栈（第一期）Day20

今日主要内容：
实战作业要求
模块基本知识
序列化模块

一，昨日作业：实战

# 实战：
# 实战一：计算时间差

# 实战二：验证码

# 实战三：计算器
# 首先得到一个字符串
# 去空格
# 没有空格的字符串
# 先算最里层括号里的 ： 找括号 ，且括号里没有其他括号
# 得到了一个没有括号的表达式 ：只有加减乘除
# 从左到右先找到第一个乘除法 ：   # 循环
    # 乘除法第一个数的符号是不必匹配的
    # 找到乘除法如何计算呢：
        # 先判断是乘法还是除法
        # 如果是乘法就以‘*’分割得到的内容是字符串数据类型的数
        # 如果是除法就用'/'分割的内容是字符串数据类型的数
        # 转数据类型之后根据 '*','/'计算结果
        # 结果替换原来字符串中的内容
# 所有的乘除法都做完了
# 计算加减  —— 加减法
# 只有一个数了 就可以结束了

二，模块基本知识

# 所有的模块导入都应该尽量往上写
    # 内置模块
    # 扩展模块
    # 自定义模块
# 模块不会重复被导入 ： sys.moudles
# 从哪儿导入模块 : sys.path


#import
# import 模块名
    # 模块名.变量名 和本文件中的变量名完全不冲突
# import 模块名 as 重命名的模块名 ： 提高代码的兼容性
# import 模块1，模块2  #这种其实不推荐


#from import
# from 模块名 import 变量名
    #直接使用 变量名 就可以完成操作
    #如果本文件中有相同的变量名会发生冲突
# from 模块名 import 变量名字 as 重命名变量名
# from 模块名 import 变量名1，变量名2
# from 模块名 import *
    # 将模块中的所有变量名都放到内存中
    # 如果本文件中有相同的变量名会发生冲突
# from 模块名 import * 和 __all__ 是一对
    # 没有这个变量，就会导入所有的名字
    # 如果有all 只导入all列表中的名字
   
   
   
# __name__
# 在模块中 有一个变量__name__，
# 当我们直接执行这个模块的时候，__name__ == '__main__'
# 当我们执行其他模块，在其他模块中引用这个模块的时候，这个模块中的__name__ == '模块的名字'

三，序列化模块

1，基本知识

# 序列化 —— 转向一个字符串数据类型
# 序列 —— 字符串




# 以下两种情况需要序列化：
# 数据存储，写文件；
# 网络上传输的时候，只能传bytes；

# 从数据类型 --> 字符串的过程 序列化
# 从字符串 --> 数据类型的过程 反序列化
                                                         
# json *****（五星满分，非常重要）
# pickle ****
# shelve ***

# json： 
   # 数字 字符串 列表 字典 元组（通过中介列表）
    # 通用的序列化格式
    # 只有很少的一部分数据类型能够通过json转化成字符串
# pickle：
    # 所有的python中的数据类型都可以转化成字符串形式
    # pickle序列化的内容只有python能理解
    # 且部分反序列化依赖python代码
# shelve：
    # 序列化句柄
    # 使用句柄直接操作，非常方便

2，json:dumps+loads

# json dumps序列化方法 loads反序列化方法
dic = {1: "a", 2: 'b'}
print(type(dic), dic)
import json
str_d = json.dumps(dic)   # 序列化
print(type(str_d), str_d)

dic_d = json.loads(str_d)  # 反序列化
print(type(dic_d), dic_d)

输出结果：
<class ‘dict’> {1: ‘a’, 2: ‘b’}
<class ‘str’> {“1”: “a”, “2”: “b”}
<class ‘dict’> {‘1’: ‘a’, ‘2’: ‘b’}

3，json:dump+load

import json
#json dump load  和文件相关的操作
dic = {1: "a", 2: 'b'}
f = open('fff', 'w', encoding='utf-8')
json.dump(dic, f)
f.close()
f = open('fff')
res = json.load(f)
f.close()
print(type(res), res)

输出结果：
<class ‘dict’> {‘1’: ‘a’, ‘2’: ‘b’}

import json
# json dump load ，缺点：只能一次性写进去，一次性读出来。
dic = {1: "中国", 2: 'b'}
f = open('fff', 'w', encoding='utf-8')
json.dump(dic, f, ensure_ascii=False)
json.dump(dic, f, ensure_ascii=False)
f.close()
f = open('fff', encoding='utf-8')
res1 = json.load(f)
res2 = json.load(f)
f.close()
print(type(res1), res1)
print(type(res2), res2)

输出结果：
程序报错！！！！
该方式缺点：只能一次性写入，一次性读出。

4，json:处理文件的方法

l = [{'k': '111'}, {'k2': '111'}, {'k3': '111'}]
f = open('file', 'w')
import json
for dic in l:
    str_dic = json.dumps(dic)
    f.write(str_dic+'\n')
f.close()

f = open('file')
import json
l = []
for line in f:
    dic = json.loads(line.strip())
    l.append(dic)
f.close()
print(l)

输出结果：
[{‘k’: ‘111’}, {‘k2’: ‘111’}, {‘k3’: ‘111’}]

5,pickle

import pickle
dic = {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
str_dic = pickle.dumps(dic)
print(str_dic)  #一串二进制内容，虽然我们看不懂，但是不影响使用

dic2 = pickle.loads(str_dic)
print(dic2)    #字典

输出结果：
b’\x80\x03}q\x00(X\x02\x00\x00\x00k1q\x01X\x02\x00\x00\x00v1q\x02X\x02\x00\x00\x00k2q\x03X\x02\x00\x00\x00v2q\x04X\x02\x00\x00\x00k3q\x05X\x02\x00\x00\x00v3q\x06u.’
{‘k1’: ‘v1’, ‘k2’: ‘v2’, ‘k3’: ‘v3’}

import pickle
import time


struct_time1 = time.localtime(1000000000)
struct_time2 = time.localtime(2000000000)
f = open('pickle_file', 'wb')
pickle.dump(struct_time1, f)
pickle.dump(struct_time2, f)
f.close()
f = open('pickle_file', 'rb')
struct_time1 = pickle.load(f)
struct_time2 = pickle.load(f)
print(struct_time1.tm_year)
print(struct_time2.tm_year)
f.close()

输出结果：
2001
2033
假如我们现在打开文件，会发现文件中是乱码，我们是看不懂的。

6，shelve

import shelve
f = shelve.open('shelve_file')
f['key'] = {'int': 10, 'float': 9.5, 'string': 'Sample data'}  #直接对文件句柄操作，就可以存入数据
f.close()

import shelve
f1 = shelve.open('shelve_file')
existing = f1['key']  #取出数据的时候也只需要直接用key获取即可，但是如果key不存在会报错
f1.close()
print(existing)

输出结果：
{‘int’: 10, ‘float’: 9.5, ‘string’: ‘Sample data’}

#以只读打开
import shelve
f = shelve.open('shelve_file', flag='r')
existing = f['key']
print(existing)

f.close()

f = shelve.open('shelve_file', flag='r')
existing2 = f['key']
f.close()
print(existing2)

输出结果：
{‘int’: 10, ‘float’: 9.5, ‘string’: ‘Sample data’}
{‘int’: 10, ‘float’: 9.5, ‘string’: ‘Sample data’}

补充知识点：

# writeback:由于shelve在默认情况之下是不会记录待持久化对象的任何改动，
# 所以我们在shelve.open()时候需要修改默认参数。

import shelve

f = shelve.open('shelve_file')
f['key'] = {'int': 10, 'float': 9.5, 'string': 'Sample data'}  #直接对文件句柄操作，就可以存入数据
f.close()

f1 = shelve.open('shelve_file')
print(f1['key'])
f1['key']['new_value'] = 'this was not here before'
f1.close()



f3 = shelve.open('shelve_file', writeback=True)
print(f3['key'])
f3.close()

输出结果：
自己执行时，并没有保存修改，以后再去查！