模块二

模块 json pickle os sys hashlib collections

1. 序列化模块

​ 推荐使用json json是各种语言通用的# pickle(python私有)

• 1.定义:就是将一个常用的数据化结构转化成一个特殊的序列,并且将这个特殊的序列还可以反解回去

• 2. 主要用途:

     1. json模块: 不能是set集合

     2. 网络传输数据:json.dumps json.loads 注意元组 字典,,列表 没问题

        1.将字典转换为字符串类型
        import json
        dic = {"alex":"it",1:"宝元"}
        s = json.dumps(dic,ensure_ascii=False) #关闭ascii码
        print(s,type(s))  #{"alex": "it", "1": "宝元"} <class 'str'>
        
        2.将字符串类型转回字典类型
        dct = json.loads(s)
        print(dct,type(dct))  #{'alex': 'it', '1': '宝元'} <class 'dict'>
        

        1.将元组转换为字符串类型
        import json
        tu = (1,2,"清华")
        a = json.dumps(tu,ensure_ascii=False)
        print(a,type(a))  #[1, 2, "清华"] <class 'str'>
        
        2.将字符串类型转换为元组--(相同方法转换为了**列表**)
        b = json.loads(a)
        print(b,type(b))   ### [1, 2, '清华'] <class 'list'>
        print(tuple(b),type(tuple(b)))  ###  (1, 2, '清华') <class 'tuple'>
        

     3. 文件读写数据; 文件中写入的都是以字符串形式

        1. 单行写入还原:将对象转换为字符串写入文件

        # 1.将字典以字符串的形式写入文件
        import json
        f = open("序列化","w")   #写不写encoding="utf-8" 都可以
        dic = {"alex":"Teacher","宝元":"中国"}
        json.dump(dic,f)     #文教中内容:{"alex": "Teacher", "u5b9du5143": "u4e2du56fd"}
        f.close()
        #2.将文件中的字符串类型的字典转换成字典
        import json
        f1 = open("序列化","r")   #写不写encoding="utf-8" 都可以
        dic1 = json.load(f1)
        print(dic1,type(dic1))   #{'alex': 'Teacher', '宝元': '中国'} <class 'dict'>
        f1.close()
        

        以元组为例 存储的是以列表形式

     # 1.将元组以字符串的形式写入文件
     import json
     f = open("序列化","w",encoding="utf-8")
     tu = ("alex","Teacher","宝元","中国")
     json.dump(tu,f)   # ["alex", "Teacher", "u5b9du5143", "u4e2du56fd"]
     f.close()
     #2.将文件中的字符串类型的字典转换成元组   #先转换为列表,在自行转换元组#
     import json
     f1 = open("序列化","r",encoding="utf-8")
     tu1 = json.load(f1)
     print(tu1,type(tu1))      #['alex', 'Teacher', '宝元', '中国'] <class 'list'>
     print(tuple(tu),type(tuple(tu)))   #('alex', 'Teacher', '宝元', '中国') <class 'tuple'>
     f1.close()
     

     • 多行写入还原:将文件中的字符串还原为数据类型

#3.写入多个文件 或多行
import json
dic = {1:"alex"}
lst = [1,2,3,4]
t = (3,45,6)
f = open("序列化","w",encoding="utf-8")
s1 = json.dumps(dic)
s2 = json.dumps(lst)   --- 注意事项加了 s
s3 = json.dumps(t)
f.write(s1 + "
")      #  {"1": "alex"}
f.write(s2 + "
")		#  [1, 2, 3, 4]
f.write(s3 + "
")		#  [3, 45, 6]
f.close()

读回来
import json
f = open("序列化",encoding="utf-8")
for i in f:
    print(json.loads(i),type(json.loads(i)))
 结果:
{'1': 'alex'} <class 'dict'>
[1, 2, 3, 4] <class 'list'>
[3, 45, 6] <class 'list'>  ##注意换成列表了

pickle 模块 元组,列表,字典数据类型不变

• 1.以元组为例 pickle.dumps pickle.loads

  1.将元组转换为字符串
  import pickle
  tu = (1,2,3,"宝元")
  s = pickle.dumps(tu)
  print(s,type(s))   ##b'x80x03(Kx01Kx02Kx03Xx06x00x00x00xe5xaex9dxe5x85x83qx00tqx01.' <class 'bytes'>
  #类似字节
  
  2.将字符串转回原数据类型
  a = pickle.loads(s)
  print(a,type(a))   #(1, 2, 3, '宝元') <class 'tuple'>
  

2. 转换函数的函数名

   import pickle
   def func():
       print("数据类型又转回来了")
   
   f = pickle.dumps(func)
   print(f, type(f))    ##b'x80x03c__main__
   func
   qx00.' <class 'bytes'>
   pickle.loads(f)()   # 数据类型又转回来了
   

3. 用于文件写读 单行 pickle.dump pickle.load

   1.写入文件
   import pickle
   lst = [1,2,"alex","北京"]
   f = open("序列化","wb") #写入的是类似字节,用wb
   pickle.dump(lst,f)      ##   �]q (K
   KX   alexq
   X   鍖椾含qe.
   f.close()
   
   2.返回原文件
   f = open("序列化","rb")
   print(pickle.load(f))    #[1, 2, 'alex', '北京']
   

f = open("序列化","rb")
print(pickle.load(f))    #[1, 2, 'alex', '北京']
print(type(pickle.load(f)))   ##报错-------------------##报错

f = open("序列化","rb")
d = pickle.load(f)
print(d,type(d))    #[1, 2, 'alex', '北京'] <class 'list'>

4. 用于多行写读 pickle.dump pickle.load

1.向文件中写入多行代码
import pickle
dic = {1:"中国"}
lst = [1,2,"alex","北京"]
tu = (1,"土豆")
f = open("序列化","wb")
pickle.dump(dic,f)
pickle.dump(lst,f)
pickle.dump(tu,f)    ##�}q K
X   涓�浗q
s.�]q (K
KX   alexq
X   鍖椾含qe.�K
X   鍦熻眴q 唓
.     ##代码在同一行
f.close()

将文件中代码输出 第一种
f = open("序列化","rb")   ## 读字节
print(pickle.load(f))   #  {1: '中国'}
print(pickle.load(f))   #   [1, 2, 'alex', '北京']
print(pickle.load(f))    #  (1, '土豆')
@#读取的行数可以少,不能多

将文件中代码输出 第二种
f = open("序列化","rb")   ## 读字节
while True:
    try:
        print(pickle.load(f))
    except EOFError:
        break
f.close()

5. 用于多行写读 pickle.dumps pickle.loads

1.写入文件,在文件中呈现多行
import pickle
dic = {"alex":"泰国","baoyuan":"中国"}
f = open("序列化","wb")
s = "
".encode("utf-8")
f.write(pickle.dumps(dic) + s)
f.write(pickle.dumps(dic) + s)    #-----加  s  了
f.write(pickle.dumps(dic) + s)
f.close()
结果:
�}q (X   alexq
X   娉板浗qX   baoyuanqX   涓�浗qu.
�}q (X   alexq
X   娉板浗qX   baoyuanqX   涓�浗qu.
�}q (X   alexq
X   娉板浗qX   baoyuanqX   涓�浗qu.

2.将文件读取
f1 = open("序列化","rb")
for i in f1:
    print(pickle.loads(i))

2. os 模块

• 1.定义: 模块与操作系统之间的接口(程序员通过python向系统发送指令)

2.1 工作目录

import os
os.getcwd()-------获取当前工作路径  
例如:print(os.getcwd()) --------E:新建文件夹PyCharmday17

import os
os.chdir()---------路径切换 --#等同于cmd终端输入cd 文件路径
os.chdir("E:新建文件夹PyCharmday04")
print(os.getcwd())----E:新建文件夹PyCharmday04

import os
os.curdir-----返回当前目录
print(os.curdir)-----结果是一个点   .   表示当前

import os
os.pardir--------获取当前目录的父目录字符串名  
print(os.pardir)-----结果是一个点   ..   表示当前父目录

2.2 文件夹

import os
os.mkdir()-----创建一个文件夹
os.mkdir("来一个")----同级目录下创建了一个名为"来一个"的空文件夹

import os
os.rmdir()-----删除一个文件夹
os.rmdir("来一个")-----删除了此文件(此文件必须为空的,不能有东西)

import os
os.makedirs()-------------递归创建文件
os.makedirs("a/b/c")-----创建三个文件夹

import os
os.removedirs()------------递归删除文件
os.makedirs("a/b/c")-----删除三个文件夹

import os
os.listdir()----获取当前文件夹下的子目录
print(os.listdir("E:新建文件夹PyCharmday17"))---['day17 练习.py', 'pickle练习1.pickle', '序列化']

2.3 文件

import os 
os.rename("要修改的文件名","修改后的文件名")

2.4 路径