1，什么是序列化--将原本的字典，列表等内容转换成一个字符串的过程就叫做序列化，字符串是有顺序的，序列化转向一个字符串的过程，我们平时说的序列，指的就是字符串。
2，为何要序列化？本来字符串是可以强转的，为何要序列化，因为字典转化成字符串的时候，他其实能实现的功能就变少了，所以一般是不会这样转的，什么情况下我们会把其他类型转化成字符串呢？两种情况：1，写文件，只能写字符串,应该是数据存储，比如数据库里面写的时候；2，网络传输的时候，只是能bytes类型，但是字典转化成bytes,必须先转成字符串，再转换成bytes。
3，序列化：从数据类型--》字符串的过程；反序列化：从字符串--》数据类型的过程
4，几个现成的模块，操作序列化，反序列化,三个模块；json模块，非常非常重要，一定要掌握，六星模块，需要和别人进行数据交互的时候，必须用json，一般情况下，json都可以实现;pickle 四星；shelve，三星，是Python3里面新出现的序列化解决方式，特点是比较好操作，实用性一般，知道有这么个模块就行
5，json相当于语言界的英语，国际通用语言，他也是一种通用的序列化格式，不只是Python，其他的语言，像JAVA啦，JS啦都在用的，加入我写Python，他写了C++，他需要我给他提供数据，那么我就可以从网上用JSON格式传给他，JSON就是这么一种通用的语言，传给谁，谁都认识。
每一种语言拥有的数据类型都是有限的，一定有一些是Python有的数据类型，其他语言没有的，如果想要把大家都通起来，那么要用尽量少的数据类型，所以JSON不是所有的数据类型都可以转的，只有很少的一部分数据类型可以通过转化成字符串。
6，应为因为JSON缺点所以出现了pickle，优点，所有的Python数据类型都可以转化成字符串数据类型，缺点是pickle序列化的内容，只有Python能理解。另外一个问题是，一些扩展模块里面的数据，必须两边都装同样的模块，内存里都有这个模块才可以认识，部分反序列化依赖python代码
7，shelve 操作简单，序列化句柄，拿着句柄就可以随便写了，使用句柄直接操作，非常方便。
8，json，dumps和loads，这种是对内存中的数据进行操作，操作完了数据还在内存中的。对象持久化是指将内存中的对象保存到可永久保存的存储设备中（如磁盘）的一种技术。
import json # json dumps 序列化方法，loads反序列化方法 dic = {'k1':'v1'} print(type(dic)) # <class 'dict'> str_d = json.dumps(dic) # 序列化 print(type(str_d),str_d) # <class 'str'> {"k1": "v1"} # 变成双引号了。json的字符串元素必须要用双引号引起来。 # '{"k1": "v1"}' dic_d = json.loads(str_d) print(type(dic_d),dic_d) # <class 'dict'> {'k1': 'v1'} # 哪些可以序列化：数字，字符串，列表，字典，元祖(json只认识列表，所以当成列表来序列化)， # 集合不可以序列化，json只可以转换很少的数据类型。 # 元祖是转化成列表来进行序列化的
9，json,dump和load是和文件相关的操作，每一个元素都有用“”括起来，转换成字符串
dic ={1:'a',2:'b'}
f = open("file_json.txt",mode='w',encoding="utf-8")
json.dump(dic,f) # 参数要加两个的，数据和文件句柄，县序列化，转化成一个字符串，然后再传进去。
f.close()
# {"1": "a", "2": "b"}
f = open('file_json.txt') # 不指定得话，操作系统默认是什么编码方式就是什么方式打开的，MAC是UTF-8，window是GBK，
# GBK和UTF-8兼容ASCII码，就是二者对于ASCII的编码方式都是1个字节，编码方式是一样的，不需要额外指定，不会乱的，
# 但是这个习惯不太好
res = json.load(f)
f.close()
print(type(res),res)
# <class 'dict'> {'1': 'a', '2': 'b'} 读出来了
10，ensure_ascii=False参数，这个参数即使不加，也不会影响读写操作，只是中途看的时候比较方便。以后遇到知道怎么解决就行
dic ={1:'中国',2:'b'}
f = open("file_json.txt",mode='w',encoding="utf-8")
# json.dump(dic,f)
json.dump(dic,f,ensure_ascii=False)
f.close()
# {"1": "u4e2du56fd", "2": "b"} # 如何在json文件里面显示出中文呢？
# {"1": "中国", "2": "b"}
f = open('file_json.txt')
res = json.load(f)
f.close()
print(type(res),res)
11，读写方式改成a 得话，那么是不能正常load的，因为写了多行，怎么办呢？那是一条一条读还是一次读呢？只可以一次性写进去，一次性读出来，分段读得话，不知道从哪儿开始读
dic ={1:'中国',2:'b'}
f = open("file_json.txt",mode='w',encoding="utf-8")
# json.dump(dic,f)
json.dump(dic,f,ensure_ascii=False)
json.dump(dic,f,ensure_ascii=False)
f.close()
# {"1": "中国", "2": "b"}{"1": "中国", "2": "b"}
f = open('file_json.txt')
res = json.load(f) # load的时候会报错
f.close()
print(type(res),res)
# json.decoder.JSONDecodeError: Extra data: line 1 column 22 (char 21)
12，想实现分段读，分段写怎么实现呢？
l =[{'k':'111'},{'k2':'111'},{'k3':'111'}]
# 把字典分别写进去，再分别load出来
f = open("file_json.txt",'w')
for dic in l:
str_dic = json.dumps(dic)
f.write(str_dic+'
')
f.close()
f = open('file_json.txt')
for line in f:
print(line.strip())
f.close()
13, 一次性写，一次性读，不然就是分次读写。
l =[{'k':'111'},{'k2':'111'},{'k3':'111'}]
# 把字典分别写进去，再分别load出来
# 借助于dumps和loads,先把字典读入内存，在单独对某个字典来进行操作
f = open("file_json.txt",'w')
for dic in l:
str_dic = json.dumps(dic)
f.write(str_dic+'
')
f.close()
l=[]
f = open('file_json.txt')
for line in f:
dic = json.loads(line.strip())
l.append(dic)
f.close()
print(l)
14,格式化往里面写的话，虽然好看，会比较占地儿，就类似那个三级菜单的格式
15，pickle模块和json一样的，四个方法，loads ,dumps,load dump,pickle是可以序列化任何数据类型的，只有Python认识，比方说集合,打开关闭文件的方式是二进制模式b
import pickle dic = {1:'a',2:"b"} str_d = pickle.dumps(dic) print(type(str_d),str_d) # 一串二进制的内容 # <class 'bytes'> b'x80x03}qx00(Kx01Xx01x00x00x00aqx01Kx02Xx01x00x00x00bqx02u.' dic = pickle.loads(str_d) print(type(dic),dic) # 字典 # <class 'dict'> {1: 'a', 2: 'b'} import time struct_time = time.localtime(100000000) print(struct_time) f = open('pickle_file.txt','wb') pickle.dump(struct_time,f) f.close() f = open('pickle_file.txt','rb') struct_time2 = pickle.load(f) print(struct_time2.tm_year)
16，pickle可以多次读和多次写，json不可以
import time struct_time1 = time.localtime(100000000) struct_time2 = time.localtime(10000000) f = open('pickle_file.txt','wb') pickle.dump(struct_time1,f) pickle.dump(struct_time2,f) f.close() f = open('pickle_file.txt','rb') struct_time1 = pickle.load(f) struct_time2 = pickle.load(f) print(struct_time1.tm_year) print(struct_time2.tm_year) # 1973 # 1970
17，picke 序列化的内容是乱码的，一般我们看不懂，但是pickle自己认识，所以我们知道就可以了
18，shelve模块，只有一个方法open,使用key来访问的，使用起来和字典类似
import shelve f = shelve.open('shelve_file') f['key'] = {'int':10,"float":9.5,"string":"sample data"} # 直接对文件句柄操作，就可以写入数据 # 每次打开shelve会创建好几个文件，不用去管他，挨个点开看，全都看不明白 f.close() import shelve f1 = shelve.open('shelve_file') existing = f1['key'] # 取出数据的时候，也需要直接用key获取即可，但是如果key不存在会报错 f1.close() print(existing) # 不支持统一时间，往同一个DB进行写操作，所以如果我们的应用只进行读操作，可以以只读的方式打开
19，即使只读的方式打开，仍然可以修改，不知道为何只读flag不生效（我的是生效的）。理论上是不可以改的
f = shelve.open('shelve_file',flag='r') existing = f['key'] f['key']['float'] = 10 # 没改成 # f['key'] = 10 # 我这边现在无论如何都写不成功 f.close() f = shelve.open('shelve_file',flag='r') existing2 = f['key'] f.close() print(ex
20，writeback= True,writeback有优点也有缺点，优点是减少了我们出错的概率，并让对象的持久化对用户更加的透明了，并不是所有的情况都需要，使用writeback以后，shelve每次open的时候都会增加额外的内存消耗，close之后，会将缓存中的所有对象都写入DB会造成时间的浪费。想改就要加writeback不可以随随便便的改。不可以总是去修改。Python不存在修改这个操作，只能是重新写一个。
f1 = shelve.open('shelve_file',writeback=True) print(f1['key']) f1['key']['new_value'] = 'this was not here before' print(f1['key']) f1.close() # 我这样加，但是加完了，他也没有及成功，可以加完重新打开，试验一下 # 加上writeback = True 就可以添加成功了，就写进去了 # 后面做的所有的增删改的操作，都会被记录到文件里面
21，什么是模块呢？一个py文件就是一个模块，随着编程的能力提高，你会发现，你不能满足在一个文件里面写程序了，而且你会发现有些功能是可以被重复使用的，比方说，验证码功能，博客园可以使用，淘宝也可以使用，于是我们就希望把一些有通用功能的代码，写到一个单独的文件里面，什么时候需要用了，把他直接导进来就可以了。
22，自己另一一个demo.py，在另外一个文件里面导入，发现pycharm会报错，pycharm有时候会骗你的，这个其实修改下路径就可以了,打开路径是当前路径的上一层路径就可以了。这个下面一会还会讲。
23，模块的名字必须符合命名规则，就是数字字母下划线，理论上名字可以用中文，但是我们不推荐这么用，模块名要有意义，并且不能和系统已有的模块重名。
24，只要一import 模块，模块里面的代码就会执行。
25，同一个模块多次导入，只会导入一次
# 这个地方写多个import，但是只会导入一次，后面会讲温和只会导入一次 import demo import demo import demo import demo import demo import demo
26，导入模块的命名空间
# import demo # import之后第一件事是找到这个模块，然后加载模块内的代码到内存里，读到专属的命名空间里面，里面所有的名字都要通过demo这个名字去调用。 # 找到模块 # 创建者模块的命名空间 # 把文件中的名字都放到命名空间里 # 两个文件的命名空间是完全隔离的
27，为何一个模块不会被重复导入？
import sys print(sys.modules.keys()) print(sys.path) # 默认会包含当前文件夹和上一层文件夹 # 结果列表里面有我们自己定义的demo # 当我们导入一个模块的时候，系统会自动去sys.modules这儿来看一下，如果这儿已经存在这个模块了，他就不会再重复导入了，不存在的话， # 他会去path里面找 # 先从sys.module里面查看是否已经被导入 # 如果没有导入，则根据sys.path路径寻找模块 # 找到了就导入
28，给文件起别名import...as
import time as t print(t.time()) # print(time.time) # NameError: name 'time' is not defined # 起了别名之后，原来的名字就无效了 # if 数据库 == 'Oracle': # import oracle as db # elif 数据库 == 'mysql': # import mysql as db # # 连接数据库 db.connect # 登录认证 # 增删改查 # 关闭数据库 # 除了数据库，操作文件其实也有很多种，包括硬盘也是 # 里面提供的方法恰好都一致的话，就可以用一个名字去操作。 # 其实是为了写一个兼容的程序
29，导入模块的一些规范
import os import sys import time # import os,sys,time # 语法上可以这样写，但是编码规则上我们不推荐这样写，如果想注释掉某个代码的时候，会比较麻烦 # 并且导入模块都
30，模块导入的顺序，先导入内置的模块（就是随着Python安装完就有的，很多的，re,sys等），再导入扩展的模块（别人之前写好的，需要单独装的，比如说django），最后导入自定义的模块，顺序要记好，编码规则的一种。
31，
import demo #这样会比较占用内存 from demo import read # 没有导入的函数和变量都是不可以用的，但是read函数可以应用demo模块里面定义的变量 # 这个地方为啥会飘红，这是Python解释器再报错，它为啥会报错呢？ # 重新打开，根节点文这个文件的上层文件夹，就不会再报错了 # 这只是Pycharm在报错，我的文件其实是不会报错的、 # 他虽然报错，但是sys.path里面两种方式都可以找到的 # 如果本文件定义了相同文件，那么模块里面的函数就永远也调用不到了， def read(): print('my read') read() # 这种调用的话就需要模块去调用了
31，from也支持导入多个名字,逗号分隔
from demo import read,money
32，
# 可以module导入全部的东西 # 这样导入不安全，有重名会比较麻烦 from demo import * from math import pi # 用哪个导入那个就行
33，__all__，定义在模块里面，列表，元素为字符串
__all__ = ['money'] # 模块里面加上这个参数的话，import的时候，即使import了*，也是只可以用这一个变量 money = 5 def read(): print('read') # read()
34，模块不会用的胡，一种是看源码，一种是去网上查看
35，包，就是一大堆模块的集合，我创建一个文件夹，里面的每一个文件都是模块
36，__name__==__main__ ，调试模块用的，限制啥时候执行，在那个页面点击的执行，那个页面就是main,不再这个页面执行，那么他的name 就是他自己的名字模块名
money = 5 def read(): print('read')
# 双下name模块的名字，这也是把模块当做脚本执行的方法 if __name__ == '__main__': read()