欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

常用模块介绍

程序员文章站 2022-04-08 23:09:37
常用模块的介绍: ​ time,datetime ​ os,sys ​ hashlib,json,pickle,collections time模块: time 模块(和时间相关):封装了获取时间戳和字符串形式的时间的一些方法。 三大对象:时间戳, 结构化时间对象(9大字段), 字符串【重点】 ti ......

常用模块的介绍:

​ time,datetime
​ os,sys
​ hashlib,json,pickle,collections

time模块:

  • time 模块(和时间相关):封装了获取时间戳和字符串形式的时间的一些方法。

  • 三大对象:时间戳, 结构化时间对象(9大字段), 字符串【重点】

    • time.time():获取时间戳

    • time.gmtime([seconds]):获取格式化时间对象:是九个字段组成的

    • time.localtime([seconds]):获取格式化时间对象:是九个字段组成的

    • time.mktime(t):时间对象 -> 时间戳

    • time.strftime(format[,t]):把时间对象格式化成字符串

    • time.strptime(str,format):把时间字符串转换成时间对象

      import time
      # 获取时间戳
      # 时间戳:从时间元年(1970 1 1 00:00:00)到现在经过的秒数。
          print(time.time())#1558317680.919616
      
      # 获取格式化时间对象:是九个字段组成的。
           # 默认参数是当前系统时间的时间戳。
           print(time.gmtime())# gmt  time.struct_time(tm_year=2019, tm_mon=5, tm_mday=20, tm_hour=2, tm_min=1, tm_sec=20, tm_wday=0, tm_yday=140, tm_isdst=0)
      
           # 获取时间元年过一秒后,对应的时间对象
           print(time.gmtime(1))#time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=1, tm_wday=3, tm_yday=1, tm_isdst=0)
      
           print(time.localtime())#time.struct_time(tm_year=2019, tm_mon=5, tm_mday=20, tm_hour=10, tm_min=1, tm_sec=20, tm_wday=0, tm_yday=140, tm_isdst=0)
      
      # 时间对象 ---> 时间戳
           t1 = time.localtime()  #时间对象
           t2 = time.mktime(t1)   #获取对应的时间戳
           print(t2)#1558318103.0
           print(time.time())#1558318103.9826832
      
      
      # 格式化时间对象转换成字符串
           s = time.strftime("%y %m %d %h:%m:%s")
           print(s,type(s))#2019 05 20 10:05:17 <class 'str'>
      
      # 把时间字符串转换成时间对象
           time_obj = time.strptime('2019 05 20','%y %m %d')
           print(time_obj)#time.struct_time(tm_year=2019, tm_mon=5, tm_mday=20, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=140, tm_isdst=-1)
      
           time_obj = time.strptime('2019 05 20 12 30 55','%y %m %d %h %m %s')
           print(time_obj)#time.struct_time(tm_year=2019, tm_mon=5, tm_mday=20, tm_hour=12, tm_min=30, tm_sec=55, tm_wday=0, tm_yday=140, tm_isdst=-1)
      
      #暂停当前程序,睡眠xxx秒  time.sleep(xxx)
           for i in range(5):
               print(time.strftime('%y %m %d %h:%m:%s'))
               time.sleep(1)

datetime模块:

  • datetime模块:日期时间模块,封装了一些和日期、时间相关的类。

    • date:需要年,月,日三个参数

    • time:需要时,分,秒三个参数

    • datetime:需要年,月,日,时,分,秒六个参数.

    • timedelta:需要一个时间段.可以是天,秒,微秒.

      • timedelta可以和以下三个类进行数学运算: datetime.time, datetime.datetime, datetime.timedelta
    • 获取以上类型的对象,主要作用是和时间段进行数学运算.

      import datetime
      
      #date类
           d = datetime.date(2019,5,20)
          #获取date对象的各个属性
           print(d)#2019-05-20
           print(d.year)#2019
           print(d.month)#5
           print(d.day)#20
      
      #time类:
           t = datetime.time(10,11,55)
           print(t)#10:11:55
          #获取time的各个属性
           print(t.hour)#10
           print(t.minute)#11
           print(t.second)#55
      
      #datetime类:
           dt = datetime.datetime(2019,5,20,10,11,46)
           print(dt)#2019-05-20 10:11:46
      
      #timedelta类:时间的变化量
           td = datetime.timedelta(days=1)
           print(td,type(td))#1 day, 0:00:00 <class 'datetime.timedelta'>
      
      ##参与数学运算:
      # 创建时间对象,只能和以下三类进行数学运算: date,datetime,timedelta
           测试:(date,datetime,timedelta分别于timedelta运算,datetime与date不能运算)
           td = datetime.timedelta(days=1)
           d = datetime.date(2010,10,10)
           res = d - td
           print(res)#2010-10-09
      
      
      #timedelta和时间段进行运算的结果类型: 和另一个操作数保持一致
           td2 = datetime.date(2010,10,10)
           td = datetime.timedelta(days=1)
           res = d + td
           print(res,type(res))#2010-10-11 <class 'datetime.date'>
      
           d = datetime.datetime(2010,10,10,10,10,10)
           td = datetime.timedelta(days=1)
           res = d + td
           print(res,type(res))#2010-10-11 10:10:10 <class 'datetime.datetime'>
      
           d = datetime.timedelta(seconds=20)
           td = datetime.timedelta(days=1)
           res = d + td
           print(type(res),res)#<class 'datetime.timedelta'> 1 day, 0:00:20
      
      
      # 时间变化量的计算会产生进位。
           t = datetime.datetime(2010,12,31,23,59,58)
           td = datetime.timedelta(seconds=3)
           res = t + td
           print(res)#2011-01-01 00:00:01
      
           t = datetime.datetime(2010,10,10,10,10,00)
           td = datetime.timedelta(seconds=3)
           res = t - td
           print(res)#2010-10-10 10:09:57
      
      # 练习:计算某一年的二月份有多少天.
      # 普通算法:根据年份计算是否是闰年.是:29天,否:28
      
      # 用datetime模块.首先创建出指定年份的3月1号.然后让它往前走一天.
           year = int(input("请输入年份:"))
           d = datetime.date(year,3,1) # 创建指定年份的date对象
           td = datetime.timedelta(days=1) # 创建一天 的时间段
           res = d - td
           print(res.day)#根据输入的年份,显示 28 或 29
      

os模块:

  • os模块:和操作系统相关的操作被封装到这个模块中,主要是文件删除,目录删除,重命名等操作。

    import os
    #和文件操作相关:重命名,删除
    
    #重命名:
       os.rename('a.txt','b.txt')
    
    #删除:
       os.remove('b.txt')
    
    #删除目录,必须是空目录
       os.rmdir('aa')
    
    #递归删除空文件夹
       os.removedirs('aa')
    
    #使用shutil模块可以删除带内容的目录(慎用)
         import shutil
         shutil.rmtree('aa')
    
    #和路径相关的操作,被封装到另一个子模块中:os.path
    
        #返回一个路径中的父目录部分(不会判断路径是否存在)
             res = os.path.dirname(r'd:/aaa/bbb/ccc/a.txt')  #路径不存在,不会报错
             print(res)#d:/aaa/bbb/ccc
    
        #返回path指定的路径的最后一个内容.如果只是一个盘符,或者是以路径分隔符结尾的字符串,则返回空;否则返回的是路径中的最后一部分内容.
             res = os.path.basename(r'd:/aaa/bbb/ccc.txt')  #路径不存在,不会报错
             print(res)#ccc.txt
             res = os.path.basename(r'd:/aaa/bbb/ccc')
             print(res)#ccc
    
        #返回一个元组,第二个元素表示的是最后一部分的内容,第一个元素表示的是剩余的内容.
          如果只是一个盘符或者是以路径分隔符结尾的字符串,则第二个元素为空。否则第二个元素就是最后一部分的内容。如果path中不包含路径分隔符,则第一个元素为空.
             res = os.path.split(r'd:/aa/bb/cc/a.txt')  #路径不存在,不会报错
             print(res)#('d:/aa/bb/cc', 'a.txt')
    
        #拼接路径
             path = os.path.join('aaa','bbb','ccc','a.txt')
             print(path)#aaa\bbb\ccc\a.txt
             path = os.path.join('d:\\''aaa','bbb','ccc','a.txt')
             print(path)#d:\aaa\bbb\ccc\a.txt
    
    
        #返回一个路径的绝对路
             如果参数路径是相对的路径,就把当前路径和参数路径的组合字符串当成结果返回.
             如果参数路径已经是绝对路径,就直接把参数返回.
             如果参数路径以/开始,则把当前盘符和参数路径连接起来组成字符串返回.
    
        注意: 此方法只是简单的将一个拼接好的字符串返回,并不会去检查这个字符串表示的文件是否存在.
    
         #如果是/开头的路径,默认是在当前盘符下
             res = os.path.abspath(r'/a/b/c')
             print(res)#d:\a\b\c
         #如果不是以/开头,默认当前路径
             res = os.path.abspath(r'a/b/c')
             print(res)#d:\python22\day16\a\b\c
    
             res = os.path.abspath('aa')
             print(res)#d:\python22\day16\aa
    
    
         #判断功能:
         #判断是否是绝对路径
             print(os.path.isabs('d:/a.txt'))#true  路径不存在,不会报错
             print(os.path.isabs('a.txt'))#false
    
         #判断是否是目录
             print(os.path.isdir('d:/aaa.txt'))#false  aaa.txt文件夹不存在  或者 aaa.txt是文件
             print(os.path.isdir('d:/aaa.txt'))#true  aaa.txt文件夹存在的情况
    
         #判断路径是否真正存在.
             print(os.path.exists('d:/a.txt'))#false    a.txt不存在
             print(os.path.exists('d:/s22/aaa.txt'))#true  aaa.txt存在的情况
             print(os.path.exists('d:/s22'))#true
    
         #判断是否是文件
             print(os.path.isfile('d:/aaaa.txt'))#false  文件不存在的情况
             print(os.path.isfile('d:/s22'))#false  是目录的情况
             print(os.path.isfile('d:/s22/aaa.txt'))#true
    

sys模块:

  • sys模块:和python解释器相关的操作

    import sys
    #获取命令行方式运行的脚本后面的参数:sys.argv[x]
         print('脚本名:',sys.argv[0])   #脚本名:d:\python22\day16\tt16.py
         print('第一个参数:',sys.argv[1])  #第一个参数: hello
         print('第二个参数:',sys.argv[2])  #第二个参数: world
         print(type(sys.argv[1]))  #<class 'str'>
         print(type(sys.argv[2]))  #<class 'str'>
    
    # 解释器执行时寻找模块的路径:sys.path
        #sys.path :系统寻找模块的路径.
        print(sys.path)
    
    #sys.modules :返回系统已经加载的模块,以字典形式返回.
      print(sys.modules)
    
    

hashlib模块:

  • hashlib模块:封装一些用于加密的类.

    • 加密的目的:用于判断和验证,而并非解密。给一个数据加密,然后用另一个数据加密的结果和第一次加密的结果对比。如果结果相同,说明原文相同.如果不相同,说明原文不同.
    • 特点:
      • 把一个大的数据,切分成不同块,分别对不同的块进行加密,再汇总的结果,和直接对整体数据加密的结果是一致的.
      • 单向加密,不可逆.
      • 原始数据的一点小的变化,将导致结果的非常大的差异,'雪崩'效应.
  • 给一个数据加密的三大步骤:

    例如:md5加密算法:

    1.获取一个加密对象
    2.使用加密对象的update,进行加密,update方法可以调用多次
    3.通常通过 hexdigest() 获取加密结果 或 digest()方法.

    import hashlib
    # 获取一个加密对象
       m = hashlib.md5()
    # 使用加密对象的update进行加密
         m.update('abc中文'.encode('utf-8'))  #?????
         m.update('def'.encode('utf-8'))
    # 通过hexdigest获取加密结果
         res = m.hexdigest()
         res1 = m.digest()   ###????
         print(res)#2f1b6e294e72d25ae196fe4ac2d27de6
         print(res1)#b'/\x1bn)nr\xd2z\xe1\x96\xfej\xc2\xd2}\xe6'
    
    
    
    # 不同加密算法(不同的加密对象),实际上就是加密结果的长度不同,长度越长,越耗时.常用的是md5
         print(len(hashlib.md5().hexdigest()))#32
         print(len(hashlib.sha224().hexdigest()))#56
         print(len(hashlib.sha256().hexdigest()))#64
    
    # 在创建加密对象时,可以指定参数,称为salt.
         m = hashlib.md5(b'abc')
         print(m.hexdigest())#900150983cd24fb0d6963f7d28e17f72
    
         m = hashlib.md5()
         m.update(b'abc')
         print(m.hexdigest())#900150983cd24fb0d6963f7d28e17f72
    
         m = hashlib.md5()
         m.update(b'abc')
         m.update(b'def')
         print(m.hexdigest())#e80b5017098950fc58aad83c8c14978e
    
    
    #注册登录:
         def get_md5(username,password):
             m = hashlib.md5(username[::-1].encode('utf-8'))#加盐,将用户名反转,再转化为二进制字节
             # m.update(username.encode('utf-8'))
             m.update(password.encode('utf-8'))
             ret = m.hexdigest()
             return ret
    
         def regist(username,password):
             res = get_md5(username,password)#加密
             with open('login',encoding='utf-8',mode='r') as f:
    
    
    
    
                    ???????
    
    
    
    
    


序列化:把内存中的数据,转换成字节或字符串的形式,以便于进行存储或者网络传输.??????
内存中数据 -----> 字节串/字符串 : 序列化
字节串/字符串 ----> 内存中的数据 : 反序列化

json模块:

  • json模块:

    • javascript object notation:java脚本对象标记语言.已经成为一种简单的数据交换格式.
    • 序列化:将其他数据格式转换成json字符串的过程.
    • 反序列化:将json字符串转换其他数据类型的过程.
    • 涉及到的方法:
      • json.dumps(obj):将obj转换成json字符串返回到内存中.
      • json.dump(obj,fp):将obj转换成json字符串并保存在fp指向的文件中.
      • json.loads(s):将内存中的json字符串转换成对应的数据类型对象
      • json.load(f):从文件中读取json字符串,并转换回原来的数据类型.
  • 注意:

    • json并不能序列化所有的数据类型:例如:set集合 。

    • 元组数据类型经过json序列化后,变成列表数据类型。

    • json文件通常是一次性写入,一次性读取,但是可以利用文件本身的方式实现:一行存储一个序列化json字符串,在反序列化时,按行反序列化即可。

      import json
      ##序列化:
      
       # json.dumps:将数据转换成字符串,用于存储或网络传输。
      
           s = json.dumps([1,2,3]) # 把指定的对象转换成json格式的字符串
           print(type(s))#<class 'str'>
           print(s)#[1, 2, 3]
      
           s = json.dumps((1,2,3))#  元组序列化后,变成列表
           print(s)#[1, 2, 3]
      
           res = json.dumps(10)
           print(res,type(res))#10 <class 'str'>
      
           res = json.dumps({'name':'alex','age':88})
           print(res,type(res))#{"name": "alex", "age": 88} <class 'str'>
      
           res = json.dumps(set('abc'))
           print(res)#typeerror: object of type 'set' is not json serializable
      
      
       # json.dump
          #将json结果写到文件中
           with open('a.txt',encoding='utf-8',mode='a') as f:
               json.dump([1,2,3],f)
      
      
      #反序列化:
          #json.loads
               res = json.dumps([1,2,3])
               lst = json.loads(res)   ## 反序列化
               print(lst,type(lst))#[1, 2, 3] <class 'list'>
      
              # 元组会变成列表
               res = json.dumps((1,2,3))
               lst = json.loads(res)           # 反序列化
               print(lst,type(lst))#[1, 2, 3] <class 'list'>
      
          #json.load
          #从文件中反序列化:
               with open('a.txt',encoding='utf-8') as f:
                   res = json.load(f)
               print(res,type(res))#[1, 2, 3] <class 'list'>
      
      
      
      # json文件通常是一次性写,一次性读.使用另一种方式,可以实现多次写,多次读.
          # 把需要序列化的对象.通过多次序列化的方式, 用文件的write方法,把多次序列化后的json字符串写到文件中
               with open('json.txt',encoding='utf-8',mode='a') as f:
                   f.write(json.dumps([1,2,3]) + '\n')   #此时只能用dumps,不能用dump
                   f.write(json.dumps([4,5,6]) + '\n')
      
          #  把分次序列化的json字符串,反序列化回来
               with open('json.txt',encoding='utf-8',mode='r') as f:
                   res1 = json.loads(f.readline().strip())
                   print(res1)
                   res2 = json.loads(f.readline().strip())
                   print(res2)
                   # [1, 2, 3]
                   # [4, 5, 6]
      
          #使用循环改进:
               with open('json.txt',encoding='utf-8',mode='r') as f:
                   for line in f:
                       res = json.loads(line.strip())  #此时只能用loads,不能用load
                       print(res)
              #  [1, 2, 3]
              #  [4, 5, 6]
      
      

pickle模块:

  • 序列化过程:将python中所有的数据类型.转换成字节串。

  • 反序列化过程:将字节串转换成python中数据类型。

  • pickle常用场景:和json一样,一次性写入,一次性读取。

  • pickle: python专用的序列化模块,和json的方法一致。

  • json,pickle的比较:

    • json:

      • 1.不是所有的数据类型都可以序列化.结果是字符串.
      • 2.不能多次对同一个文件序列化.
      • 3.json数据可以跨语言
    • pickle:

      • 1.所有python类型都能序列化,结果是字节串.
      • 2.可以多次对同一个文件序列化
      • 3.不能跨语言.
      import pickle
      
      #python所有的数据类型都可以进行序列化
      
      # 列表序列化
           bys = pickle.dumps([1,2,3])
           print(bys,type(bys))#b'\x80\x03]q\x00(k\x01k\x02k\x03e.' <class 'bytes'>
      
      # 保存了元组的数据类型
           bys = pickle.dumps((1,2,3))#序列化
           print(bys,type(bys))#b'\x80\x03k\x01k\x02k\x03\x87q\x00.' <class 'bytes'>
           res = pickle.loads(bys)  #反序列化
           print(res,type(res))#(1, 2, 3) <class 'tuple'>
      
      # 集合序列化,反序列化
           bys = pickle.dumps(set('abc'))
           print(bys,type(bys))#b'\x80\x03cbuiltins\nset\nq\x00]q\x01(x\x01\x00\x00\x00cq\x02x\x01\x00\x00\x00bq\x03x\x01\x00\x00\x00aq\x04e\x85q\x05rq\x06.' <class 'bytes'>
           res = pickle.loads(bys)
           print(res,type(res))#{'c', 'b', 'a'} <class 'set'>
      
      
      # 把pickle序列化内容写入到文件:
           with open('cc.txt',mode='wb') as f:  #转化成字节
               pickle.dump([1,2,3],f)
      
      # 从文件中反序列化pickle数据
           with open('cc.txt',mode='rb') as f:   #字节
               res = pickle.load(f)
               print(res,type(res))#[1, 2, 3] <class 'list'>
      
      
      # 多次pickle数据到同一个文件中
           with open('cc.txt',mode='ab') as f:
               pickle.dump([1, 2, 3], f)
               pickle.dump([1, 2, 3], f)
               pickle.dump([1, 2, 3], f)
               pickle.dump([1, 2, 3], f)
      
      # 从文件中多次反序列化pickle数据:
           with open('cc.txt',mode='rb') as f:
               for i in range(4):
                   res = pickle.load(f)
                   print(res)
          # [1, 2, 3]
          # [1, 2, 3]
          # [1, 2, 3]
          # [1, 2, 3]
      
      

collections模块:

  • collections模块:

    • namedtuple():命名元组

    • defaultdict():默认值字典.

    • counter():计数器 #首字母必须大写

      import collections
      
      # namedtuple()
           rectangle = collections.namedtuple('rectangle_class',['length','width'])
           r = rectangle(10,6)
      
          # 通过属性访问元组的元素
            print(r.length)#10
            print(r.width)#6
      
          # 通过索引的方式访问元素
            print(r[0])#10
            print(r[1])#6
      
      #defaultdict:
       # 创建字典的方式:
           d = {'name':'alex','age':84}
           print(d)#{'name': 'alex', 'age': 84}
           d = dict([('name','alex'),('age',84)])
           print(d)#{'name': 'alex', 'age': 84}
           d = { k:v for k,v in [('name','alex'),('age',84)]}
           print(d)#{'name': 'alex', 'age': 84}
      
      # defaultdict()
           d = collections.defaultdict(int,name='alex',age=84)
           print(d['name'])#alex
           print(d['age'])#84
           print(d['addr'])#0     # {'addr':0} 也会被添加到字典
           print(d)#defaultdict(<class 'int'>, {'name': 'alex', 'age': 84, 'addr': 0})
      
           d = collections.defaultdict(bool,name='alex',age=84)
           print(d['name'])#alex
           print(d['age'])#84
           print(d['addr'])  #false   # {'addr':false} 也会被添加
           print(d)# defaultdict(<class 'bool'>, {'name': 'alex', 'age': 84, 'addr': false})
      
      
      # 自定义函数充当其第一个参数,要求自定义函数不能有参数
           def f():
               return 'hello'
      
           d = collections.defaultdict(f,name='andy',age=20)
           print(d['addr'])#hello
           print(d)# defaultdict(<function f at 0x000002a685a41e18>, {'name': 'andy', 'age': 20, 'addr': 'hello'})
      
      
      # counter :计数器
           c = collections.counter('asdfgkoiunbbsgfawpag')
           print(c)#counter({'a': 3, 'g': 3, 's': 2, 'f': 2, 'b': 2, 'd': 1, 'k': 1, 'o': 1, 'i': 1, 'u': 1, 'n': 1, 'w': 1, 'p': 1})
           print(c.most_common(3))#[('a', 3), ('g', 3), ('s', 2)]