一些好用的内置模块Ⅰ

一, 序列化模块

1. 序列化: 将一种数据结构(数据集)转化成一个特殊的序列(特殊的字符串,bytes)的过程

2. 序列化模块: 序列化模块就是将一个常见的数据结构转化成一个特殊的序列,并且这个特殊的序列还可以反解回去

3. 主要用途: 文件读写数据, 网络传输数据

4. python中的序列化模块:

   • json模块:
     1. 不同语言都遵循的一种数据转化格式,即不同语言都使用的特殊字符串.
     2. 只支持部分python数据结构: dict,list,tuple,str,int,float,True,False,None
   • pickle模块:
     1. 只能在python中使用
     2. 支持python所有的数据类型和对象
   • shelve模块: 了解

5. json模块: 重点

   1. json模块是将满足条件的数据结构转化成特殊的字符串,并且也可以反序列化还原回去

   2. dumps , loads : 主要用于网络传输

      import json
      dic = {'username': '元始天尊', 'password': '123', 'status': False}
      str_dic = json.dumps(dic) # 序列化,默认会以Ascii码转化,想保留中文,可以将ensure_ascii改为False
      print(str_dic, type(str_dic))
      # {"username": "u5143u59cbu5929u5c0a", "password": "123", "status": false} <class 'str'>
      ----------------------------------------------
      dic2 = json.loads(str_dic)
      print(dic2) # {'username': '元始天尊', 'password': '123', 'status': False}
      

   3. dump , load : 单个数据的文件读写

      import json
      dic = {'username': '元始天尊', 'password': '123', 'status': False}
      with open('ceshi.json', mode='w', encoding='utf-8') as f:
          json.dump(dic, f) # 也可以用ensure_ascii关键字
      -----------------------------------------------
      with open('ceshi.json', mode='r', encoding='utf-8') as f:
          print(json.load(f))
      

   4. 存储多个数据到一个文件中

      import json
      dic1 = {'username': '元始天尊', 'password': '123', 'status': False}
      dic2 = {'username': '太上老君', 'password': '123', 'status': False}
      dic3 = {'username': '通天教主', 'password': '123', 'status': False}
      with open('ceshi.json', mode='w', encoding='utf-8') as f:
          str_dic1 = json.dumps(dic1, ensure_ascii=True)
          f.write(str_dic1 + '
      ')
          str_dic2 = json.dumps(dic2, ensure_ascii=True)
          f.write(str_dic2 + '
      ')
          str_dic3 = json.dumps(dic3, ensure_ascii=True)
          f.write(str_dic3 + '
      ')
      --------------------------------------------------
      with open('ceshi.json', mode='r', encoding='utf-8') as f:
          for line in f:
              ret = json.loads(line)
              print(ret, type(ret))
      

6. pickle模块

   1. pickle模块是将python所有的数据结构以及对象等转化成bytes类型,然后还可以反序列还原回去

   2. dumps , lodas : 只用于网络传输

      import pickle
      dic1 = {'username': '元始天尊', 'password': '123', 'status': False}
      ret = pickle.dumps(dic1)  # 转换成bytes类型
      print(ret) # bytes类型
      -------------------------------------------------
      dic = pickle.loads(ret)  # 转回原数据类型
      print(dic, type(dic))
      

   3. dump , load : 只用于写入读取文件

      import pickle
      dic1 = {'username': '元始天尊', 'password': '123', 'status': False}
      with open('ceshi.json', mode='wb') as f:  # 因为是bytes类型,要用b模式,而且不用encoding
          pickle.dump(dic1, f)
      -------------------------------------------------
      with open('ceshi.json', mode='rb') as f:
          print(pickle.load(f))
      

   4. 存储多个数据到一个文件中

      import pickle
      dic1 = {'username': '元始天尊', 'password': '123', 'status': False}
      dic2 = {'username': '太上老君', 'password': '123', 'status': False}
      dic3 = {'username': '通天教主', 'password': '123', 'status': False}
      with open('ceshi.json', mode='wb') as f: 
          pickle.dump(dic1, f)
          pickle.dump(dic2, f)
          pickle.dump(dic3, f)
      -------------------------------------------------
      with open('ceshi.json', mode='rb') as f:
          while 1:
              try:
                  print(pickle.load(f))
              except EOFError:
                  break
      

二, SYS模块

1. sys模块是与python解释器交互的一个接口

2. 常用命令 : sys.path

   import sys
   print(sys.argv) # 命令行参数List,第一个元素是程序本身路径
   print(sys.version) # 获取Python解释程序的版本信息
   print(sys.path) # 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
   print(sys.platform) # 返回操作系统平台名称
   sys.exit() # 退出程序，正常退出时exit(0),错误退出sys.exit(1)
   

三, OS模块(多的要死)

1. os模块是与操作系统交互的一个接口

2. 目录指的是文件夹

3. 当前目录,工作目录,父级目录: 指的都是本文件所在的文件夹

4. 当前执行这个python文件的工作目录相关 : os.getcwd()

   import os
   print(os.getcwd()) # 获取当前工作目录
   os.chdir('目标目录') # 改变当前脚本工作目录
   print(os.curdir) # 返回当前目录 : '.'
   print(os.pardir) # 获取当前目录的父目录字符串名 : '..'
   

5. 和文件夹相关 : 都很重要

   os.makedirs('ceshi1/ceshi2/ceshi3') # 可以生成多次递归目录
   os.removedirs('ceshi1/ceshi2/ceshi3')
   # 若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依此类推
   os.mkdir('ceshi') # 生成单级目录
   os.rmdir('ceshi') # 删除单级空目录,若目录不为空则无法删除,报错
   print(os.listdir('D:')) 
   # 列出指定目录下的所有文件和子目录,包括隐藏文件,并以列表方式返回
   

6. 和文件相关: 都很重要

   os.remove('ceshi.txt') # 删除一个文件
   os.rename('oldname', 'newname') # 重命名文件/目录
   os.stat('path/filename') # 获取文件/目录的信息并返回
   

7. 和操作系统差异相关 : 运维相关

   print(os.sep) # 输出操作系统特定的路径分隔符,win下为"\",Linux下为"/"
   print(os.linesep) # 输出当前平台使用的行终止符，win下为"	
   ",Linux下为"
   "
   print(os.pathsep) # 输出用于分割文件路径的字符串 win下为;,Linux下为:
   print(os.name) # 输出字符串指示当前使用平台,win->'nt'; Linux->'posix'
   os.system('bash command') # 运行shell命令,直接显示
   os.popen('bash command').read() # 运行shell命令,获取执行结果
   print(os.environ) # 获取系统环境变量
   

8. path系列,和路径相关: 很多,但是都很重要

   print(os.path.abspath(path)) # 返回path的绝对路径
   print(os.path.split(path)) # 将path分割成目录和文件名,并以元组返回
   print(os.path.dirname(path))
   # 返回path的目录,其实就是os.path.split(path)的第一个元素
   print(os.path.basename(path))
   # 返回path最后的文件名,如果path以/或结尾,那么就会返回空值,即os.path.split(path)的第二项
   print(os.path.exists(path)) # 如果path存在,返回True;如果path不存在,返回False
   print(os.path.isabs(path)) # 如果path是绝对路径,返回True,否则返回False
   print(os.path.isfile(path)) # 如果path是一个存在的文件,返回True,否则返回False
   print(os.path.isdir(path)) # 如果path是一个存在的目录,返回True,否则返回False
   print(os.path.join(path1, path2...))
   # 将多个路径组合后返回,最后一个绝对路径之前的参数将被忽略
   print(os.path.getatime(path)) # 返回path所指向的文件或者目录的最后访问时间
   print(os.path.getmtime(path)) # 返回path所指向的文件或者目录的最后修改时间
   print(os.path.getsize(path)) # 返回path的大小
   

四, hashlib模块

1. 用于做加密和校验: 通过一个函数,把任意长度的数据按照一定规则转换为一个固定长度的数据串(通常用16进制的字符串表示)

2. hashlib的特征以及使用要点: 必须是bytes类型

   1. bytes类型数据-->通过hashlib算法-->固定长度的字符串
   2. 不同的bytes类型数据转化成的结果一定不同
   3. 相同的bytes类型数据转化成的结果一定相同
   4. 此转化过程不可逆
   5. 主要用于: 密码的加密, 文件的一致性校验

3. 普通加密: MD5

   import hashlib
   md5 = hashlib.md5()   # 获取md5加密器
   md5.update('123456'.encode('utf-8')) # 给md5加密器传值,必须是bytes类型
   s = md5.hexdigest()  # 获取md5加密的结果
   print(s) # 'e10adc3949ba59abbe56e057f20f883e'
   

   # 加盐加密
   # 固定的盐
   md5 = hashlib.md5('python'.encode('utf-8')) # 'python'就是固定的盐
   md5.update('123456'.encode('utf-8'))
   s = md5.hexdigest()
   print(s) # 67ca2d7d3245294467ef0f0570c789a5
   ------------------------------------------------------
   # 加动态的盐
   username = input('请输入用户名:')
   md5 = hashlib.md5(username[::2].encode('utf-8')) # 针对不同用户名,盐都不一样
   md5.update('123456'.encode('utf-8'))
   s = md5.hexdigest()
   print(s)
   

   # 更高级的加密方式,数字越大加密方法越复杂,安全性越高,但是效率就会越慢
   # sha系列算法
   ret = hashlib.sha1()
   ret.update('123456'.encode('utf-8'))
   print(ret.hexdigest())
   
   #也可加盐
   ret = hashlib.sha384(b'python')
   ret.update('123456'.encode('utf-8'))
   print(ret.hexdigest())
   
   # 也可以加动态的盐
   ret = hashlib.sha384(b'python'[::2])
   ret.update('123456'.encode('utf-8'))
   print(ret.hexdigest())
   

4. 文件的一致性校验 : 将文件校验写在一个函数中

   # 第一版:比较low
   def func(file):
       with open(file, mode='rb') as f:
           md5 = hashlib.md5()
           md5.update(f.read()) # 要一次性加载文件
           return ret.hexdigest()
   ------------------------------------------------------
   # 第二版:改进版
   def func(file):
       with open(file, mode='rb') as f:
           md5 = hashlib.md5()
           while 1:
               read = f.read(1024)  
               if read: # 判断读取的是否有内容,判断是否读取完毕
                   md5.upade(read)
               else:
                   return md5.hexdigest()    
   

五, time模块

1. 在python中,通常有三种方式来表示时间:

   • 时间戳(times tamp): 通常来说,时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量.我们运行“type(time.time())”,返回的是float类型

     import time
     t = time.time()
     print(t)
     

   • 格式化的时间字符串(format time):

     import time
     t1 = time.strftime('%Y-%m-%d %H:%M:%S') # 必须是ascii码支持的
     print(t1)  # 2019-06-28 19:04:00
     ------------------------------------------------
     t2 = time.strftime('%Y{}%m{}%d{} %H:%M:%S')
     t3 = t2.format('年', '月', '日')
     print(t3)  # 2019年06月28日 19:04:00
     

     %y 两位数的年份表示（00-99）
     %Y 四位数的年份表示（000-9999）
     %m 月份（01-12）
     %d 月内中的一天（0-31）
     %H 24小时制小时数（0-23）
     %I 12小时制小时数（01-12）
     %M 分钟数（00=59）
     %S 秒（00-59）
     %a 本地简化星期名称
     %A 本地完整星期名称
     %b 本地简化的月份名称
     %B 本地完整的月份名称
     %c 本地相应的日期表示和时间表示
     %j 年内的一天（001-366）
     %p 本地A.M.或P.M.的等价符
     %U 一年中的星期数（00-53）星期天为星期的开始
     %w 星期（0-6），星期天为星期的开始
     %W 一年中的星期数（00-53）星期一为星期的开始
     %x 本地相应的日期表示
     %X 本地相应的时间表示
     %Z 当前时区的名称
     %% %号本身
     

   • 结构化时间,元组(struct time):

     t = time.localtime()
     print(t)
     # time.struct_time(tm_year=2019, tm_mon=6, tm_mday=28, tm_hour=19, tm_min=12, tm_sec=59, tm_wday=4, tm_yday=179, tm_isdst=0)
     

   • 小结: 时间戳是计算机能够识别的时间;格式化时间字符串是人能够看懂的时间;结构化元组时间则是用来操作时间的

2. 几种格式之间的转换

   import time
   # 格式化时间--->结构化时间
   ft = time.strftime('%Y-%m-%d %H:%M:%S')
   st = time.strptime(ft, '%Y-%m-%d %H:%M:%S') # 此处格式必须与上方相同
   print(st)
   # 结构化时间--->时间戳
   t = time.mktime(st)
   print(t)
   # 时间戳--->结构化时间
   t = time.time()
   st = time.localtime(t)
   print(st)
   # 结构化时间--->格式化时间
   ft = time.strftime('%Y-%m-%d %H:%M:%S', st)
   print(ft)
   

   #结构化时间 --> %a %b %d %H:%M:%S %Y串
   #time.asctime(结构化时间) 如果不传参数，直接返回当前时间的格式化串
   >>>time.asctime(time.localtime(1500000000))
   'Fri Jul 14 10:40:00 2017'
   >>>time.asctime()
   'Mon Jul 24 15:18:33 2017'
   
   #时间戳 --> %a %d %d %H:%M:%S %Y串
   #time.ctime(时间戳)  如果不传参数，直接返回当前时间的格式化串
   >>>time.ctime()
   'Mon Jul 24 15:19:07 2017'
   >>>time.ctime(1500000000)
   'Fri Jul 14 10:40:00 2017' 
   
   t = time.time()
   ft = time.ctime(t)
   print(ft)
   
   st = time.localtime()
   ft = time.asctime(st)
   print(ft)
   

3. 计算时间差

   t1 = '2017-09-11 08:30:00'
   t2 = '2019-05-11 08:50:00'
   st1 = time.strptime(t1, '%Y-%m-%d %H:%M:%S')
   st2 = time.strptime(t2, '%Y-%m-%d %H:%M:%S')
   tt1 = time.mktime(st1)
   tt2 = time.mktime(st2)
   time_dif = tt2 - tt1
   struct_time = time.localtime(time_dif)
   print(struct_time)
   print(f'过去了{struct_time.tm_year-1970}年{struct_time.tm_mon-1}月{struct_time.tm_mday-1}天{struct_time.tm_hour}小时{struct_time.tm_min}分钟{struct_time.tm_sec}秒')
   

六, datetime模块

import datetime
now_time = datetime.datetime.now()
# 现在的时间2019-06-28 19:47:21.339993
--------------------------------------------------
# 只能调整的字段: weeks days hours minutes seconds
print(datetime.datetime.now() + datetime.timedelta(weeks=3)) # 三周后
print(datetime.datetime.now() + datetime.timedelta(weeks=-3)) # 三周前
print(datetime.datetime.now() + datetime.timedelta(days=-3)) # 三天前
print(datetime.datetime.now() + datetime.timedelta(days=3)) # 三天后
print(datetime.datetime.now() + datetime.timedelta(hours=5)) # 5小时后
print(datetime.datetime.now() + datetime.timedelta(hours=-5)) # 5小时前
print(datetime.datetime.now() + datetime.timedelta(minutes=-15)) # 15分钟前
print(datetime.datetime.now() + datetime.timedelta(minutes=15)) # 15分钟后
print(datetime.datetime.now() + datetime.timedelta(seconds=-70)) # 70秒前
print(datetime.datetime.now() + datetime.timedelta(seconds=70)) # 70秒后
--------------------------------------------------
# 可直接调整到指定的 年 月 日 时 分 秒 等
now_time = datetime.datetime.now()
print(now_time.replace(year=1977))  # 直接调整到1977年
print(now_time.replace(month=1))  # 直接调整到1月份
print(now_time.replace(year=1989,month=4,day=25))  # 1989-04-25 18:49:05.898601
--------------------------------------------------
# 将时间戳转化成时间
print(datetime.date.fromtimestamp(1232132131))  # 2009-01-17