模块二

标签：字符   网络   break   error:   路径   pen   读取   port   get   

模块 json pickle os sys hashlib collections

1. 序列化模块

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

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

• 1. 主要用途:

     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. 单行写入还原:将对象转换为字符串写入文件

        2. # 1.将字典以字符串的形式写入文件
           import json
           f = open("序列化","w")   #写不写encoding="utf-8" 都可以
           dic = {"alex":"Teacher","宝元":"中国"}
           json.dump(dic,f)     #文教中内容:{"alex": "Teacher", "\u5b9d\u5143": "\u4e2d\u56fd"}
           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", "\u5b9d\u5143", "\u4e2d\u56fd"]
     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 + "\n")      #  {"1": "alex"}
f.write(s2 + "\n")      #  [1, 2, 3, 4]
f.write(s3 + "\n")      #  [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'\x80\x03(K\x01K\x02K\x03X\x06\x00\x00\x00\xe5\xae\x9d\xe5\x85\x83q\x00tq\x01.' <class 'bytes'>
  #类似字节
  
  2.将字符串转回原数据类型
  a = pickle.loads(s)
  print(a,type(a))   #(1, 2, 3, '宝元') <class 'tuple'>

1. 转换函数的函数名

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

2. 用于文件写读 单行 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'>

1. 用于多行写读 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()

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

1.写入文件,在文件中呈现多行
import pickle
dic = {"alex":"泰国","baoyuan":"中国"}
f = open("序列化","wb")
s = "\n".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:\新建文件夹\PyCharm\day17

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

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:\新建文件夹\PyCharm\day17"))---['day17 练习.py', 'pickle练习1.pickle', '序列化']

2.3 文件

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

2.4 路径

模块二

标签：字符   网络   break   error:   路径   pen   读取   port   get   

原文地址：https://www.cnblogs.com/lvweihe/p/11276025.html