模块一：时间模块、random模块、hashlib模块、日志模块

模块：就是一系列功能的集合体，有以下分类：
*解释器内建模块
*python标准库(位于python解释器安装目录的lib文件夹下）
*第三方模块(通过(pip install 模块名)语法下载到python解释器安装目录lib文件夹下
*自定义模块

模块分为四种形式：
1、使用python编写的.py文件
2、已被编译为共享库或dll的c或c++扩展
3、把一系列模块组织到一起的文件夹（注：文件夹下有一个__init__.py文件，该文件夹称之为包）
4、使用c编写并链接到python解释器的内置模块

为何有模块：
1、内置模块与第三方模块拿来用即可，无需定义，这样可以极大的提升自己的开发效率
2、自定义模块：可以将程序的各部分功能提取出来放到一个模块中为大家共享使用，好处是减少了代码冗余，程序组织架构更加清晰

 

如何使用模块：
模块导入语法：
(1): import 模块名
(2): from 模块名 import 成员变量名
(3): from 模块名 import 成员变量名1,成员变量名2
(4): from 模块名 import *
(5): from 模块名 import 成员变量名 as 别名

import导入模块在使用时的优缺点（必须加前缀）：
优：肯定不会与当前名称空间中的名字冲突
缺：加前缀显得麻烦
from....import.....导入模块时不加前缀
优：代码更加精简
缺：容易与当前名称空间混淆
所以在模块名冲突时可用as取别名

 

1、导入模块时会执行模块，多次的导入只执行一次，之后的导入，都是直接引用首次导入产生的foo.py名称空间，不会重复执行代码。
import foo首次导入模块发生的事件：
*执行foo.py文件，检测语法
*产生foo.py的名称空间，将foo.py运行过程中产生的名字丢到foo的名称空间中
*在当前执行的文件中产生的有一个名字foo，该名字指向产生的模块名称空间

2、加上foo.作为前缀就相当于指名道姓地说明要引用foo名称空间中的名字，所以肯定不会与当前执行文件所在名称空间中的名字相冲突

3、在Python中模块也属于第一类对象，可以进行赋值、以数据形式传递以及作为容器类型的元素等操作

4、可以在函数内导入模块
def func()
import foo

5、一个python文件的两种用途：
1）被当作执行程序运行 run.py
2）被当作模块导入 foo.py
区分：
1）当foo.py被当作程序入口运行时，__name__的值为‘__main__’
2）当foo.py被当作模块导入时，__name__的值为‘foo’
例：if __name__==’__main__’: #是否为程序入口
run()
此知识点多用于测试模块文件中的功能

6、模块查找优先级
无论时import还是from....import....在导入模块时都涉及到查找问题
优先级：
1）内存（内置模块）
2）硬盘：按照sys.path中存放的文件顺序依次查找要导入的模块
注意：针对被导入模块与执行文件在不同路径下得情况，为了确保模块对应的源文件仍可以被找到，需要将源文件foo.py的所在路径添加到sys.path中，

导入模块或者包的本质在于对sys.path的路径搜索：
python解释器会将执行文件所在目录动态插入到sys.path（结果是个列表）索引为的位置

例：文件位置：项目名称：-bin（run.py），-lib（foo.py，log.py)
import os，sys
print(__file__) # 获取当前文件的绝对路径
#可获取项目的绝对路径
BASE_DIR=os.path.dirname(os.path.dirname(__file__))
# 将项目路径放入环境变量中
sys.path.insert(0,BASE_DIR)
run.py文件引用模块foo时：from lib.foo import *

 

Time模块

 1 Import time
 2 1、时间戳：1970-1-1到现在的秒数
 3 作用：用于时间间隔的计算
 4 timestamp=time.time()
 5 
 6 2、time.sleep(second)，second秒数
 7 
 8 3、time.ctime(timestamp)    
 9 # 结果 wed jun 9 08:48:51 2021
10 
11 4、time.asctime(传入时间元组)：*生成固定格式的时间表示格式，把一个表示时间的元组或者struct_time*表示为’Sat Jan 13 21:56:34 2018’这种形式。如果没有给参数，会将time.localtime()作为参数传入。
12 
13 5.按照某种格式显示时间：2021-06-27 12：12：12
14 作用：用于展示时间
15 print(time.strftime('%Y-%m-%d %H:%M:%S %p')) # 2021-06-27 15:12:06 PM
16 print(time.strftime('%Y-%m-%d %X')) # 2021-06-27 15:12:06
17 
18 6、结构化的时间
19 作用：用于单独获取时间的某一部分
20 print(time.gmtime())    # 世界标准时间
21 res = time.localtime()   # 本地时间
22 print(res)
23 print(res.tm_year)
24 print(res.tm_yday)
25 运行结果：
26 # time.struct_time(tm_year=2021, tm_mon=6, tm_mday=27, tm_hour=15, tm_min=16, tm_sec=15, tm_wday=6, tm_yday=178, tm_isdst=0)
27 # 2021
28 # 178
29 
30 例：打印进度条
31 import time
32 def progress(percent):
33     if percent>1:
34         percent = 1
35     res = int(50*percent) * "#"
36     print('\r[%-50s]%d%%'%(percent*100))
37 
38 sev = 0
39 total = 102050
40 while sev < total:
41     time.sleep(0.01)
42     sev += 1024
43     percent = sev/total
44     progress(percent)

datetime模块

 

 1 （一）datetime模块的date类型（年 月 日）
 2 Import datetime
 3 1、datetime.date() 构建任意日期对象
 4 print(datetime.date(1993,12,12)) # 1993-12-12  <class ‘datetime.date’>
 5 获取时间片信息
 6 d=datetime.date(1993,12,12)
 7 print(d.year)   # 1993
 8 print(d.month)  # 12
 9 print(d.day)    # 12
10 
11 2、获取当前日期
12 today=datetime.date.today()  # 2021-06-19
13 
14 3、按指定格式输出时间
15 today.strftime(“”)  # %Y:year %m:month %d:day
16 print(today.strftime(“%Y/%m/%d”))
17 
18 （二）datetime模块的datetime类型（年月日时分秒）
19 1、datetime.datetime() 获取任意日期对象
20 dt=datetime.datetime(2012,12,12)
21 print(dt)  # 2012-12-12  00:00:00
22 获取时间片信息
23 print(dt.year)     2012
24 print(dt.month)    12
25 print(dt.day)        12
26 print(dt.hour)      0
27 print(dt.minute)    0
28 
29 2、获取当前日期对象
30 today=datetime.datetime.today()
31 now=datetime.datetime.now()
32 
33 3、格式化时间
34 print(now.strftime(“%Y/%m/%d %H:%M”))
35 
36 （三）datetime模块的time类型（时分秒）
37 t=datetime.time(3,3,10)
38 print(t.hour)
39 print(t.minute)
40 print(t.second)
41 
42 （四）datetime模块的timedelta类型（时间间隔）
43 delta =datetime.timedelta(weeks=2)
44 print(now+delta)

 

时间模块重点：

 

 

 1 1、时间格式的转换
 2 struct_time -----> 时间戳
 3 
 4 import time
 5 # .mktime()函数接收struct_time对象作为参数，返回用秒数来表示时间的浮点型
 6 stime = time.localtime()
 7 print(stime)
 8 print(time.mktime(stime))
 9 运行结果：
10 # time.struct_time(tm_year=2021, tm_mon=6, tm_mday=27, tm_hour=15, tm_min=38, tm_sec=58, tm_wday=6, tm_yday=178, tm_isdst=0)
11 # 1624779538.0
12 
13 时间戳---->struct_time
14 tp_time=time.time()
15 print(tp_time)
16 print(time.localtime(tp_time))
17 运行结果：
18 # 1624779876.5282025
19 # time.struct_time(tm_year=2021, tm_mon=6, tm_mday=27, tm_hour=15, tm_min=44, tm_sec=36, tm_wday=6, tm_yday=178, tm_isdst=0)
20 
21 struct_time = time.localtime()
22 print(time.strftime('%Y-%m-%d %H:%M:%S',struct_time))
23 #  2021-06-27 15:50:22
24 print(time.strptime('1988-03-03 11:11:11','%Y-%m-%d %H:%M:%S'))
25 # time.struct_time(tm_year=1988, tm_mon=3, tm_mday=3, tm_hour=11, tm_min=11, tm_sec=11, tm_wday=3, tm_yday=63, tm_isdst=-1)
26 
27 重点：format string  <-------> timestamp
28 （1）format string ---->struct_time------>timestamp
29 struct_time = time.strptime('1988-03-03 11:11:11','%Y-%m-%d %H:%M:%S')
30 print(struct_time)
31 # time.struct_time(tm_year=1988, tm_mon=3, tm_mday=3, tm_hour=11, tm_min=11, tm_sec=11, tm_wday=3, tm_yday=63, tm_isdst=-1)
32 timestamp = time.mktime(struct_time) + 7*86400
33 print(timestamp)
34 # 573966671.0
35 
36 (2)format <------struct_time <------timestamp
37 struct_time = time.localtime(timestamp)
38 print(struct_time)
39 # time.struct_time(tm_year=1988, tm_mon=3, tm_mday=10, tm_hour=11, tm_min=11, tm_sec=11, tm_wday=3, tm_yday=70, tm_isdst=0)
40 res = time.strftime('%Y-%m-%d %X',struct_time)
41 print(res)
42 # 1988-03-10 11:11:11
43 
44 了解：
45 print(datetime.datetime.fromtimestamp(33333333))
46 # 1970-01-05 04:35:33

random模块

 

 1 Import random
 2 1、获取0-1之间随机浮点型数
 3 print(random.random()) 
 4 
 5 2、获取1-5随机整数(包括边界数)[1,5]
 6 print(random.randint(1,5)) 
 7 
 8 3、获取1-5随机浮点型数字（不包含边界）(1,5)
 9 print(random.uniform(1,5))
10 
11 获取1-5随机整数[1，5)
12 print(random.randrange(1,5))
13 
14 4、从列表选项中随机获取一个值
15 print(random.choices([1,5,True,9,’xxx’]))  # 结果为列表
16 
17 5、从列表中随机获取2(或多个)个值
18 print(random.sample([1,True,”XXX”],2)  # 结果为列表
19 
20 6、随机打乱次序,相当于“洗牌”
21 L=[1,2,3,4,5]
22 print(random.shuffle(L))  # 变化的是原列表
23 例子：随机验证码
24 chr()返回值是当前整数对应的 ASCII 字符。
25 import random
26 def get_random_str():
27     random_str=''
28     for i in range(5):
29         rd_num=str(random.randint(0,9))
30         rd_low=chr(random.randint(97,122))
31         rd_upr=chr(random.randint(65,90))
32         random_str+=random.choices([rd_num,rd_low,rd_upr])[0]
33     return random_str
34 print(get_random_str())

 

hashlib模块

 1 1 什么是hash
 2     什么是摘要算法呢？摘要算法又称哈希算法、散列算法。它通过一个函数，把任意长度的数据转换为一个长度固定的数据串（通常用16进制的字符串表示）。
 3 举个例子，你写了一篇文章，内容是一个字符串'how to use python hashlib - by Michael'，并附上这篇文章的摘要是'2d73d4f15c0db7f5ecb321b6a65e5d6d'。如果有人篡改了你的文章，并发表为'how to use python hashlib - by Bob'，你可以一下子指出Bob篡改了你的文章，因为根据'how to use python hashlib - by Bob'计算出的摘要不同于原始文章的摘要。
 4 可见，摘要算法就是通过摘要函数f()对任意长度的数据data计算出固定长度的摘要digest，目的是为了发现原始数据是否被人篡改过。
 5 摘要算法之所以能指出数据是否被篡改过，就是因为摘要函数是一个单向函数，计算f(data)很容易，但通过digest反推data却非常困难。而且，对原始数据做一个bit的修改，都会导致计算出的摘要完全不同。
 6 
 7 hashlib模块：封装一些用于加密的类
 8 加密的目的：用于判断和验证，而并非解密，文件完整性校验
 9 特点：
10 1）把一个大的数据，切成不同块，分别对不同的块进行加密，再汇总结果和直接对整体数据加密的结果是一致的
11 2）单向加密，不可逆
12 3）原始数据的一点小的变化，将导致结果的非常大的差异
13 4）只要传入的内容一样，得到的hash值必一样
14 5）不管传入的内容有多大，只要使用的hash算法不变，得到的hash长度一致
15 
16 
17 2 为何要用hash算法
18     hash值、产品的三大特性：
19   （1）只要传入的内容一样，得到的hash值必然一样
20   （2）只要我们使用的hash算法固定，无论传入的内容有多大，得到的hash值的长度的都是固定的
21   （3）不可以用hash值逆推出原来的内容
22 基于（1）和（2）的可以在下载文件时做一致性效验
23 基于（1）和（3）可以对密码进行加密
24 
25 md5加密算法：
26 import hashlib
27 m = hashlib.md5()  # 获取一个加密对象
28 m.update('abc中文'，encoding = 'utf-8') # 使用加密对象的update进行加密
29 res = m.hexdigest() # 通过hexdigest获取加密结果
30 print(res)
31 
32 给一个数据加密的三大步骤：
33 1、获取一个加密对象
34 2、使用加密对象的update，进行加密，update方法可以调用多次
35 3、通常通过hexdigest获取加密结果，或digest()方法
36 
37 给一个数据加密：
38 验证：用另一个数据加密的结果和第一次加密的结果对比，结果相同，说明原文相同
39 例如上传至百度云盘的文件，在上传前可以进行一次加密，同一份文件，下载下来后再进行一次加密（两次加密方式要一致），对比两次加密的结果，来判断文件的一致性
40 
41 （1）不同加密算法：实际上就是加密结果的长度
42 sh256=hashlib.sha256()
43 sh256.update('hello lili'.encode())
44 print(sh256.hexdigest())
45 print(len(hashlib.md5().hexdigest()))  # 32
46 print(len(sh256.hexdigest()))  # 64
47 
48 模拟撞库：
49 import hashlib
50 # 真实密码进行md5加密后的结果
51 cryptograph = 'aee949757a2e698417463d47acac93df' 
52 
53 # 制作密码字段 （猜测可能会是的密码）
54  passwds=[
55      'alex3714',
56      'alex1313',
57      'alex94139413',
58      'alex123456',
59      '123456alex',
60      'a123lex',
61  ]
62  
63  # 将所有猜测的密码进行md5加密
64  dic = {}
65  for p in password:
66      res = hashlib.md5(p.encode('utf-8'))
67      dic[p] = res.hexdigest()
68      
69  # 模拟撞库得到的密码
70  for k,v in dic.items():
71      if v == crytograph:  # 将加密后的密码与正是密码的加密结果对比
72          print('撞库成功，明文密码是：%s'%k) # 当一直时，便可知道真实密码
73          break
74  
75 （2）避免撞库成功，在创建加密对象时，可以指定参数，称为salt
76 例如：原密码：alex3714
77 import hashlib
78 m = hashlib.md5()
79 m.update('天王'.encode('utf-8'))
80 m.update('alex'.encode('utf-8'))
81 m.update('盖地虎'.encode('utf-8'))
82 m.update('3714'.encode('utf-8'))
83 print(m.hexdigest())
84 # f83060c64f0f029c2337fb453533c34a
85 # 这里的天王、盖地虎就是加盐操作

日志模块

 1 import logging
 2 # 日志级别
 3 logging.debug(“调试信息”)
 4 logging.info(“正常信息”)
 5 logging.warning(“警告信息”)
 6 logging.error(“错误信息”)
 7 logging.critical(“严重错误信息”)
 8 结果：
 9 WARNING:root:警告信息
10 ERROR:root:错误信息
11 CRITICAL:root:严重错误信息
12 
13 日志config函数
14 logging.basicConfig(   # 日志打印信息
15 #日志级别ritical-50，error-40，warning-30，info-20，debug-10
16 level=logging.DEBUG  # 相当于level=10
17 filename=”log.txt”
18 #日志格式
19 format=”%(asctime)s %(levelname)s %(message)s”
20 #日期格式
21 datefmt=”%Y/%m/%d %H:%M
22 )
23 
24 日志器组件 处理器组件  格式化组件 过滤组件
25 import logging
26 def get_logger():
27     #(1)获取日志器组件
28     logger=logging.getLogger()
29     logger.setLevel(logging.DEBUG)  #设置日志级别
30 
31     #判断当前日志器对象是否拥有处理器组件
32 if not logger.handlers:  
33 # 表示当handlers列表为空时，空列表为false
34         #(2)构建处理器对象: 文件输出流 控制台输出流
35         fh=logging.FileHandler(
36             filename='log2.txt',
37             encoding='utf-8'
38         )
39         sh=logging.StreamHandler()
40         # fh不设置按照logger的日志级别，与sh级别不同
41         sh.setLevel(logging.WARNING)
42         #日志器对象添加处理器对象
43         logger.addHandler(fh)
44         logger.addHandler(sh)
45 
46         #(3)创建格式化组件
47         fmt=logging.Formatter(
48             fmt='%(asctime)s %(levelname)s %(lineno)s %(message)s',
49             datefmt='%Y/%m/%d %H:%M'
50         )
51 
52         #处理器对象添加格式化组件
53         fh.setFormatter(fmt)
54         sh.setFormatter(fmt)
55 
56     return logger
57 logger=get_logger()
58 logger.debug("调试信息")
59 logger.info("正常信息")
60 logger.warning("警告信息")
61 logger.error("错误信息")
62 logger.critical("严重错误信息")