Python 模块II（json、os等）

1.今日大纲

1. 序列化模块（json，pickle）
2. sys模块
3. os模块
4. hashlib模块（md5，sha系列）

2.具体内容

1. 系列化模块

   • 将一个数据结构转化成一个特殊序列（特殊字符串）的过程

   • 可以反转

   • 将一个字符串转化为一个数据结构，可以使用eval()方法，但此方法危险系数极大，会将代码流内部潜在的“病毒程序”同时运行

   • json模块（两对四个方法）

     • 是所有语言公认的一种序列
     • dumps，loads 主要用与网络传输，也可以用于文件的存取
     • dump，load 单个数据的存取文件

     import json
     dic = {'one':1,'two':2}
     #dumps，loads
     ret = json.dumps(dic,ensure_ascii = False)
     print(ret,type(ret))#{"one":1,"two":2}  <class 'str'>
     
     ret_dic = json.loads(ret)
     print(ret_dic,type(ret_dic))#{'one':1,'two':2} <class 'dict'>
     
     #文件传输（dumps，loads）
     with open('json1.json',mode='w')as f:
       ret = json.dumps(dic)
       f.write(ret)
       
     with open('json1.json')as f:
       content = f.read()
       print(json.loads(content))
       
     #dump，load ：单个数据的存取文件
     with open('json2.json',mode='w')as f:
       json.dump(dic,f)
     
     with open('json2.json')as f:
       ret = json.load(f)
       print(ret)
       
     #多个数据存储到一个文件中（dumps，loads）
     dic1 = {'one1':1,'two':2}
     dic2 = {'one2':1,'two':2}
     dic3 = {'one3':1,'two':2}
     with open('jsonmore.json',mode ='w')as f:
       f.write(f'{json.dumps(dic1)}\n{json.dumps(dic2)}\n{json.dumps(dic3)}')
       
     with open('jsonmore.json')as f:
       for line in f:
         ret json.loads(line)
         print(ret)
     

   • pickle模块

     • 只能在python语言中使用，支持所有的数据类型
     • dumps，loads，只能用于网络传输
     • dump，load，数据结构存取

     import pickle
     #dumps,loads 只能用于网络传输
     l1 = [111,222,333]
     ret = pickle.dumps(l1)
     print(ret,type(ret))#<class 'bytes'>
     
     l2 = pickle.loads(ret)
     print(l2,type(l2))#<class 'list'>
     
     #dump，load 数据结构存取
     with open('pick练习',mode='w')as f:
       pickle.dump(l1,f)
     
     with open('pick练习')as f:
       ret = pickle.load(f)
       print(ret)
       
     #多个文件写入
     l1 = ['one1',222,333]
     l2 = ['one2',222,333]
     l3 = ['one3',222,333]
     with open('pickle练习1',mode='w')as f:
       pickle.dump(l1,f)
       pickle.dump(l2,f)
       pickle.dump(l3,f)
       
     with open('pickle练习1')as f:
       ret1 = pickle.load(f)
       ret2 = pickle.load(f)
       ret3 = pickle.load(f)
       print(ret1,ret2,ret3)
       #['one1',222,333] ['one2',222,333] ['one2',222,333]
       #不需要自己手动添加换行
     

2. sys模块

   • 与python解释器交互的一个接口

   #返回模块的搜索路径
   sys.path
   #返回python解释程序的版本信息
   sys.version
   

3. os模块

   • 与操作系统交互的一个接口，多与工作目录，路径，文件等相关

   #py文件的工作目录相关的工作路径（4）
   
   #1.获取当前工作目录，绝对路径
   print(os.path.getcwd())
   #2.改变当前脚本的工作目录
   os.chdir(路径)
   print(os.getcwd())
   #3.返回当前目录
   print(os.curdir)  #.
   #4.返回当前目录的父目录字符串名
   print(os.pardir) #..
   
   #和文件夹相关的（8）
   
   #1.生成多条递归目录
   os.makedirs('文件1/文件2/文件3')
   #2.删除目录（截止到有文件的那层）
   os.removedirs('文件1/文件2/文件3')
   #3.生成单级目录
   os.mkdir('单级目录')
   #4.删除单级空目录
   os.rmdir('单级空目录')
   #5.列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式返回
   print(os.listdir('文件1'))
   #6.删除一个文件
   os.remove('xxx')
   #7.重命名文件或目录
   os.rename('旧'，'新')
   #8.获取文件/目录信息
   print(os.stat(路径))
   
   #path系列，和路径相关（12）
   
   #1.返回绝对路径
   print(os.path.abspath('路径'))
   #2.将path分割成目录和文件名以二元组返回
   print(os.path.split(r'day017/jsonlxx.json'))
   #(day017', 'jsonlxx.json')
   #3.获取父级目录
   print(os.path.dirname('day017/jsonlxx.json'))#day017
   	#动态获取当前文件的绝对路径
     print(__file__)
     #获取当前文件的爷爷级目录
     print(os.path.dirname(__file__))
   #4.获取文件名
   print(os.path.basename('day017/jsonlxx.json'))#jsonlxx.json
   #5.判断路径是否存在，返回布尔值
   print(os.path.exists('路径'))
   #6.判断是否是绝对路径，返回布尔值
   print(os.path.isabs('路径'))
   #7.判断该路径是否是一个文件路径，返回布尔值
   print(os.path.isfile('路径'))
   #8.判断是否是一个目录
   print(os.path.isdir('路径'))
   #9.多个路径组合返回
   ret = os.path.join('D:','day17','随便')
   print(ret)#D:/day17/随便
   	#例
     par_dir = os.path.dirname(__file__)
     paths = os.path.join(par_dir,'db','date')
     with open(paths,mode='w')as f:
       f.write('123')
   #10.最后访问时间
   print(os.path.getatime('文件路径'))
   #11.最后修改时间
   print(os.path.getmtime('文件路径'))
   #12.文件大小
   print(os.path.getsize('文件路径'))
   
   

4. hashlib模块

   • 其中包括摘要算法，散列算法等，是一系列加密算法的集合

   • 用途：

     • 密码加密
     • 文件一致性校验

   • Md5（）加密

     • 将一个字节类型的数据，通过hashlib加密，返回一个等长的16进制数字的字符串形式
     • 加密过程不可逆
     • 加密前的数据集对加密后的16进制集的映射是按照一一映射的

     import hashlib
     ret = hashlib.md5()
     ret.update('123'.encode('utf-8'))
     s = re.hexdigest()
     print(s)
     
     #固定加盐
     ret = hashlib.md5('XXX'.encode('utf-8'))
     ret.update('123'.encode('utf-8'))
     print(ret.hexdigest())
     
     #动态加盐
     username = input('>>>').strip()
     password = input('>>>').strip()
     ret = hashlib.md5(username[::2].encode('utf-8'))
     ret.update('123'.encode('utf-8'))
     print(ret.hexdigest())
     

   • sha系列，sha+数字，数字越大，加密程度越高，耗时高

     #可加盐，动态盐，同md5
     ret = hashlib.sha512()
     ret.update('123'.encode('utf-8'))
     print(ret.hexdigest())
     

   • 文件一致性验证

     • 网上下载东西，一般来说，都会显示一个经过md5（）加密后的16进制数字的字符串

     

     import hashlib
     def md5_file(path):
       with open(path,mode='rb')as f:
         ret = hashlib.md5()
         while 1:
           content = f.read(1024)
           if content:
             ret.update(content)
           else:
             return ret.hexdigest()