模块一：时间模块、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模块

Import time
1、时间戳：1970-1-1到现在的秒数
作用：用于时间间隔的计算
timestamp=time.time()

2、time.sleep(second)，second秒数

3、time.ctime(timestamp)    
# 结果 wed jun 9 08:48:51 2021

4、time.asctime(传入时间元组)：*生成固定格式的时间表示格式，把一个表示时间的元组或者struct_time*表示为’Sat Jan 13 21:56:34 2018’这种形式。如果没有给参数，会将time.localtime()作为参数传入。

5.按照某种格式显示时间：2021-06-27 12：12：12
作用：用于展示时间
print(time.strftime('%Y-%m-%d %H:%M:%S %p')) # 2021-06-27 15:12:06 PM
print(time.strftime('%Y-%m-%d %X')) # 2021-06-27 15:12:06

6、结构化的时间
作用：用于单独获取时间的某一部分
print(time.gmtime())    # 世界标准时间
res = time.localtime()   # 本地时间
print(res)
print(res.tm_year)
print(res.tm_yday)
运行结果：
# 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)
# 2021
# 178

例：打印进度条
import time
def progress(percent):
    if percent>1:
        percent = 1
    res = int(50*percent) * "#"
    print('
[%-50s]%d%%'%(percent*100))

sev = 0
total = 102050
while sev < total:
    time.sleep(0.01)
    sev += 1024
    percent = sev/total
    progress(percent)

datetime模块

（一）datetime模块的date类型（年 月 日）
Import datetime
1、datetime.date() 构建任意日期对象
print(datetime.date(1993,12,12)) # 1993-12-12  <class ‘datetime.date’>
获取时间片信息
d=datetime.date(1993,12,12)
print(d.year)   # 1993
print(d.month)  # 12
print(d.day)    # 12

2、获取当前日期
today=datetime.date.today()  # 2021-06-19

3、按指定格式输出时间
today.strftime(“”)  # %Y:year %m:month %d:day
print(today.strftime(“%Y/%m/%d”))

（二）datetime模块的datetime类型（年月日时分秒）
1、datetime.datetime() 获取任意日期对象
dt=datetime.datetime(2012,12,12)
print(dt)  # 2012-12-12  00:00:00
获取时间片信息
print(dt.year)     2012
print(dt.month)    12
print(dt.day)        12
print(dt.hour)      0
print(dt.minute)    0

2、获取当前日期对象
today=datetime.datetime.today()
now=datetime.datetime.now()

3、格式化时间
print(now.strftime(“%Y/%m/%d %H:%M”))

（三）datetime模块的time类型（时分秒）
t=datetime.time(3,3,10)
print(t.hour)
print(t.minute)
print(t.second)

（四）datetime模块的timedelta类型（时间间隔）
delta =datetime.timedelta(weeks=2)
print(now+delta)

时间模块重点：

1、时间格式的转换
struct_time -----> 时间戳

import time
# .mktime()函数接收struct_time对象作为参数，返回用秒数来表示时间的浮点型
stime = time.localtime()
print(stime)
print(time.mktime(stime))
运行结果：
# 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)
# 1624779538.0

时间戳---->struct_time
tp_time=time.time()
print(tp_time)
print(time.localtime(tp_time))
运行结果：
# 1624779876.5282025
# 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)

struct_time = time.localtime()
print(time.strftime('%Y-%m-%d %H:%M:%S',struct_time))
#  2021-06-27 15:50:22
print(time.strptime('1988-03-03 11:11:11','%Y-%m-%d %H:%M:%S'))
# 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)

重点：format string  <-------> timestamp
（1）format string ---->struct_time------>timestamp
struct_time = time.strptime('1988-03-03 11:11:11','%Y-%m-%d %H:%M:%S')
print(struct_time)
# 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)
timestamp = time.mktime(struct_time) + 7*86400
print(timestamp)
# 573966671.0

(2)format <------struct_time <------timestamp
struct_time = time.localtime(timestamp)
print(struct_time)
# 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)
res = time.strftime('%Y-%m-%d %X',struct_time)
print(res)
# 1988-03-10 11:11:11

了解：
print(datetime.datetime.fromtimestamp(33333333))
# 1970-01-05 04:35:33

random模块

Import random
1、获取0-1之间随机浮点型数
print(random.random()) 

2、获取1-5随机整数(包括边界数)[1,5]
print(random.randint(1,5)) 

3、获取1-5随机浮点型数字（不包含边界）(1,5)
print(random.uniform(1,5))

获取1-5随机整数[1，5)
print(random.randrange(1,5))

4、从列表选项中随机获取一个值
print(random.choices([1,5,True,9,’xxx’]))  # 结果为列表

5、从列表中随机获取2(或多个)个值
print(random.sample([1,True,”XXX”],2)  # 结果为列表

6、随机打乱次序,相当于“洗牌”
L=[1,2,3,4,5]
print(random.shuffle(L))  # 变化的是原列表
例子：随机验证码
chr()返回值是当前整数对应的 ASCII 字符。
import random
def get_random_str():
    random_str=''
    for i in range(5):
        rd_num=str(random.randint(0,9))
        rd_low=chr(random.randint(97,122))
        rd_upr=chr(random.randint(65,90))
        random_str+=random.choices([rd_num,rd_low,rd_upr])[0]
    return random_str
print(get_random_str())

hashlib模块

1 什么是hash
    什么是摘要算法呢？摘要算法又称哈希算法、散列算法。它通过一个函数，把任意长度的数据转换为一个长度固定的数据串（通常用16进制的字符串表示）。
举个例子，你写了一篇文章，内容是一个字符串'how to use python hashlib - by Michael'，并附上这篇文章的摘要是'2d73d4f15c0db7f5ecb321b6a65e5d6d'。如果有人篡改了你的文章，并发表为'how to use python hashlib - by Bob'，你可以一下子指出Bob篡改了你的文章，因为根据'how to use python hashlib - by Bob'计算出的摘要不同于原始文章的摘要。
可见，摘要算法就是通过摘要函数f()对任意长度的数据data计算出固定长度的摘要digest，目的是为了发现原始数据是否被人篡改过。
摘要算法之所以能指出数据是否被篡改过，就是因为摘要函数是一个单向函数，计算f(data)很容易，但通过digest反推data却非常困难。而且，对原始数据做一个bit的修改，都会导致计算出的摘要完全不同。

hashlib模块：封装一些用于加密的类
加密的目的：用于判断和验证，而并非解密，文件完整性校验
特点：
1）把一个大的数据，切成不同块，分别对不同的块进行加密，再汇总结果和直接对整体数据加密的结果是一致的
2）单向加密，不可逆
3）原始数据的一点小的变化，将导致结果的非常大的差异
4）只要传入的内容一样，得到的hash值必一样
5）不管传入的内容有多大，只要使用的hash算法不变，得到的hash长度一致


2 为何要用hash算法
    hash值、产品的三大特性：
  （1）只要传入的内容一样，得到的hash值必然一样
  （2）只要我们使用的hash算法固定，无论传入的内容有多大，得到的hash值的长度的都是固定的
  （3）不可以用hash值逆推出原来的内容
基于（1）和（2）的可以在下载文件时做一致性效验
基于（1）和（3）可以对密码进行加密

md5加密算法：
import hashlib
m = hashlib.md5()  # 获取一个加密对象
m.update('abc中文'，encoding = 'utf-8') # 使用加密对象的update进行加密
res = m.hexdigest() # 通过hexdigest获取加密结果
print(res)

给一个数据加密的三大步骤：
1、获取一个加密对象
2、使用加密对象的update，进行加密，update方法可以调用多次
3、通常通过hexdigest获取加密结果，或digest()方法

给一个数据加密：
验证：用另一个数据加密的结果和第一次加密的结果对比，结果相同，说明原文相同
例如上传至百度云盘的文件，在上传前可以进行一次加密，同一份文件，下载下来后再进行一次加密（两次加密方式要一致），对比两次加密的结果，来判断文件的一致性

（1）不同加密算法：实际上就是加密结果的长度
sh256=hashlib.sha256()
sh256.update('hello lili'.encode())
print(sh256.hexdigest())
print(len(hashlib.md5().hexdigest()))  # 32
print(len(sh256.hexdigest()))  # 64

模拟撞库：
import hashlib
# 真实密码进行md5加密后的结果
cryptograph = 'aee949757a2e698417463d47acac93df' 

# 制作密码字段 （猜测可能会是的密码）
 passwds=[
     'alex3714',
     'alex1313',
     'alex94139413',
     'alex123456',
     '123456alex',
     'a123lex',
 ]
 
 # 将所有猜测的密码进行md5加密
 dic = {}
 for p in password:
     res = hashlib.md5(p.encode('utf-8'))
     dic[p] = res.hexdigest()
     
 # 模拟撞库得到的密码
 for k,v in dic.items():
     if v == crytograph:  # 将加密后的密码与正是密码的加密结果对比
         print('撞库成功，明文密码是：%s'%k) # 当一直时，便可知道真实密码
         break
 
（2）避免撞库成功，在创建加密对象时，可以指定参数，称为salt
例如：原密码：alex3714
import hashlib
m = hashlib.md5()
m.update('天王'.encode('utf-8'))
m.update('alex'.encode('utf-8'))
m.update('盖地虎'.encode('utf-8'))
m.update('3714'.encode('utf-8'))
print(m.hexdigest())
# f83060c64f0f029c2337fb453533c34a
# 这里的天王、盖地虎就是加盐操作

日志模块

import logging
# 日志级别
logging.debug(“调试信息”)
logging.info(“正常信息”)
logging.warning(“警告信息”)
logging.error(“错误信息”)
logging.critical(“严重错误信息”)
结果：
WARNING:root:警告信息
ERROR:root:错误信息
CRITICAL:root:严重错误信息

日志config函数
logging.basicConfig(   # 日志打印信息
#日志级别ritical-50，error-40，warning-30，info-20，debug-10
level=logging.DEBUG  # 相当于level=10
filename=”log.txt”
#日志格式
format=”%(asctime)s %(levelname)s %(message)s”
#日期格式
datefmt=”%Y/%m/%d %H:%M
)

日志器组件 处理器组件  格式化组件 过滤组件
import logging
def get_logger():
    #(1)获取日志器组件
    logger=logging.getLogger()
    logger.setLevel(logging.DEBUG)  #设置日志级别

    #判断当前日志器对象是否拥有处理器组件
if not logger.handlers:  
# 表示当handlers列表为空时，空列表为false
        #(2)构建处理器对象: 文件输出流 控制台输出流
        fh=logging.FileHandler(
            filename='log2.txt',
            encoding='utf-8'
        )
        sh=logging.StreamHandler()
        # fh不设置按照logger的日志级别，与sh级别不同
        sh.setLevel(logging.WARNING)
        #日志器对象添加处理器对象
        logger.addHandler(fh)
        logger.addHandler(sh)

        #(3)创建格式化组件
        fmt=logging.Formatter(
            fmt='%(asctime)s %(levelname)s %(lineno)s %(message)s',
            datefmt='%Y/%m/%d %H:%M'
        )

        #处理器对象添加格式化组件
        fh.setFormatter(fmt)
        sh.setFormatter(fmt)

    return logger
logger=get_logger()
logger.debug("调试信息")
logger.info("正常信息")
logger.warning("警告信息")
logger.error("错误信息")
logger.critical("严重错误信息")