一. os 模块 所有关于操作系统的内容都在os模块
    os.makedirs("d:/1PY/新建文件夹/宝宝")      # 可生成多层递归目录
    os.removedirs("d:/1PY/新建文件夹/宝宝")     # 若目录为空, 则删除, 并递归到上一级目录, 如若也为空, 则删除, 依次类推
    os.mkdir("d:/1PY/新建文件夹")      # 生成单级目录, 相当于shell中mkdir dirname
    os.rmdir("d:/1PY/新建文件夹")      # 删除单级空目录, 若目录不为空则无法删除, 报错, 相当于shell中的rmdir dirname
    lst = os.listdir("d:/")        # 列出指定目录下的所有文件和子目录, 包括隐藏文件, 并以列表方式打印
    "d:" 当前文件所在文件夹下    "d:/"  d盘
    print(lst)
    os.remove("")     # 指定删除一个文件
    os.rename("d:/1PY/周末大作业", "d:/1PY/周末作业")       # 重命名文件, 目录
    ret = os.stat("d:/1PY/周末作业")       # 获取文件/目录信息
    print(ret)
    os.stat_result(st_mode=16895, st_ino=1688849860285352, st_dev=399180, st_nlink=1, st_uid=0, st_gid=0,
                   st_size=4096, st_atime=1545896396, st_mtime=1545540100, st_ctime=1543629480)
    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）是创建时间（详细信息参见平台的文档）。
    
    os.system("dir")     # 运行shell命令, 直接显示
    print(os.popen("dir").read())       # pipe open 运行shell命令, 获取执行结果
    ret = os.getcwd()     # current working directory 获取当前工作目录, 即当前python脚本工作的目录路径
    print(ret)
    os.chdir("d:/1PY/周末作业")      # 改变当前脚本工作目录, 相当于 shell下 cd
    ret = os.getcwd()
    print(ret)
    
    os.path
    
    ret = os.path.abspath("d:/1PY/Day20/x1.txt")       # absolute path 返回path规范化的绝对路径
    print(ret)
    ret = os.path.split("d:/1PY/周末作业")        # 将path分割成目录和文件名二元组返回
    print(ret)
    ('d:/1PY', '周末作业')
    print(os.path.dirname("d:/1PY/周末作业"))       # 返回path的目录, 其实就是os.path.split(path)的第一个元素
    d:/1PY
    print(os.path.dirname(__file__))                   # 当前文件的文件夹
    print(os.path.dirname(os.path.dirname(__file__)))   # 当前文件的文件夹的文件夹
    os.path.basename("d:/1PY/周末作业")     # 返回path最后的文件名, 如果path以/或\结尾, n那么就会返回空值, 即os.path.split(path)的第二个元素
    print(os.path.exists("d:/1PY/周末大作业"))        # 如果path存在, 返回True, 如果path不存在, 返回False
    os.path.isabs("path")       # 如果path是绝对路径, 返回True
    os.path.isfile("")      # 如果path是一个存在的文件, 返回True, 否则返回False
    os.path.isdir("")       # 如果path是一个存在的目录, 则返回True
    os.path.join(path[, path2[, ...]])        # 将多个路径组合后返回, 第一个绝对路径之前的参数将被忽略
    print(os.path.join("d:/2PY", "Day23"))
    d:/2PY/Day23
    print(os.path.getatime("d:/2PY/Day23 模块_02"))      # 返回path指向的文件或目录的最后访问时间
    print(os.path.getmtime("d:/2PY/Day23 模块_02"))      # 返回path指向的文件或目录的最后修改时间
    print(os.path.getsize("d:/2PY/Day22 模块_01"))       # 返回path的大小
    1545899709.7857668
    1545894003.6891558
    0
    
    特殊属性
    print(os.sep)     # 输出操作系统特定的路径分隔符, win下为"\\", linux下为"/"
    print(os.linesep)       # 输出当前平台使用的行终止符  win下为"\r\n", linux下为"\n"
    print(os.pathsep)       # 输出用于分割文件路径的字符串  win下为";", linux下为":"
    print(os.name)      # 输出字符串指示当前使用平台  win下为"nt", linux下为"posix"

二. sys模块 所有关于python解释器相关的都在sys模块
    print(sys.argv)     # 命令行参数list, 第一个元素时程序本身路径
    ['D:/1PY/Day23/Day23_练习.py']
    sys.exit(0)         # 退出程序, 正常退出是exit(0), 错误退出sys.exit(1)
    print(sys.version)      # 获取python解释程序的版本信息
    3.6.7 (v3.6.7:6ec5cf24b7, Oct 20 2018, 12:45:02) [MSC v.1900 32 bit (Intel)]
    
    重要
    print(sys.path)     # 返回模块的搜索路径, 初始化时使用pythonpath环境变量的值
    ['D:\\1PY\\Day23', 'D:\\1PY', 'D:\\python\\python36.zip', 'D:\\python\\DLLs',
    'D:\\python\\lib', 'D:\\python','D:\\python\\lib\\site-packages',
    'D:\\pycharm\\PyCharm 2018.2.4\\helpers\\pycharm_matplotlib_backend']
    sys.path.append("D:/2PY")
    print(sys.path)
    ['D:\\1PY\\Day23', 'D:\\1PY', 'D:\\python\\python36.zip', 'D:\\python\\DLLs',
     'D:\\python\\lib', 'D:\\python', 'D:\\python\\lib\\site-packages',
     'D:\\pycharm\\PyCharm 2018.2.4\\helpers\\pycharm_matplotlib_backend', 'D:/2PY']
    
    print(sys.platform)       # 返回操作系统平台名称
    win32
三. 序列化
    序列化就是把内存里的数据类型转变为字符串, 以使其能存储到硬盘或通过网络传输到远程, 因为硬盘或网络传输时只能接受bytes
    python中存在三种序列化的方案:
    1. pickle: 可以将python中的任意数据类型转化成bytes并写入到文件中, 同样也可以吧文件中写好的bytes转换回我们python的数据, 这个过程被称为反序列化
    2. shelve: 简单另类的一种序列化方案, 有点类似后面我们学到的redis, 可以作为一种小型的数据库使用
    3. json:将python中常见的字典, 列表转换成字符串, 是目前前后端数据交互使用频率最高的一种数据格式
四. pickle
    1. dumps()    把对象序列化成字节
    2. loads()    把字节反序列化成对象
    import pickle

class Cat():
        def __init__(self, name, age):
            self.name = name
            self.age = age
    
        def catchMouse(self):
            print(self.name, "抓老鼠")

c = Cat("jerry", 18)
    
    bs = pickle.dumps(c)        # 把对象序列化
    print(bs)                   # 二进制格式
    
    cc = pickle.loads(bs)           # 把二进制反序列化成对象
    cc.catchMouse()
    # jerry 抓老鼠
    
    3. dump()    把对象序列化写入文件
    4. load()    把文件中的内容反序列化成对象
    with open("cat", mode = "wb") as f:
        pickle.dump(c, f)

with open("cat", mode = "rb") as f:
        cc = pickle.load(f)
        cc.catchMouse()
    # jerry 抓老鼠
    pickle还支持多个对象的导入
    lst = [Cat("jerry", 19), Cat("tommy", 20), Cat("alpha", 21)]
    with open("catt", mode = "wb") as f:
        for el in lst:
            pickle.dump(el, f)          # 把对象写入到文件中
    
    with open("catt", mode = "rb") as f:
        for i in range(len(lst)):
            cc = pickle.load(f)            # 从文件中读取对象
            cc.catchMouse()
    上面的写法不太好, 因为在读的时候, 并不知道有多少对象要读,
    最好是把要写的多对象装入一个列表里
    with open("cattt", mode = "wb") as f:
        pickle.dump(lst, f)
    
    with open("cattt", mode = "rb") as f:
        lst = pickle.load(f)
    for el in lst:
        el.catchMouse()
五. json　　https://www.cnblogs.com/loleina/p/5623968.html
    全称: javascript object notation jr对象简谱, 是一种轻量级的数据交换格式。Json最广泛的应用是作为AJAX中web服务器和客户端的通讯的数据格式
    javascript中的json类似python中的字典
    python: True, False, None
    json: true, false, null
    我们的程序时python写的, 但是前端是在JS那边解析json的, 所以, 我们需要把程序产生的字典转化成json格式的json串, 字符串
    1.dumps()    把对象序列化成json
    2.loads()    把json反序列化成对象
    dic = {"a": "女王", "b": "萝莉", "c": "小清新"}
    s = json.dumps(dic, ensure_ascii=False)     # 把字典转化成字符串

　　# ensure_ascii：默认值True，如果dict内含有non-ASCII的字符，则会类似\uXXXX的显示数据，设置成False后，就能正常显示

print(s)
    {'a': '女王', 'b': '萝莉', 'c': '小清新'}
    dic = json.loads(s)
    print(type(dic), dic)
    <class 'dict'> {'a': '女王', 'b': '萝莉', 'c': '小清新'}
    3.dump()    把对象序列化写入文件
    4.load()    把文件中的内容反序列化成对象
    lst = [{"a": 1}, {"b": 2}, {"c": 3}]
    # 写入
    with open("test.json", mode = "w", encoding = "utf-8") as f:
        for el in lst:
            s = json.dumps(el, ensure_ascii=True) + "\n"
            f.write(s)
    # 读取
    with open("test.json", mode = "r", encoding = "utf-8") as f:
        for line in f:
            dic = json.loads(line.strip())
            print(dic)
　# 两个函数的唯一区别就是dump把python对象转换成json对象生成一个fp的文件流，而dumps则是生成了一个字符串

参数设置,格式化输出学习一下: https://www.cnblogs.com/Eva-J/articles/7228075.html#_label9