day20:序列化模块，模块的导入

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": "\u4e2d\u56fd", "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':''},{'k2':''},{'k3':''}]
# 把字典分别写进去，再分别load出来
f = open("file_json.txt",'w')

for dic in l:
    str_dic = json.dumps(dic)
    f.write(str_dic+'\n')
f.close()

f = open('file_json.txt')
for line in f:
    print(line.strip())
f.close()

13, 一次性写，一次性读，不然就是分次读写。

l =[{'k':''},{'k2':''},{'k3':''}]
# 把字典分别写进去，再分别load出来
# 借助于dumps和loads,先把字典读入内存，在单独对某个字典来进行操作
f = open("file_json.txt",'w')

for dic in l:
    str_dic = json.dumps(dic)
    f.write(str_dic+'\n')
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'\x80\x03}q\x00(K\x01X\x01\x00\x00\x00aq\x01K\x02X\x01\x00\x00\x00bq\x02u.'

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)

#
#

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()