常用模块 os模块 序列化模块

os.path.abspath(path) 返回这个文件的绝对路径
os.path.split(path) 把一个路径分成两段 第二段是一个文件/文件夹
os.path.dirname(path) 返回path的目录
os.path.basename(path) 返回path 最后的文件名
os.path.exists（path）如果路径存在 那么返回True ，不存在 返回false
os.path.isabs(path)判断是否是绝对路径
os.path.isfile(path)判断是否是一个文件 
os.isdir(path) 判断文件或文件夹是否存在
os.path.join(path1[...path2,path3])将多个路径组合后返回
os.path.getmtime(path) 返回path 指向的文件或者目录的最后访问时间
os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小
os.listdir 查看文件下的目录

#拿到这个我文件夹下所有的文件或文件夹
是文件就取文件大小 是文件夹就再打开这个文件夹，在取文件 计算大小

递归
import os
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(文件夹路径)
print(ret)




循环
import os
lst=['C:python文件',]     列表
size_sum=0
while lst:       循环列表
    path=lst.pop()     把列表中的元素弹出来
    path_list=os.listdir(path)    查看路径下的文件 
    for name in path_list:         循环文件
        path_abs=os.path.join(path,name)    
        if os.path.isdir(path_abs):      文件夹的逻辑
            lst.append(path_abs)
        else:
            size_sum+=os.path.getsize(path_abs)
print(size_sum)

1 序列化模块

什么叫序列化？-----将原本的字典。列表等内容转换成一个字符串的过程就叫做序列化

序列化：字符串 bytes

序列： 列表，元组，字符串，bytes

为什么要把其他的数据类型转换成字符串？
1 能够在网络上传输的只能是bytes

2 能够在存储在文件里的只能是bytes和str

json 模块

1 json模块提供了四个功能：dumps,dump,loads.load

2 json在所有的语言之间都通用：json序列化的数据 在python上序列化了，能过处理的数据类型是非常有限的：字符串 列表 字典 数字，字典中的key值必须是字符串

3

import json
dic ={'k1':'v1','k2':'v2','k3':'v3'}
str_dic=json.dumps(dic)   #序列化 ;将一个字典转换成一个字符串
print(str_dic,type(str_dic))
#注意json换完的字符串类型的字典中的字符串是由”“表示
# 结果：{"k1": "v1", "k2": "v2", "k3": "v3"} <class 'str'>


dic2=json.loads(str_dic)    #反序列化：将字符串格式的字典转换成一个字典
print(dic2,type(dic2))
#结果：{'k1': 'v1', 'k2': 'v2', 'k3': 'v3'} <class 'dict'>

dump 和load是直接操作文件的
import json
# dic ={'k1':'v1','k2':'v2','k3':'v3'}
# with open('json_file',mode='a') as f:   
#     json.dump(dic,f)       将字典转换成字符串写入到文件中


with open('json_file',mode='r') as f:
    dic=json.load(f)    从文件中将字符串字典转换成字典
print(dic.keys())

问题一：
import json
dic = {1 : 'value',2 : 'value2'}
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'>      反序列化之后  int类型的1 变成了字符串类型的‘1’    和原来的的字典不一样 因此在使用json方法的序列化和反序列化时 不能用数字作为键


问题2
import json
dic = {r : [1,2,3],t : (4,5,'aa')}
ret = json.dumps(dic)  # 序列化
print(dic,type(dic))
print(ret,type(ret))

结果：
{r: [1, 2, 3], 2: (4, 5, 'aa')} <class 'dict'>
{"r": [1, 2, 3], "2": [4, 5, "aa"]} <class 'str'>
 
在序列化的时候元组变成列表了  

问题3
mport json
s = {1,2,'aaa'}  集合不是
json.dumps(s)

结果：TypeError: Object of type 'set' is not JSON serializable

问题4：
json.dumps({(1,2,3):123})
keys must be a string

键值必须时字符串类型

import json
dic= {'key' : 'value','key2' : 'value2'}
ret=json.dumps(dic)
with open('json_file','a') as f:
    f.write(ret)


with open('json_file','r') as f:
    str_dic=f.read()
    dic=json.loads(str_dic)
    json.loads(f)

存文件
dic = {'key1' : 'value1','key2' : 'value2'}
with open('json_file','a') as f:
     str_dic=json.dumps(dic)
     f.write(str_dic+'
')
     str_dic = json.dumps(dic)
     f.write(str_dic + '
')
     str_dic = json.dumps(dic)
     f.write(str_dic + '
')
     



读取文件
with open('json_file','r') as f:
for line in f:
    dic=json.loads(line.strip())
    print(dic.kes())

4 json 中的dumps loads 和dump load的区别

(1)dumps loads

在内存中做数据类型转换：

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

loads    字符串类型 转成 数据类型 反序列化

(2) dump load

直接将数据类型写入文件，直接从文件中读出数据类型

   dump 数据类型 写入 文件 序列化   

   load   文件 读出 数据类型  反序列化

   dump 在存取文件时能连续存 但读取的时候（load）不能连续取

pickle模块：pickle模块提供了四个功能：dumps、dump(序列化，存）、loads（反序列化，读）、load  （不仅可以序列化字典，列表...可以把python中任意的数据类型序列化）