一、os模块
os模块是与操作系统交互的一个接口。
import os
# 和文件和文件夹的操作有关
os.makedirs(‘dirname1/dirname2‘) # 可生成多层递归目录
os.removedirs(‘dirname1‘) # 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir(‘dirname‘) # 生成单级目录；相当于shell中mkdir dirname
os.rmdir(‘dirname‘) # 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir(‘dirname‘) # 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove(‘path‘) # 删除一个文件，（不能删除文件夹）
os.rename("oldname","newname") # 重命名文件/目录
os.stat(‘path/filename‘) # 获取文件/目录信息
# 和执行操作系统命令有关
os.system("bash command") # 运行shell命令，直接显示（即使用python语言 直接执行操作系统命令，更适用于有运维功底的python开发人员）
os.popen("bash command").read() # 运行shell命令，获取执行结果（即使用python语言 直接执行操作系统命令，更适用于有运维功底的python开发人员）
os.getcwd() # 获取当前工作目录，即当前python脚本工作的目录路径（并不是当前文件所在 目录，而是当前文件是在哪个目录下执行的，而且这个是可以改变的）
os.chdir("dirname") # 改变当前脚本工作目录；相当于shell下cd
注意：os.system和os.popen是执行字符串数据类型的命令行代码。
# 和路径有关
os.path.abspath(path) # 返回path规范化的绝对路径
os.path.split(path) # 将path分割成目录和文件名按元组返回
os.path.dirname(path) # 返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path) # 返回path最后的文件名。如果path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path) # 如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path) # 如果path是绝对路径，返回True
os.path.isfile(path) # 如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path) # 如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]]) # 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略，用法示例如下：
print(os.path.join("E:\pythonDemo\work", "aaa","bbb","ccc"))
# 结果为：E:\pythonDemo\work\aaa\bbb\ccc
os.path.getatime(path) # 返回path所指向的文件或者目录的最后访问时间
os.path.getmtime(path) # 返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path) # 返回path的大小
print(os.stat("test16.py"))
# 结果为：os.stat_result(st_mode=33206, st_ino=36873221949109263, st_dev=3128153233, st_nlink=1, st_uid=0, st_gid=0, st_size=758, st_atime=1534846129, st_mtime=1534846129, st_ctime=1534380128)
注意：os.stat(‘path/filename‘) 获取文件/目录信息 的结构说明，如下示例：
stat 结构：
st_mode: inode 保护模式。
st_ino: inode 节点号。
st_dev: inode 驻留的设备。
st_nlink: inode 的链接数。
st_uid: 所有者的用户ID。
st_gid: 所有者的组ID。
st_size: 普通文件以字节为单位的大小；包含等待某些特殊文件的数据。
st_atime: 上次访问的时间。
st_mtime: 最后一次修改的时间。
st_ctime: 由操作系统报告的"ctime"。在某些系统上（如Unix）是最新的元数据更改的时间，在其它系统上（如Windows）是创建时间（详细信息参见平台的文档）。
stat 结构
os模块的属性：
os.sep 输出操作系统特定的路径分隔符，win下为"\\"，Linux下为"/"
os.linesep 输出当前平台使用的行终止符，win下为"\t\n"，Linux下为"\n"
os.pathsep 输出用于分割文件路径的字符串 win下为;，Linux下为:
os.name 输出字符串指示当前使用平台。win->‘nt‘，Linux->‘posix‘
os模块的属性
os.popen/os.system相关解释：
os模块所做的事情：
定制了很多方法 间接的帮助你去调用操作系统的命令，获得结果，然后帮助你分析整理成我们需要的数据类型的形态；
我们也可以用os.popen/os.system直接取调用操作系统的命令，获得结果，但是，分析和整理的工作需要我们自己做；
所以，用os模块的方法本身能够完成的功能我们就用定制好的方法就够了，如果有一天，我们发现os模块定制好的功能解决不了我们的问题了，而刚好操作系统的命令能够很好地帮助我们解决问题，这个时候就用os.popen/os.system。
注意：os.path.getsize()的参数是一个文件夹的情况
ret = os.path.getsize(r"E:\pythonDemo\1-basis")
ret3 = os.path.getsize(r"E:\pythonDemo\work")
print(ret, ret3) # 结果为：4096 4096
所有的文件夹，都至少是4096个字节，因为每当创建一个文件夹，就在操作系统上创建一个文件，里边存的是这个文件夹的信息，记录文件名、文件大小、创建时间等等，当一个文件刚刚创建出来的时候，只要放了文件就给分配4096个字节的空间，当用完了4096个字节空间后再存数据时则double即扩大一倍，以此类推，而这个大小不会算在这个文件夹中所有文件总大小中，即不会对这个文件夹中所有文件总大小造成影响。
os.path.getsize()的参数是一个文件夹的情况
练习题：使用python代码统计一个文件夹中所有文件的总大小
# 递归
def func(path):
size_sum = 0
name_lst = os.listdir(path)
for name in name_lst:
path_abs = os.path.join(path,name)
if os.path.isdir(path_abs):
size = func(path_abs)
size_sum += size
else:
size_sum += os.path.getsize(path_abs)
return size_sum
ret = func(r‘E:\pythonDemo ‘)
print(ret)
# 循环（堆栈思想-列表 满足一个顺序 先进来的后出去）
lst = [r‘ E:\pythonDemo ‘] # 列表的第一个目录就是我要统计的目录
size_sum = 0
while lst:
path = lst.pop()
path_list = os.listdir(path)
for name in path_list:
abs_path = os.path.join(path,name)
if os.path.isdir(abs_path):
lst.append(abs_path)
else:
size_sum += os.path.getsize(abs_path)
print(size_sum)
二、序列化模块
什么叫序列化—--将原本的字典、列表等内容转换成一个字符串的过程就叫做序列化。
为什么要有序列化模块？
比如，我们在python代码中计算的一个数据需要给另外一段程序使用，那我们怎么给？现在我们能想到的方法就是存在文件里，然后另一个python程序再从文件里读出来。但是我们都知道，对于文件来说是没有字典这个概念的，所以我们只能将数据转换成字典放到文件中。你一定会问，将字典转换成一个字符串很简单，就是str(dic)就可以办到了，为什么我们还要学习序列化模块呢？没错，序列化的过程就是从dic 变成str(dic)的过程。现在你可以通过str(dic)，将一个名为dic的字典转换成一个字符串，但是你要怎么把一个字符串转换成字典呢？聪明的你肯定想到了eval()，如果我们将一个字符串类型的字典str_dic传给eval，就会得到一个返回的字典类型了。eval()函数十分强大，但是eval是做什么的？e官方demo解释为：将字符串str当成有效的表达式来求值并返回计算结果。ＢＵＴ！强大的函数有代价。安全性是其最大的缺点。想象一下，如果我们从文件中读出的不是一个数据结构，而是一句"删除文件"类似的破坏性语句，那么后果实在不堪设设想。而使用eval就要担这个风险。所以，我们并不推荐用eval方法来进行反序列化操作(将str转换成python中的数据结构)。
为什么要把其他数据类型转换成字符串?（使用序列化的场景）
1）能够在网络上传输的只能是bytes,
2）能够存储在文件里的只有bytes和str
序列化的目的：
1）以某种存储形式使自定义对象持久化；
2）将对象从一个地方传递到另一个地方；
3）使程序更具维护性；
1、json模块
json模块提供了四个功能：序列化（dumps和dump）、反序列化（loads和load）。如下示例：
import json
dic = {‘key‘ : ‘value‘,‘key2‘ : ‘value2‘}
ret = json.dumps(dic) # 序列化
print(dic,type(dic)) # {‘key‘: ‘value‘, ‘key2‘: ‘value2‘} <class ‘dict‘>
print(ret,type(ret)) # {"key": "value", "key2": "value2"} <class ‘str‘>
res = json.loads(ret) # 反序列化
print(res,type(res)) # {‘key‘: ‘value‘, ‘key2‘: ‘value2‘} <class ‘dict‘>
# json能够序列化的数据有什么特点，请看下面几个示例，并分析结果：
# 问题1:字典的key是整型，经过序列化和反序列化变成字符串类型
# 问题2:字典的value是元组，经过序列化和反序列化变成了列表类型
dic = {1 : [1,2,3], 2 : (4,5,‘aa‘)}
ret = json.dumps(dic) # 序列化
print(dic,type(dic)) # {1: [1, 2, 3], 2: (4, 5, ‘aa‘)} <class ‘dict‘>
print(ret,type(ret)) # {"1": [1, 2, 3], "2": [4, 5, "aa"]} <class ‘str‘>
res = json.loads(ret) # 反序列化
print(res,type(res)) # {‘1‘: [1, 2, 3], ‘2‘: [4, 5, ‘aa‘]} <class ‘dict‘>
# 问题3:set集合类型不能被json序列化
# 问题4:字典的键必须是字符串才能被json序列化
s = {1,2,‘aaa‘}
json.dumps(s) # 报错：TypeError: Object of type ‘set‘ is not JSON serializable
json.dumps({(1,2,3):123}) # 报错：TypeError: keys must be a string
总结：json在所有的语言之间都通用：即json序列化的数据，在python上序列化了，那在java中也可以反序列化，所以json能够处理的数据类型是非常有限的，只有字符串，列表，字典，数字这几种类型，而且字典中的key只能是字符串。
# 向文件中记录字典
import json
dic = {‘key‘ : ‘value‘,‘key2‘ : ‘value2‘}
ret = json.dumps(dic) # 序列化（将序列化结果写入内存，下面从内存中读取写入文件）
with open(‘json_file‘,‘a‘) as f:
f.write(ret) # 向文件json_file中写入字典{"key": "value", "key2": "value2"}
# 从文件中读取字典
with open(‘json_file‘,‘r‘) as f:
str_dic = f.read() # 文件中读取后写入内存
dic = json.loads(str_dic) # 将内存中的字符串反序列化
print(dic) # 将反序列化的结果打印{‘key‘: ‘value‘, ‘key2‘: ‘value2‘}
# dump和load是直接操作文件的，如下示例：
dic = {‘key1‘ : ‘value1‘,‘key2‘ : ‘value2‘}
with open(‘json_file‘,‘a‘) as f:
json.dump(dic,f) # 向文件json_file中写入：{"key1": "value1", "key2": "value2"}
with open(‘json_file‘,‘r‘) as f:
dic = json.load(f)
print(dic) # {‘key1‘: ‘value1‘, ‘key2‘: ‘value2‘}
总结：如果你是处理和文件相关的（往文件里边写或者从文件里边读），那么可以用dump和load；如果是处理网络上传输的数据时，此时数据都是在内存里，这是就要用dumps和loads。
# 问题5 不支持连续的存 取
dic = {‘key1‘ : ‘value1‘,‘key2‘ : ‘value2‘}
with open(‘json_file‘,‘a‘) as f:
json.dump(dic,f)
json.dump(dic,f)
json.dump(dic,f)
with open(‘json_file‘,‘r‘) as f:
dic = json.load(f)
print(dic.keys())
总结：上面程序中虽然成功通过dump多次向文件中存入3个字典，但是load会报错# 也就是说load只能读取存一个字典的文件，嵌套字典也可以，但最外层只能是一个。
那么现在有个需求：就是想要把一个一个的字典放到文件中，再一个一个的取出来，该怎么实现？如下示例：
dic = {‘key1‘ : ‘value1‘,‘key2‘ : ‘value2‘}
with open(‘json_file‘,‘a‘) as f:
str_dic = json.dumps(dic)
f.write(str_dic+‘\n‘)
str_dic = json.dumps(dic)
f.write(str_dic + ‘\n‘)
str_dic = json.dumps(dic)
f.write(str_dic + ‘\n‘)
with open(‘json_file‘,‘r‘) as f:
for line in f:
dic = json.loads(line.strip())
print(dic)
# 结果为：
# {‘key1‘: ‘value1‘, ‘key2‘: ‘value2‘}
# {‘key1‘: ‘value1‘, ‘key2‘: ‘value2‘}
# {‘key1‘: ‘value1‘, ‘key2‘: ‘value2‘}
综上：json的dumps、loads-----在内存中做数据转换：
umps 序列化 数据类型 转成 字符串；
loads 反序列化 字符串 转成 数据类型；
json的dump、load----直接将数据类型写入文件，直接从文件中读出数据类型：
dump 序列化 数据类型 写入 文件 反序列化；
load 反序列化 文件中 读出 数据类型；
json是所有语言都通用的一种序列化格式，只支持列表、字典、字符串、数字，且字典的key必须是字符串。
# ensure_ascii 关键字参数
dic = {‘key‘:‘你好‘}
print(json.dumps(dic)) # {"key": "\u4f60\u597d"}
print(json.dumps(dic,ensure_ascii=False)) # "key": "你好"}
ensure_ascii 关键字参数
# json 的格式化输出
data = {‘username‘:[‘李华‘,‘二愣子‘],‘sex‘:‘male‘,‘age‘:16}
json_dic2 = json.dumps(data,sort_keys=True,indent=4,separators=(‘,‘,‘:‘),ensure_ascii=False)
print(json_dic2)
# 结果为：
# {
# "age":16,
# "sex":"male",
# "username":[
# "李华",
# "二愣子"
# ]
# }
json 的格式化输出
2、pickle模块
pickle模块提供了四个功能：序列化，存（dumps、dump）、反序列化，读（loads、load），此外，pickle模块不仅可以序列化字典，列表...它可以把python中任意的数据类型序列化。
import pickle
dic = {(1,2,3):{‘a‘,‘b‘},1:‘abc‘}
ret = pickle.dumps(dic) # dumps序列化的结果只能是字节
print(ret) # 结果为：b‘\x80\x03}q\x00(K\x01K\x02K\x03\x87q\x01cbuiltins\nset\nq\x02]q\x03(X\x01\x00 \x00\x00aq\x04X\x01\x00\x00\x00bq\x05e\x85q\x06Rq\x07K\x01X\x03\x00\x00\x00abcq\x08u.‘
print(pickle.loads(ret)) # {(1, 2, 3): {‘b‘, ‘a‘}, 1: ‘abc‘}
# pickle模块的dump、load 的和文件操作
with open(‘pickle_file‘,‘wb‘) as f:
pickle.dump(dic,f)
with open(‘pickle_file‘,‘rb‘) as f:
ret = pickle.load(f)
print(ret,type(ret))
# pickle可以多次dump和load
dic = {(1,2,3):{‘a‘,‘b‘},1:‘abc‘}
dic1 = {(1,2,3):{‘a‘,‘b‘},2:‘abc‘}
dic2 = {(1,2,3):{‘a‘,‘b‘},3:‘abc‘}
dic3 = {(1,2,3):{‘a‘,‘b‘},4:‘abc‘}
with open(‘pickle_file‘,‘wb‘) as f:
pickle.dump(dic, f)
pickle.dump(dic1, f)
pickle.dump(dic2, f)
pickle.dump(dic3, f)
with open(‘pickle_file‘,‘rb‘) as f:
ret = pickle.load(f)
print(ret,type(ret))
ret = pickle.load(f)
print(ret,type(ret))
ret = pickle.load(f)
print(ret, type(ret))
ret = pickle.load(f)
print(ret, type(ret))
# ret = pickle.load(f) # EOFError: Ran out of input
# print(ret, type(ret)) # dump了4个字典，第5次load会报错
# 结果为：
# {(1, 2, 3): {‘b‘, ‘a‘}, 1: ‘abc‘} <class ‘dict‘>
# {(1, 2, 3): {‘b‘, ‘a‘}, 2: ‘abc‘} <class ‘dict‘>
# {(1, 2, 3): {‘b‘, ‘a‘}, 3: ‘abc‘} <class ‘dict‘>
# {(1, 2, 3): {‘b‘, ‘a‘}, 4: ‘abc‘} <class ‘dict‘>
# 改进
with open(‘pickle_file‘,‘rb‘) as f:
while True:
try:
ret = pickle.load(f)
print(ret,type(ret))
except EOFError:
break
总结：1）pickle序列化支持在python中几乎所有数据类型；
2）dumps序列化的结果只能是字节；
3）只能在python中使用；
4）在和文件操作的时候，需要用rb wb的模式打开文件；
5）可以多次dump和多次load；
原文地址：https://www.cnblogs.com/li-li/p/9526332.html