Python基础学习笔记（16）主要模块

Python基础学习（16）主要模块

一、今日内容大纲

• time 模块
• datetime 模块
• os 模块
• sys 模块
• json 模块
• pickle 模块
• hashlib 模块
• collection 模块

二、变量类别

可在Pycharm自动补全功能中经常看到：

• C：Class 类
• m：Method 方法
• F：Function 函数
• f：Field 域
• V：Variable 变量
• p：property 属性
• p：parameter 参数

三、time 模块

封装了获取时间戳和字符串形式地时间的一些方法。

1. 三大对象

   • 时间戳 timestamp
   • 格式化时间对象 format time object
   • 时间字符串 time string

2. 获取时间戳

   时间戳：从时间元年（1970-01-01 00:00:00）到现在经过的秒数（某些语言是毫秒数）。

   print(time.time())  # 1594723794.3379405
   

3. 获取格式化事件对象

   格式化时间对象是一个名为 struct_time 的元组，元组中共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时标记）。

   print(time.gmtime())  # GMT（格林威治） 时间
   print(time.localtime())  # 当地时间
   # time.struct_time(tm_year=2020, tm_mon=7, tm_mday=14, tm_hour=10, tm_min=57, tm_sec=26, tm_wday=1, tm_yday=196, tm_isdst=0)
   print(time.localtime(1))  # 是时间元年过一秒，对应的时间对象
   

4. 时间字符串

   时间字符串需要通过格式化时间对象转化，转化为字符串易于阅读，而格式化事件对象易于传输。

   # 将格式化时间对象转换成字符串 string-format-time
   s = time.strftime('%Y.%m.%d %H:%M:%S', time.gmtime())  # 将格林威治时间对象转换为字符串
   s = time.strftime('%Y.%m.%d %H:%M:%S')  # 默认转换当地的事件对象
   
   
   # 将时间对象转换为时间字符串 string-parse-time
   time_obj = time.strptime('2010.10.10', '%Y.%m.%d')  # 将字符串转换为时间对象
   

5. 格式化事件对象转化为时间戳（了解）

   print(time.mktime(time.gmtime()))  # 1594697675.0
   

6. 睡眠功能

   可以通过time.sleep()实现当前运行程序的睡眠，主要用于开发过程。

四、datetime 模块

日期时间模块，封装了一些和日期时期相关的类，主要用于对时间进行数学运算，里面主要包含 date 类、time 类、datetime 类、timedelta 类等。

1. date 类

   主要包含year,month,day三个属性（property）。

   d = datetime.date(2010, 10, 10)
   print(d)  # 2010-10-10
   # 获取date类的各个属性(property)
   print(d.year)
   print(d.month)
   print(d.day)
   

2. time 类

   主要包含hour,minute,second三个属性。

   t = datetime.time(10, 48, 59)
   print(t)  # 10:48:59
   # 获取time类的各个属性(property)
   print(t.hour)
   print(t.minute)
   print(t.second)
   

3. datetime 类

   相当于综合了 time 类和 date 类的功能，主要包含year,month,day,hour,minute,second六个属性。

   dt = datetime.datetime(2010, 11, 11, 11, 11, 11)
   print(dt)  # 2010-11-11 11:11:11
   

4. timedelta 类

   是一种储存时间变化量的类，具有days,seconds,microseconds,milliseconds,minutes,hours,weeks属性等。

   # timedeleta类
   td = datetime.timedelta(days=300)
   print(td)  # 1 day, 0:00:00
   
   # 创建时间运算:date,datetime,timedelta(和time类不能计算)
   # 时间变化量的运算会跨位运算
   d = datetime.date(2010, 10, 10)
   res = d + td
   print(res)  # 2011-08-06
   

   # 练习:计算2100某一年的二月份有多少天
   # 普通算法:根据年份计算是否是闰年
   # 用datetime模块
   import datetime
   d = datetime.date(2100, 3, 1)
   res = d - datetime.timedelta(days=1)
   print(res.day)  # 28
   

五、os 模块

和底层操作系统相关的操作被封装在这个模块中。

1. 和文件操作相关

   • 删除文件：

     ​ os.remove(path)：删除路径下的文件

   • 重命名文件

     ​ os.rename(path_1, path_2)：将路径一的文件修改为路径二的文件

   • 删除目录（必须是空目录）

     ​ os.removedirs(path)：删除路径所指的目录

   • 扩展：利用 shutil（shell utility）模块删除带文件的目录

     ​ shutil.rmtree(path)：彻底删除，慎用

2. 和路径相关的操作

   和路径相关的操作，都被封装在了 os 模块的子模块 os.path 中。

   • 目录路径:

     ​ os.path.dirname(path):它不判断路径是否真是存在，直接返回目录路径。

     res = os.path.dirname(r'd:\dsa\dsad\asdas.aaa')
     print(res)  # d:\dsa\dsad
     

   • 文件名:

     ​ os.path.basename(path):它不判断路径是否真实存在，返回文件名。

     res = os.path.basename(r'd:\dsa\dsad\asdas.aaa')
     print(res)  # asdas.aaa
     

   • 分割目录路径与文件名:

     ​ os.path.split(path):它不判断路径是否真实存在，将目录路径和文件名分开作为元组返回。

     res = os.path.split(r'd:\dsa\dsad\asdas.aaa')
     print(res)  # ('d:\\dsa\\dsad', 'asdas.aaa')
     

   • 拼接路径:

     ​ os.path.join(path, paths):它不判断路径是否真实存在，拼接路径，返回拼接后的路径。

     path = os.path.join('d:\\', 'aaa', 'bbb.as')
     print(path)  # d:\aaa\bbb.as
     

   • 绝对路径:

     ​ os.path.abspath(path):它不判断路径是否真实存在，如果是\开头的路径，返回的绝对路径是在当前盘符下，如果不是\开头，返回的绝对路径是当前项目路径。

     path = os.path.abspath(r'\a\b\c')
     print(path)  # D:\a\b\c
     path = os.path.abspath(r'a\b\c')
     print(path)  # D:\Python\Python Project\day16\a\b\c
     

   • 判断绝对路径:

     ​ os.path.isabs(path):它不判断路径是否真实存在，返回布尔值判断传入路径是否是绝对路径。

     print(os.path.isabs('a.txt'))  # False
     print(os.path.isabs(r'c:\a.txt'))  # True
     

   • 判断目录:

     ​ os.path.isdir(path):会判断目录是否真实存在，如果不是目录或者不存在会返回False。

     print(os.path.isdir(r'c:\Python'))  # True
     

   • 判断存在:

     ​ os.path.exists(path):会判断目录或者文件是否真实存在，返回布尔值。

     print(os.path.exists(r'c:\Python'))  # True
     

   • 判断文件:

     ​ os.path.isfile(path):会判断文件是否真实存在，如果不是文件或文件不存在返回False。

     print(os.path.isfile(r'c:\Python'))  # False
     

   • 判断快捷方式:

     ​ os.path.islink(path):会判断快捷方式是否真实存在，如果不存在或者不是快捷方式返回False。

六、sys 模块

封装和 Python 解释器相关的操作。

1. 命令行参数 sys,agrv

   全称为 argument variable 获取命令行参数，以列表形式返回，列表第一个元素为文件路径。

   print(sys.argv)
   # ['D:/Python/Python Project/day16/04 sys模块.py']
   

2. 模块查找路径sys.path

   以列表形式返回模块查找路径，可以在程序中动态地临时修改。

3. 已加载模块sys.modules

   返回系统已经加载的模块，以字典形式返回，不可以动态地修改（可能会引起程序错误）。

七、json 模块

是 JavaScript Object Notation 的简称，是一种简单的数据交换格式，用于结构化数据和线性数据的转化，而 json 只能将数据和字符串之间进行转化，用于存储或者网络传输（不太彻底，没有彻底转换为二进制字节形式）。

1. 序列化过程和反序列化过程

   • 序列化过程 serialization ：将结构化数据转化为线性数据，将内存中的数据转换成字节形式用以保存在文件或网络传输。
   • 反序列化过程 deserialization ：将线性数据转化为结构化数据，将网络中获取的数据，转换成内存中原来的数据类型。

2. json.dump()和json.dumps()

   # json.dump()
   s = json.dumps([1,2,3])  # 把指定的对象转换成json格式的字符串
   print(s)  # '[1, 2, 3]'
   s = json.dumps((1, 2, 3))  # 元组序列化后,会变成列表
   print(s)  # '[1, 2, 3]'
   res = json.dumps(10)
   print(res)  # '10'
   res = json.dumps({'name':'andy', 'age': 10})
   print(res)  # '{"name": "andy", "age": 10}'
   # res = json.dumps(set('abs'))  # TypeError: Object of type 'set' is not JSON serializable
   
   
   # 将json结果写入到文件中,通过json.dump()
   with open(r'json.txt',encoding='utf-8',mode='a') as file_handler:
       json.dump([1, 2, '12'], file_handler)
   

3. json.load()和json.loads()

   # 反序列化
   res = json.dumps([1, 2, 3])
   lst = json.loads(res)
   print(type(lst))  # <class 'list'>
   print(lst)  # [1, 2, 3]
   # 元组反序列化变为列表
   res = json.dumps((1,2,3))
   lst = json.loads(res)
   print(type(lst))  # <class 'list'>
   print(lst)  # [1, 2, 3]
   
   
   
   # 从文件中反序列化
   with open(r'json.txt', encoding='utf-8') as file_handler:
       res = json.load(file_handler)  # json文件通常是一次性写一次性读,所以json.load()只能一次性读文件
       print(type(res))  # <class 'list'>
       print(res)  # [1, 2, '12']
   

   # 另一种方式,可以实现多次写多次读:把需要序列化的对象,通过多次序列化的方式,
   # 用文件的write方法,把多次序列化后的json字符串写到文件中
   with open('json.txt', mode='a', encoding='utf-8') as file_handler:
       file_handler.write(json.dumps([1, 2, 3]) + '\n')
       file_handler.write(json.dumps([4, 5, 6]) + '\n')
   # 反序列化同理
   

八、pickle 模块

用以序列化过程和反序列化过程，将 Python 中所有的数据转换成字节形式；基本使用方法与 json 模块相同。

import pickle
bys = pickle.dumps((1,2,3))
print(type(bys))  # <class 'bytes'>
print(bys)  # b'\x80\x03K\x01K\x02K\x03\x87q\x00.'

res = pickle.loads(bys)
print(res)  # (1, 2, 3)
print(type(res))  # <class 'tuple'>
# 可以序列化\反序列化任何数据类型
bys = pickle.dumps(set('abc'))
res = pickle.loads(bys)
print(res)  # {'b', 'c', 'a'}
print(type(res))  # <class 'set'>


# pickle.dump和load序列化和反序列化可以多次读取,与json不同
# 把pickle序列化内容写入文件(二进制不涉及到encoding所以不设置encoding参实)
with open('pickle.txt', mode='wb') as file_handler:
    pickle.dump([1, 2, 3], file_handler)
    pickle.dump([3, 4, 5], file_handler)

# 反序列化
with open('pickle.txt', mode='rb') as file_handler:
    ret1 = pickle.load(file_handler)
    ret2 = pickle.load(file_handler)
    print(ret1, type(ret1))  # [1, 2, 3] <class 'list'>
    print(ret2, type(ret2))  # [3, 4, 5] <class 'list'>
# 在使用过程中要一次写一次读,多次会乱

json 模块和 pickle 模块的对比：

json 模块	pickle 模块
1.不是所有的数据类型都可以序列化	1.所有的pyhton类型都可以序列化
2.不能多次对同一个文件序列化	2.可以多次对同一个文件序列化
3.json数据可以跨语言读取	3.不能跨语言使用

九、hashlib 模块

用以封装一些加密的类。

1. 加密

   • 加密的目的：用于判断和验证，而并非解密
   • 加密的特点：
     • 把一个大的数据，切分成不同块进行加密，再汇总的结果，和直接对整体数据加密的结果是一致的。
     • 单向加密不可逆。
     • 原始数据一丁点小的变化，会导致结果有非常大的差异，即"雪崩"效应。

2. md5 加密算法

   # 获取一个加密对象
   m = hashlib.md5()
   # 使用加密对象的update,进行加密
   m.update(b'abc')
   res1 = m.hexdigest()
   m.update('中文'.encode('utf-8'))  # 只能接受二进制类型，中文转化成二进制
   res2 = m.hexdigest()
   print(res1, res2)  # 900150983cd24fb0d6963f7d28e17f72 1af98e0571f7a24468a85f91b908d335
   

3. 数据加密的三大步骤

   • 获取一个加密对象
   • 使用加密对象的 update 算法（可以调用多次叠加加密）
   • 通过 hexdigest() 方法或者 digest() 获取加密结果

4. 不同加密方法的区别

   # 不同的加密算法：实际上就是加密结果的长度不同
   s = hashlib.sha224()
   s.update(b'abc')
   print(s.hexdigest())  # 23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7
   
   print(hashlib.md5().hexdigest())  # d41d8cd98f00b204e9800998ecf8427e
   print(hashlib.sha1().hexdigest())  # da39a3ee5e6b4b0d3255bfef95601890afd80709
   print(hashlib.sha256().hexdigest())  # e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
   

5. 加密对象的 salt

   在创建加密对象时，可以指定参数，称为 salt 。

   hashlib.md5(b'abc')  # 相当于update了,与update结果是相同的
   

十、collection 模块

定义了一些容器类，包括collection.namedtuple()、collection.defaultdict()、collection.Counter()等。

1. namedtuple()命名元组

   # namedtuple():命名元组
   from collections import namedtuple
   # 定义一个Rectangle类(自己定义的类名习惯上首字母大写)
   Rectangle = namedtuple('this_s_a_rectangle_class', ['length', 'width'])
   # Rectangle类的使用
   r = Rectangle(10, 5)
   # 通过属性访问元组的元素
   print(r.length)  # 10
   print(r.width)  # 5
   # 通过索引的方式访问元素
   print(r[0])  # 10
   print(r[1])  # 5
   

2. defaultdict()默认值字典

   from collections import defaultdict
   dic = defaultdict(lambda :10,name='andy',age=10)
   print(dic['name'])  # andy
   # 索引没有定义的值时，会按照工厂函数默认添加一个键值对，工厂函数不能有参数传入
   print(dic['ad'])  # 10
   print(dic)  # defaultdict(<function <lambda> at 0x000001DFCFEDBD90>, {'name': 'andy', 'age': 10, 'ad': 10})
   

3. Counter()计数器

   from collections import Counter
   c = Counter('saddasadsad312544444sas')
   print(c)  # Counter({'s': 5, 'a': 5, '4': 5, 'd': 4, '3': 1, '1': 1, '2': 1, '5': 1})
   print(c.most_common(2))  # [('s', 5), ('a', 5)]