16 模块time、datetime、random、hashlib、logging

1. 时间模块time、datetime

在python中，表示时间有三种方式：
时间戳

格式化的时间字符串(Format String): '2022-03-01'

时间元组(struct_time)

1.1 time模块

1.1.1 时间戳（time）

（1）生成时间戳

时间戳是指格林威治时间1970年01月01日00时00分00秒（北京时间1970年01月01日08时00分00秒）起至现在的总秒数。

import time  # 导入time模块

a = time.time()  # 生成时间戳，时间戳是浮点数类型
print(a, type(a))  # 1722591376.9927173 <class 'float'>

（2）时间戳转换为时间元组（UTC时间）     国际时间

将时间戳转换为UTC时间，与英国伦敦当地时间一致

import time

b = time.time()  # 生成时间戳
c = time.gmtime(b)  # 时间戳转换为时间元组类型
print(c, type(c))
# time.struct_time(tm_year=2024, tm_mon=8, tm_mday=2, tm_hour=9, tm_min=43, tm_sec=59, tm_wday=4, tm_yday=215, tm_isdst=0) <class 'time.struct_time'>

（3）时间戳转换为时间元组（当地时间）

UTC时间+8小时=北京时间

import time

a = time.time()
b = time.localtime(a)
print(b)
# time.struct_time(tm_year=2024, tm_mon=8, tm_mday=2, tm_hour=17, tm_min=51, tm_sec=9, tm_wday=4, tm_yday=215, tm_isdst=0)

1.1.2 字符串格式化时间（strftime）

符号    含义              值
%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    当前时区的名称
%%    %号本身    

import time

# 时间元组放或不放都行
a = time.strftime('%Y-%m-%d %H:%M:%S')
print(a)  # 2024-08-02 18:09:09
b = time.strftime('%Y-%m-%d %H:%M:%S', time.gmtime())
print(b)  # 2024-08-02 10:09:09
c = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())
print(c)  # 2024-08-02 18:09:09

d = time.strftime('%c')
print(d)  # Fri Aug  2 18:09:09 2024

1.1.3 时间元组(struct_time)

（1）time.localtime   时间戳--->时间元组

import time

print(time.localtime())
# time.struct_time(tm_year=2024, tm_mon=8, tm_mday=2, tm_hour=18, tm_min=28, tm_sec=19, tm_wday=4, tm_yday=215, tm_isdst=0)

（2）time.mktime     时间元组--->时间戳

print(time.mktime(time.localtime()))  # 1722594776.0

（3）time.strftime     时间元组--->时间字符串

时间元组参数若不写，则使用当前时间

import time

print(time.strftime("%Y-%m-%d ", time.localtime()))
# 2024-08-02
print(time.strftime("%H:%M:%S ", time.localtime()))
# 18:50:35

（4）time.strptime　时间字符串--->时间元组

import time

print(time.strptime('2022-02-28 09:22:05', '%Y-%m-%d %H:%M:%S'))
# time.struct_time(tm_year=2022, tm_mon=2, tm_mday=28, tm_hour=9, tm_min=22, tm_sec=5, tm_wday=0, tm_yday=59, tm_isdst=-1)

（5）time.asctime    时间元组--->标准的时间格式

import time

print(time.asctime(time.localtime()))  # Fri Aug  2 19:05:20 2024
print(time.asctime())  # Fri Aug  2 19:05:20 2024

（6）time.ctime         时间戳--->标准的时间格式

import time

print(time.ctime(time.time()))  # Fri Aug  2 19:08:23 2024
print(time.ctime())  # Fri Aug  2 19:08:23 2024

1.1.4 小结

时间戳是计算机处理时间的方法

时间字符串是人类能够看懂的字符串

时间元组是两者的中间值，用来互相转换

1.2 datetime模块

（1）自定义日期并格式化输出

import datetime

a = datetime.date(2023, 11, 20)
print(a)  # 2023-11-20

（2）获取当地时间

年月日

import datetime

print(datetime.date.today())  # 2024-08-02

年月日时分秒

import datetime

a = datetime.datetime.today()
print(a)  # 2024-08-02 19:43:42.946123

# 以以上时间a为基础，可以得到更加具体的数据
print(a.year)  # 2024
print(a.month)  # 8
print(a.day)  # 2
print(a.hour)  # 19
print(a.minute)  # 46
print(a.second)  # 30
print(a.weekday)  # 星期(weekday星期是0-6) 0表示周一
print(a.isoweekday)  # 获取星期(weekday星期是1-7) 1表示周一

（3）timedelta  时间日期的增减对象

打印时间增减

import datetime

# 生成一个时间数据，可以对日期进行加减
ahead_day = datetime.timedelta(days=2)
print(ahead_day)  # 2 days, 0:00:00

delay_day = datetime.timedelta(days=3)
print(delay_day)  # 3 days, 0:00:00

对日期进行增减

import datetime

# 打印当前时间提前2天的具体时间
ahead_day = datetime.timedelta(days=2)
print(datetime.datetime.today() - ahead_day)  # 2024-07-31 19:57:35.348771

# 打印当前时间往后3天的具体时间
delay_day = datetime.timedelta(days=3)
print(datetime.datetime.today() + delay_day)  # 2024-08-05 19:59:09.937551

日期对象与timedelta之间的关系：

　　日期对象 = 日期对象 + / - timedelta对象
 　   timedelta对象 = 日期对象 + / - 日期对象

2. 随机模块random

import random

# 1.随机生成0~1之间的小数 random
a = random.random()
print(a)  # 0.46371291740686915

# 2.生成指定区间的小数  uniform
b = random.uniform(1, 2)
print(b)  # 1.90434431469814

# 3.随机区间整数，两侧都可以取到  randint
c = random.randint(11, 13)
print(c)  # 13

# 4.随机区间整数，要考虑起始值和步长  randrange
d = random.randrange(1, 10, 2)
print(d)  # 1,3,5,7,9中取一个数

# 5.随机返回列表的一个元素   choice
e = ['messi', 'ronaldo', 'neymar', 'kylian']
print(random.choice(e))  # messi

# 6.随机返回列表指定个数元素  sample
f = ['messi', 'ronaldo', 'neymar', 'kylian', 'haaland']
print(random.sample(f, 2))
# ['neymar', 'haaland']

# 7.打乱列表顺序，作用在原列表上  shuffle
g = [1, 2, 3, 4, 5, 6, 7, 8, 9]
random.shuffle(g)
print(g)  # [1, 6, 8, 4, 5, 7, 3, 2, 9]

random模块的应用场景

# chr方法：根据ASCII码表的顺序，传入数字以展示对应的字符
import random

print(chr(65))  # A
print(chr(90))  # Z
print(chr(97))  # a
print(chr(122))  # z

# 生成一个6位数的随机验证码
def identify_code(n):
    code = ''  # 初始为空，循环一次字符串个数加一个
    for i in range(n):  # 定义循环的次数
        upper_case = chr(random.randint(65, 90))
        lower_case = chr(random.randint(97, 122))
        num = str(random.randint(0, 9))
        code += random.choice([upper_case, lower_case, num])  # 每次循环在大小写、数字中随机取一个
    return code

print(identify_code(6))  # j9025B

3. 摘要算法hashlib模块

3.1 概念

摘要算法又称为哈希算法、散列算法

通过一个函数将任意长度的数据转换成一个固定长度的字符串，16进制32位长度

摘要算法就是通过摘要函数f()对任意长度的数据data计算出固定长度的摘要digest，目的是为了发现原始数据是否被修改过。摘要算法之所以能指出数据是否被修改过，就是因为摘要函数是一个单向函数。
计算f(data)很容易，但通过digest反推data却非常困难。而且，对原始数据做一个bit的修改，都会导致计算出的摘要完全不同。

python的hashlib提供了常见的摘要算法：MD5、SHA1

3.2  md5算法

import hashlib

def encrypt(a):
    tool = hashlib.md5()  # 1.生成一个md5对象
    a = a.encode()  # 2.将传入的原始数据转成二进制
    tool.update(a)  # 3.对原始数据的二进制格式进行摘要加密
    print(tool.hexdigest())  # 4.获取加密后的16进制字符串
    print(tool.digest())  # 或者获取加密后的2进制字符串

encrypt('111111')

3.3 摘要算法升级之加盐

对原始数据加一个字符串，让原始数据和字符串一起加密，俗称“加盐”

def encrypt(data, salt):
    tool = hashlib.md5()  # 1.生成一个md5对象
    final_data = data + salt  # 2.对原始数据进行加盐
    final_data = final_data.encode()  # 3.加盐后的数据转成二进制
    tool.update(final_data)  # 4.加盐二进制进行摘要加密
    print(tool.hexdigest())  # 5.获取加密后的16进制字符串
    print(tool.digest())  # 或者获取2进制字符串

encrypt('111111', '111')
# bbb8aae57c104cda40c93843ad5e6db8
# b'\xbb\xb8\xaa\xe5|\x10L\xda@\xc98C\xad^m\xb8'

另一种写法

def encrypt(data, salt):
    final_data = data + salt
    final_data = final_data.encode()
    encrypt_data = hashlib.md5(final_data)
    print(encrypt_data.hexdigest())
    print(encrypt_data.digest())

encrypt('111111', '111')
# bbb8aae57c104cda40c93843ad5e6db8
# b'\xbb\xb8\xaa\xe5|\x10L\xda@\xc98C\xad^m\xb8'

3.4 摘要算法的含义

摘要算法不是加密算法

加密算法的含义是：可以对原数据进行加密，并且可以对加密后的数据进行解密

摘要算法的含义是：单向加密，没有办法解密

4. 日志模块logging

模板

import logging
import logging.config

# 定义日志输出格式 开始
standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
                  '[%(levelname)s][%(message)s]'  # 其中name为getlogger指定的名字
simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
# 定义日志输出格式 结束

# 自定义文件路径
logfile_path = 'rizhi.log'

# log配置字典
LOGGING_DIC = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'standard': {
            'format': standard_format
        },
        'simple': {
            'format': simple_format
        },
    },
    'filters': {},  # 过滤日志
    'handlers': {
        # 打印到终端的日志
        'console': {
            'level': 'DEBUG',  # NOTSET < DEBUG < INFO < WARNING < ERROR < CRITICAL
            'class': 'logging.StreamHandler',  # 打印到屏幕
            'formatter': 'simple'
        },
        # 打印到文件的日志,收集info及以上的日志
        'default': {
            'level': 'DEBUG',
            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
            'formatter': 'standard',
            'filename': logfile_path,  # 日志文件
            'maxBytes': 1024 * 1024 * 5,  # 日志大小 5M
            'backupCount': 5,  # 保留最近5份
            'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了
        },
    },
    'loggers': {
        # logging.getLogger(__name__)拿到的logger配置
        # 当键为空不存在的情况下 (key设为空字符串)默认都会使用该k:v配置
        '': {
            'handlers': ['default', 'console'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
            'level': 'DEBUG',
            'propagate': True,
            # 向上（更高level的logger）传递，如果上一个键值对的值是debug，那么可以向上打印warning的信息
            # 如果上有一个键值对的值是WARNING，那么不能向下打印debug的信息
        },

        # '注册记录': {
        #     'handlers': ['console'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
        #     'level': 'WARNING',
        #     'propagate': True,  # 向上（更高level的logger）传递
        # },  # 当键不存在的情况下 (key设为空字符串)默认都会使用该k:v配置
    },
}

# 使用日志字典配置
# logging.config.dictConfig(LOGGING_DIC)  # 自动加载字典中的配置
# logger1 = logging.getLogger('转账记录')
# logger2 = logging.getLogger('注册记录')
# logger1.debug('阿根廷足球巨星梅西')
# logger2.warning('法国足球巨星基利安姆巴佩')

# logging.config.dictConfig(LOGGING_DIC)  # 自动加载字典中的配置
# logger1 = logging.getLogger('withdraw record')
# '''loggers配置中使用空字符串作为字典的键 兼容性最好!!!'''
# logger1.debug('messi ronaldo neymar')

logging.config.dictConfig(LOGGING_DIC)
a = logging.getLogger('注册信息')
a.debug('ronaldo注册')

# 定义产生日志的函数
def get_logger(name='', ):
    '''
    :param name: 日志等级
    :return:
    '''
    # 初始化日志处理器 - 使用配置字典初始化日志处理器(将自定义配置加载到日志处理器中)
    logging.config.dictConfig(LOGGING_DIC)
    # 实例化日志处理器对象 - 并赋予日志处理器等级
    logger = logging.getLogger(name)
    # 返回日志生成对象
    return logger