常用模块一（os模块、序列化模块(json和pickle)）

一、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.sep           # 当前操作系统的路径分隔符

　　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') 获取文件/目录信息的结构说明，参数说明如下：
    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）是创建时间（详细信息参见平台的文档）。

    os.sep    输出操作系统特定的路径分隔符，win下为"\\"，Linux下为"/"
    os.linesep    输出当前平台使用的行终止符，win下为"\t\n"，Linux下为"\n"
    os.pathsep    输出用于分割文件路径的字符串 win下为;，Linux下为:
    os.name    输出字符串指示当前使用平台。win->'nt'，Linux->'posix'

os.popen/os.system相关解释：

os模块所做的事情：

　　定制了很多方法 间接的帮助你去调用操作系统的命令，获得结果，然后帮助你分析整理成我们需要的数据类型的形态；

我们也可以用os.popen/os.system直接取调用操作系统的命令，获得结果，但是，分析和整理的工作需要我们自己做；

所以，用os模块的方法本身能够完成的功能我们就用定制好的方法就够了，如果有一天，我们发现os模块定制好的功能解决不了我们的问题了，而刚好操作系统的命令能够很好地帮助我们解决问题，这个时候就用os.popen/os.system。

    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即扩大一倍，以此类推，而这个大小不会算在这个文件夹中所有文件总大小中，即不会对这个文件夹中所有文件总大小造成影响。

　　练习题：使用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是做什么的？官方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-----在内存中做数据转换：

                     dumps 序列化 数据类型 转成 字符串；

　　　　　   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": "你好"}

    # 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":[
    #         "李华",
    #         "二愣子"
    #     ]
    # }

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）pickle模块的dumps/dump序列化的结果只能是字节；

           3）只能在python中使用；

           4）在和文件操作的时候，需要用rb wb的模式打开文件；

           5）可以多次dump和多次load；