模块二：os模块、sys模块、json模块、pickle模块，包

os模块

 1 os模块是与操作系统交互的一个接口
 2 import os：
 3 1、获取当前工作目录
 4 print(os.getcwd())
 5
 6 2、切换到D:\yuan文件目录
 7 os.chdir(‘D:\yuan’)
 8
 9 3、创建文件夹
10 os.mkdir(“yuan”)   创建yuan文件夹
11 os.makedirs(“alvin/imgs”)   创建alvin/imgs文件夹
12
13 4、以列表形式输出路径下的所有文件和文件夹名字 （*）
14 print(os.listdir(‘D:\python35\day15’))
15
16 5、删除
17 os.remove(‘user’)  # 删除文件 （*）
18 os.removedirs(‘dirname1’)
19 os.rmdir(‘dirname’)  # 删除文件夹 删除单级空目录，若目录不为空无法删除会报错
20
21 6、文件重命名
22 os.rename(‘原文件名’,’目标名’)  （*）
23 os.rename(“a.log”,”abc.log”)
24
25 7、获取某文件的具体信息
26 log=os.stat(“abc.log”)
27 print(log)
28 print(log.st_size)
29 print(log.st_mtime)  最后一次修改时间
30 print(time.ctime(log.st_mtime))
31
32 8、输出路径分隔符 windows \\   linux /
33 print(os.sep)
34
35 9、获取绝对路径   (*)
36 print(os.path.abspath('run.py'))
37 # T:\egon\day22\代码\run.py
38
39 10、获取文件的目录 D:\python35\day15 实际就是os.path.split(path)中的第一个元素 （*）
40 print(os.path.dirname(r“D:\python35\day15\abc.log”))
41
42 11、将路径分割成一个目录和文件名，按元组形式返回 （*）
43 print(os.path.split(r“D:\python35\day15\abc.log”))
44 # ('D:\\python35\\day15', 'abc.log')
45
46 12、获取文件名称  实际就是os.path.split(path)中的第二个元素  （*）
47 print(os.path.basename(r“D:\python35\day15\abc.log”))   # abc.log
48
49 # 如果path是一个存在的文件，返回True，否则返回False (*)
50 print(os.path.isfile(path))
51
52 # 如果path是一个存在的目录，返回True，否则返回False (*)
53 print(os.path.isdir(path))
54
55 # 如果path存在，返回True，否则返回False   （*）
56 print(os.path.exists(path))
57
58 # 如果path是绝对路径，返回True，否则返回False  （*）
59 print(os.path.isabs(path))
60
61 13,判断文件是否存在 （*）
62 print(os.path.exists(r“D:\python35\day15\abc.log”))
63
64 14,路径拼接/  (*)
65 print(os.path.join("D:\python35","day15\\abc.log"))
66
67 推荐使用：
68 BASE_DIR = os.path.dirname(os.path.dirname(__file__)) # 获取文件的目录
69 print(BASE_DIR)   # T:/egon/day22
70
71 BASE_DIR=os.path.normpath(os.path.join(
72     __file__,  # T:\egon\day22\代码\03 os模块.py
73     '..',
74     '..'
75 ))
76 print(BASE_DIR)  # T:\egon\day22
77
78 15、获取文件信息
79 print(os.path.getsize(“abc.log”))   # 获取文件大小  （*）
80 print(os.path.getmtime(“abc.log”))  # 获取最后一次修改时间 （*）
81 print(os.path.getatime("abc.log"))  # 获取path所指向的文件或目录的最后存取时间
82
83 在python3.5之后，推出了一个新的模块pathlib
84 from pathlib import Path
85 print(Path(__file__))  # T:\egon\day22\代码\03 os模块.py
86 res = Path(__file__).parent.parent
87 print(res)  # T:\egon\day22
88
89 res=Path('/a/b/c') / 'd/e.txt'
90 print(res)  # \a\b\c\d\e.txt
91 print(res.resolve())  # T:\a\b\c\d\e.txt

sys模块

sys模块,与python解释器相关信息的模块
import sys
print(sys.version) # 解释器版本信息
print(sys.platform) # 平台 win32
1.sys.argv
print(sys.argv) # [‘04 sys模块’ ,‘yuan’,’123’]

 1 应用案例：
 2 import sys
 3 name='lili'
 4 pswd='1136'
 5 # print(sys.argv)   ['day4.py', 'lili', '1123']
 6 if len(sys.argv)==3:
 7     username=sys.argv[1]
 8     password=sys.argv[2]
 9 else:
10     username=input('请输入您的用户名：')
11     password=input('请输入您的密码：')
12 if username==name and pswd==password:
13     print('登录成功！')
14 else:
15 print('用户名或密码有误！')
16
17 2、sys.exit(n) 退出程序，正常退出时exit(0)
18
19 3、sys.version 获取python解释器程序的版本信息
20
21 4、sys.maxint 最大的int值
22
23 5、sys.platform 返回操作系统平台名称
24
25 6、sys.path 返回模块的搜索路径，初始化时使用python path环境变量的值
26
27 7、sys.modules 以字典的形式返回系统已经加载的模块，常用来作为是否重新加载一个模块的判断依据

json序列化

序列化：通过某种方式把数据结构或对象写入到磁盘文件中或通过网络传到其他节点的过程。将本语言（python）下的数据类型对象转换成json字符串的过程。
反序列化：将json字符串转换为本语言支持的对应数据类型对象。
内存中的数据类型---->序列化---->特定的格式（json格式或者pickle格式）
内存中的数据类型<----反序列化<----特定的格式（json格式或者pickle格式）

2、为何要序列化
# 序列化得到结果=>特定的格式的内容有两种用途
# 1)可用于存储=》用于存档
# 2)传输给其他平台使用=》跨平台数据交互
# python java
# 列表 特定的格式 数组

强调：
# 针对用途1的特定一格式：可是一种专用的格式=》pickle只有python可以识别
# 针对用途2的特定一格式：应该是一种通用、能够被所有语言识别的格式=》json

json：简单常用的轻量级的数据交换格式

 1 import json
 2 dic={“name”:”yuan”,”age”:18,”is_good”:True}
 3 # 序列化.dumps()
 4 dic_str = json.dumps(dic))
 5 print(dic_str,type(dic_str))
 6 print(repr(dic_str))  #打印数据原本的样子
 7
 8 将序列化的结果写入文件的简单方法：
 9 with open('test.json',mode = 'wt',encoding = 'utf-8') as f:
10     json.dump([1,'qqq'],f)
11
12 # 反序列化.loads()
13 #将json字符串转换为python的字典结构
14 data=json.loads(dic_str)
15 print(repr(data))
16
17 从文件读取json格式的字符串进行反序列化操作的简单方法
18 with open('text.json',mode = 'rt',encoding = 'utf-8') as f:
19     l = json.load(f)
20     print(l,type(l))   # [1,'qqq'] <class 'list'>
21
22 练习：
23 data_str=’{“name”:”yuan”,”age”:18,”is_good”:true}’
24 data = json.loads(data_str)
25 print(“data:”,data)   # 满足json格式也可以序列化、反序列化
26
27 python爬取的数据---序列化---->转换为json类型--反序列化-->java
28
29 前后端通信：前端JS 后端python
30 后端序列化
31 books = [{“title”:”西游记”,”price”:199,”publish”:”苹果出版社”}，
32 {“title”:”水浒传”,”price”:199,”publish”:”苹果出版社”}，
33 {“title”:”三国演义”,”price”:199,”publish”:”苹果出版社”}，
34 {“title”:”三国演义”,”price”:199,”publish”:”苹果出版社”}
35 ]
36 books_str= json.dumps(books)
37 print(repr(books_str))
38 前端反序列化
39 var  books = [{“title”:”西游记”,”price”:199,”publish”:”苹果出版社”}，
40 {“title”:”水浒传”,”price”:199,”publish”:”苹果出版社”}，
41 {“title”:”三国演义”,”price”:199,”publish”:”苹果出版社”}，
42 {“title”:”三国演义”,”price”:199,”publish”:”苹果出版社”}
43 ]
44 res=JSON.parse(books)
45
46 json格式兼容的是所有语言通用的数据类型，不能识别某一语言的所所独有的类型
47 json不认单引号
48 在python2.7和3.6之后都可以json.loads（bytes类型）但唯独3.5不可以
49
50 猴子补丁：核心就是用自己的代码替换所用模块的源代码
51 发现ujson比json性能更高，但用法一样，可能会想到用import ujson as json，但需要每个文件都重新导入一下，维护成本很高，此时我们就可以用到猴子补丁
52 只需在入口处加入以下代码（起始执行文件中）
53 import json
54 import ujson
55 def monkey_patch_json():
56     json.__name__ = 'ujson'
57     json.dumps = ujson.dumps
58     json.loads = ujson.loads
59 monkey_path_json()
60 之所以在入口处加是因为模块在导入一次后，后续的导入便直接引用第一次的成果
61
62 比如我们引用团队库里的一个模块，有想丰富模块的功能，除了继承之外也可以考虑猴子补丁功能，如果发现ujson不符合预期，也可以在启动执行文件中删除

pickle模块

内存中结构化的数据<-------->格式pickle<-------->bytes类型<------->保存到文件中或基于网络传输

将python中所有的数据类型，转换为字节串，序列化的过程

将字节串转换成python中数据类型，反序列化

 1 import pickle
 2 bys = pickle.dumps([1,2,3])
 3 print(type(bys)) # <class 'bytes'>
 4
 5 bys1 = pickle.dumps(set('abc'))
 6 print(type(bys1)) # <class 'bytes'>
 7 res = pickle.loads(bys)
 8 print(type(res)) # <class 'set'>
 9
10 bys2 = pickle.dumps((1,2,3))
11 res = pickle.loads(bys2)
12 print(type(res))  # <class 'tuple'>
13
14 pickle常用场景：和json一样，一次性写入，一次性读取
15 json、pickle的比较：
16 json：
17     不是所有的数据类型都可以序列化，结果是字符串str
18     不能多次对同一个文件序列化
19     json数据可以跨语言
20
21 pickle：
22     所有python类型都能序列化，结果是字节串
23     可以多次对同一个文件序列化
24     不能跨语言，只能用于python，并且可能不同版本的python彼此不兼容

包

1、包就是一个包含有__init__.py文件的文件夹
2、包的本质是模块的一种形式，包是用来被当作模块导入
3、关于__init__文件:是python的package的一个标识,当导入包的时候,该导入包的__init__文件会自动执行
*注：可在__init__.py文件中做一些初始化动作，在python3中，即使包下没有__init__.py文件，import 包 仍然不会报错，而在python2中包下一定要有该文件，否则import会报错
*创建包的目的不是为了运行，而是被导入使用，记住包只是模块的一种形式而已，包的本质就是一种模块

4、导包的语法：
1)import 包名.模块
2)from 包名 import 模块
3)from 包名.模块名 import 成员变量名

5、环境变量是以执行文件为准的，当在执行程序入口文件时，会自动将执行文件的绝对路径放入sys.path列表的0索引位置，所有的被导入的模块或者后续的其他文件引用的sys.path都是参照执行文件的sys.path

6、相对导入：仅限于包内使用，不能跨出包
.代表当前文件夹
..代表上一层文件夹
相对导入不能跨出包，所以相对导入仅限于包内模块彼此之间使用，而绝对导入是没有任何限制的，所以绝对导入是一种通用的导入方式。