python 常用模块(一): os模块,序列化模块(json模块 pickle模块 )

1.os模块

2.序列化模块:(1)json模块 和 pickle模块

一.os模块

os.path.abspath:

(1)把路径中不符合规范的/改成操作系统默认的格式

import os
path = os.path.abspath('C:/Administrator/PycharmProjectsled3/模块/day 19/ 课堂回顾,作业.py')
print(path)

#结果:
C:\Administrator\PycharmProjectsled3\模块\day 19\ 课堂回顾,作业.py

(2)能够给找到的相对路径改成绝对路径

import os
path = os.path.abspath('4.os模块.py')
print(path)

#结果:
E:\python_01\day19\code\day19\4.os模块.py

os.path.split:把一个路径分为两段,第二段是一个文件/文件夹

import os
path= os.path.split('D:/sylar/s15/day19/4.os模块.py')
print(path)
path= os.path.split('D:/sylar/s15/day19')
print(path)

#结果:
('D:/sylar/s15/day19', '4.os模块.py')
('D:/sylar/s15', 'day19')

os.path.dirname(path):返回path的目录。其实就是os.path.split(path)的第一个元素 

os.path.basename(path):返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素

注:

如果你两个值都需要 os.path.split

如果你只要一个值 os.path.dirname/os.path.basename

import os
ret1 = os.path.dirname('C:\Administrator\PycharmProjectsled3\模块\day 19\01 课堂回顾,作业.py')
print(ret1)

ret2 = os.path.basename('C:\Administrator\PycharmProjectsled3\模块\day 19\01 课堂回顾,作业.py')

print(ret2)

#结果:
C:\Administrator\PycharmProjectsled3\模块

day 19 课堂回顾,作业.py

os.path.exists:判断文件/文件夹是否存在

import os
ret = os.path.exists('C:\Administrator\PycharmProjectsled3\模块\day 19\01 课堂回顾,作业.py')
print(ret)

#结果:
False

os.path.isabs:判断是否为绝对路径.

import os
res1 = os.path.isabs('4.os模块.py')
res2 = os.path.isabs(r'D:\sylar\s15\day19\4.os模块.py')
print(res1)
print(res2)

#结果:
False
True

os.path.isdir:判断是否为一个文件夹

os.path.isfile:判断是否为一个文件

os.path.join:将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

os.path.getatime(path):返回path所指向的文件或者目录的最后访问时间

os.path.getmtime(path):返回path所指向的文件或者目录的最后修改时间

os.path.getsize: 查看文件大小

size= os.path.getsize(r'D:\sylar\s15\day19\4.os模块.py')  # 查看文件大小
print(size)

ret1 = os.path.getsize('D:\sylar\s15\day19')
ret2 = os.path.getsize('D:\sylar\s15\day18')
ret3 = os.path.getsize('D:\sylar\s15\day17')
ret4 = os.path.getsize('D:\sylar\s15')
print(ret1,ret2,ret3,ret4)

# 所有的文件夹 都至少是4096个字节
#
# 64字节 + 32字节/新文件

二.序列化模块

序列化: 字符串  bytes

序列: 字符串, 列表, 元组, bytes

序列化: 把其他数据类型转化成 字符串 bytes  的过程.

dic = {'':''}
print([str(dic),dic])

#结果:
["{'1': '2'}", {'': ''}]

为什么把其他数据类型转换成字符串类型?
因为能够在网上能传播的只能是bytes,
能够储存在文件里的只有bytes 和 str.

转字符串的过程 不就是数据类型的强制转换么?为什么要学个序列化模块?

# 字符串 -> 字典
str_dic = str([1,2,3])
print(str_dic,type(str_dic))

#结果:
[1, 2, 3] <class 'str'>

# 文件中读出来的 网络上接收来的
res = eval(str_dic)
print(res,type(res))

#结果:
[1, 2, 3] <class 'list'>

eval 要谨慎的使用,用户的输入/网络上接收的数据/文件中的内容
事前不知情接受的的或者其他方式传输的进行读取时,用eval要谨慎,
只有在你已知的代码 但是可能需要一些拼接 根据你自己的逻辑去做的拼接.

序列化的目的:

(1)以某种存储形式使自定义对象持久化；

(2)将对象从一个地方传递到另一个地方。

(3)使程序更具维护性。

 

(1)josn模块; Json模块提供了四个功能：dumps、dump、loads、load

josn.dumps:

import json
dic = {'key' : 'value','key2' : 'value2'}
ret = json.dumps(dic)  # 序列化
print(dic,type(dic))
print(ret,type(ret))

#结果:
{'key': 'value', 'key2': 'value2'} <class 'dict'>
{"key": "value", "key2": "value2"} <class 'str'>

josn.laods:

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

#结果:
{'key': 'value', 'key2': 'value2'} <class 'dict'>

问题1:

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

#结果:
{1: 'value', 2: 'value2'} <class 'dict'>           key不是str
{"": "value", "": "value2"} <class 'str'>     key为str

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

#结果:
{'': 'value', '': 'value2'} <class 'dict'>       key为str    

问题2:

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

#结果:
{1: [1, 2, 3], 2: (4, 5, 'aa')} <class 'dict'>
{"": [1, 2, 3], "": [4, 5, "aa"]} <class 'str'>      

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

#结果:
{'': [1, 2, 3], '': [4, 5, 'aa']} <class 'dict'>

同问题一,字典中列表所对应的key 反序列后也变成了str

问题3:

import json
s = {1,2,'aaa'}
json.dumps(s)

#结果:
TypeError: Object of type 'set' is not JSON serializable
  # json 序列化的对象里没有集合数据类型

问题4:

import json json.dumps({(1,2,3):123})

#结果: TypeError: keys must be a string

# key 必须是字符串类型

补充:

json 在所有的语言之间都通用 : json序列化的数据 在python上序列化了 那在java中也可以反序列化

能够处理的数据类型是非常有限的 : 字符串 列表 字典 数字

字典中的key只能是字符串

向文件中记录字典

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

josn.dump  , josn.laod:是直接操作文件的 , 例子如上:

问题5:不支持连续的存 取

import json
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())

#结果:  会报错  

需求 :就是想要把一个一个的字典放到文件中,再一个一个取出来???

import json
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')

with open('json_file','r') as f:
    for line in f:
        dic = json.loads(line.strip())
        print(dic.keys())

注:  json

dumps loads
    在内存中做数据转换 :
        dumps 数据类型 转成 字符串 序列化
        loads 字符串 转成 数据类型 反序列化
dump load
    直接将数据类型写入文件,直接从文件中读出数据类型
        dump 数据类型 写入 文件 序列化
        load 文件 读出 数据类型 反序列化
json是所有语言都通用的一种序列化格式
    只支持 列表 字典 字符串 数字
    字典的key必须是字符串

拓展:  ensure_ascii  (显示中文)

(2)pickle模块:

<1>支持在python中几乎所有的数据类型

dic = {(1,2,3):{'a','b'},1:'abc'}

<2>dumps 序列化的结果只能是字节

import pickle
dic = {(1,2,3):{'a','b'},1:'abc'}

ret = pickle.dumps(dic)
print(ret)

#结果:
b'\x80\x03}q\x00(K\x01K\x02K\x03\x87q\x01cbuiltins\nset\nq\x02]q\x03(X\x01\x00\x00\x00bq\x04X\x01\x00\x00\x00aq\x05e\x85q\x06Rq\x07K\x01X\x03\x00\x00\x00abcq\x08u.'

<3>只能在python中使用  #因为你如果写的代码类型在其他操作系统没有的代码类型就不可以被 序列化(像: 元组之类的)

dic = {(1,2,3):{'a','b'},1:'abc'}

ret = pickle.dumps(dic)
print(ret)
print(pickle.loads(ret))

#结果:
b'\x80\x03}q\x00(K\x01K\x02K\x03\x87q\x01cbuiltins\nset\nq\x02]q\x03(X\x01\x00\x00\x00bq\x04X\x01\x00\x00\x00aq\x05e\x85q\x06Rq\x07K\x01X\x03\x00\x00\x00abcq\x08u.'

{(1, 2, 3): {'b', 'a'}, 1: 'abc'}

<4>在和文件操作的时候,需要用rb wb的模式打开文件

import pickle

dump

with open('pickle_file','wb') as f: pickle.dump(dic,f)

laod

with open('pickle_file','rb') as f:

ret = pickle.load(f)

print(ret,type(ret))

<5>可以多次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'}
import pickle
with open('pickle_file','wb') as f:         #多次dump
    pickle.dump(dic, f)
    pickle.dump(dic1, f)
    pickle.dump(dic2, f)
    pickle.dump(dic3, f)

with open('pickle_file','rb') as f:          #多次laod
    while True:
        try:
            ret = pickle.load(f)
            print(ret,type(ret))
        except EOFError:
            break