python葵花宝典第19式-os模块、序列化模块（json、pickle）

python葵花宝典第19式-os模块、序列化模块（json、pickle）

1、os模块
os模块所做的事情：
①定制了许多方法，间接地帮助使用者去调用操作系统的命令，获得结果。然后帮助你分析整理成我们需要的数据类型的形态。
②也可以使用os.popen/os.system直接获取调用操作系统命令，获得结果，但是分析和整理的工作需要自己完成。

（1）使用python代码统计一个文件夹中所有文件的大小：

#coding:utf-8
import os

#递归
def fun(path):
    size_sum = 0
    name_list = os.listdir(path)#["day01","day02",...]
    for name in name_list:#"day01"
        path_abs = os.path.join(path,name)
        if os.path.isdir(path_abs):#True
            size = fun(path_abs)
            size_sum += size
        else:
            size_sum += os.path.getsize(path_abs)
    return size_sum

ret = fun(r"D:/biancheng/pythonCODE/PythonLearn")
print(ret)

结果：
92035218

（2）使用循环获取文件夹文件的总大小

import os

#列表的第一个目录就是我们要统计的目录
lst = [r"D:/biancheng/pythonCODE/PythonLearn",]
size_num = 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_num += os.path.getsize(abs_path)
print(size_num)

（3）统计文件的大小、显示当前路径下的而所有文件和文件夹
①统计文件的大小
os.path.getsize(“路径”) #pyhton的命令
dir 路径 \c #操作系统的命令
②显示当前路径下的而所有文件和文件夹
dir 路径 #操作系统命令
os.listdir(“路径”) #python的os提供的文件
③getcwd #获取当前执行命令的时候所在的目录
chdir #修改当前执行命令的时候所在的目录

19.2 序列化模块
1、序列和序列化
序列：列表、元组、字符串、bytes
序列化：字符串 bytes
序列化就是：把其他的数据类型转换成字符串、bytes，就是序列化过程

dic = {"1":"2"}
print([str(dic),dic])
print([str([1,2,3]),[1,2,3]])

（1）为什么进行序列化（把其他类型的数据转换成字符串）?
答：能够在网络上传输的只能是bytes,能够存储在文件里的只有bytes和str
（2）转换字符串的过程，不就是将数据类型进行强制转换吗？为什么还要学习序列化模块？
注意：①eval()要谨慎使用，用户的输入、网络上接收的数据、文件的内容
②在一直的代码，但是有可能需要一些拼接，可以使用eval()

示例：（序列化和反序列化）

#coding:utf-8
dic = {"key":"value","key2":"value2"}
import json
ret = json.dumps(dic)#序列化
print(dic,type(dic))
print(ret,type(ret))

res = json.loads(ret) #反序列化
print(res,type(res))

结果：
{‘key’: ‘value’, ‘key2’: ‘value2’} <class ‘dict’>
{“key”: “value”, “key2”: “value2”} <class ‘str’>
{‘key’: ‘value’, ‘key2’: ‘value2’} <class ‘dict’>

问题1：

dic = {1:"value",2:"value2"}
import json
ret = json.dumps(dic)#序列化
print(dic,type(dic))
print(ret,type(ret))

res = json.loads(ret)
print(res,type(res))#反序列化

结果：
{1: ‘value’, 2: ‘value2’} <class ‘dict’>
{“1”: “value”, “2”: “value2”} <class ‘str’>
{‘1’: ‘value’, ‘2’: ‘value2’} <class ‘dict’>

问题2：

dic = {1:[1,2,3],2:(4,5,"ai")}
import json
ret = json.dumps(dic)#序列化
print(dic,type(dic))
print(ret,type(ret))

res = json.loads(ret)
print(res,type(res))#反序列化

结果：
{1: [1, 2, 3], 2: (4, 5, ‘ai’)} <class ‘dict’>
{“1”: [1, 2, 3], “2”: [4, 5, “ai”]} <class ‘str’>
{‘1’: [1, 2, 3], ‘2’: [4, 5, ‘ai’]} <class ‘dict’>
注意：
（1） json能够处理额数据类型是非常有限的：字符串、列表、字典、数字
（2） json处理的字典中key只能是字符串
（3） json在所有的语言中是通用的（json序列化的数据）

2、json.dumps()、json.loads()
(1)向文件中记录字典

import json
dic = {"key":"value","key2":"value2"}#创建字典
ret = json.dumps(dic)#序列化
with open("json_file","a") as f:#写入文件
    f.write(ret)

(2)从文件中读取字典

import json
with open("json_file","r") as f:#读取文件
    str_dic = f.read()
dic = json.loads(str_dic)#反序列化
print(dic.keys())

结果：
dict_keys([‘key’, ‘key2’])

3、json.dump()、json.load()
(1)向文件中记录字典

import json
dic = {"xiao":"ni","da":"ze"}
with open("json_file","a") as f:
    json.dump(dic,f)

(2)从文件中读取字典

import json
with open("json_file","r") as f:
    dic = json.load(f)
print(dic.keys())

结果：
dict_keys([‘key’, ‘key2’])

注意：
①尽管可以对json文件进行多次dump(),但是却不能load()出来，因此切记不可多次dump()。不支持连续的多次存、取。
②如果要进行字典一个一个写入、再一个一个读取，这时候就需要我们按照一定格式进行写入。

一个一个读写文件：

import json
dic = {"xiao":"ni","da":"ze"}

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

4、总结（dumps、loads、dump、load）
(1)dumps、loads:在内存中做数据转换
dumps:数据类型->字符串 序列化
loads:字符串->数据类型 反序列化
(2)dump、load:直接进行数据类型与文件的转换
dump:数据类型->文件 序列化
load:文件->数据类型 反序列化
(3)json是所有语言都通用的一种序列化格式
只支持列表、字典、字符串、数字格式
字典的key必须是字符串

19.3 pickle模块
1、pickle.dumps()、pickle.loads()
（1）支持在python中几乎所有的数据类型
（2）dumps序列化的结果只能是字节
（3）只能在python中使用
（4）在和文件操作的时候，需要rb、wb的模式打开文件
（5）可以多次dump和多次load

import pickle
dic = {(1,2,3):{"a","b"},1:"abc"}
ret = pickle.dumps(dic)
print(pickle.loads(ret))

2、dump()、load()
(1)dump()

import pickle
dic = {(1,2,3):{"a","b"},1:"abc"}
with open("pickle_file","wb") as f:
    pickle.dump(dic,f)

（2）load()

import pickle
with open("pickle_file","rb") as f:
    ret = pickle.load(f)
    print(ret,type(ret))

运行结果：
{(1, 2, 3): {‘b’, ‘a’}, 1: ‘abc’} <class ‘dict’>

（3）可以多次dump和多次load

import pickle
dic = {(1,2,3):{"a","b"},1:"abc"}
dic2 = {(1,2,3):{"a","b"},2:"abc"}
dic3 = {(1,2,3):{"a","b"},3:"abc"}
dic4 = {(1,2,3):{"a","b"},4:"abc"}

with open("pickle_file","wb") as f:
    pickle.dump(dic,f)
    pickle.dump(dic2, f)
    pickle.dump(dic3, f)
    pickle.dump(dic4, f)

使用读取：

import pickle
with open("pickle_file","rb") as f:
    while True:
        try:
            ret = pickle.load(f)
            print(ret,type(ret))
        except EOFError:
            break

运行结果：
{(1, 2, 3): {‘a’, ‘b’}, 1: ‘abc’} <class ‘dict’>
{(1, 2, 3): {‘a’, ‘b’}, 2: ‘abc’} <class ‘dict’>
{(1, 2, 3): {‘a’, ‘b’}, 3: ‘abc’} <class ‘dict’>
{(1, 2, 3): {‘a’, ‘b’}, 4: ‘abc’} <class ‘dict’>

本期学习就到这里，欢迎关注、批评指正。