10月27日内容总结——hashlib加密模块和logging、subprocess模块

一、hashlib加密模块
二、加密补充说明
三、subprocess模块
四、logging日志模块
五、日志的执行过程
六、日志配置字典
七、作业
- start.py
- src.py
- settings.py
- common.py

一、hashlib加密模块

hashlib模块是用于数据加密的，模块中有很多种加密算法，比如md5、base64、hmac、sha1等sha系列的加密算法。

1、何为加密

将明文数据处理成密文数据让人无法看懂（无法逆转），但是可以通过已经加密过的结果进行穷举，来推测明文。

2、为什么加密

为了保证数据的安全

3、如何判断数据是否以加密

我们可以观看数据的构成，如果是用无序的数字、字母、符号来组成的，基本上都是加密数据

4、密文的长短有什么意义

密文越长表示两种情况，第一种就是明文很长，第二种就是加密的算法很复杂，这里我们需要注意算法并不是越复杂越好，应该根据实际情况选择使用，有些时候反而使用简单的算法就足够了。

5、加密算法的基本操作

# 第一步导入模块

import hashlib

# 2.传入明文数据

md5 = hashlib.md5()

md5.update(b'hello')

# 3.获取加密密文

res = md5.hexdigest()

print(res)  # 5d41402abc4b2a76b9719d911017c592

注：md5中需要使用二进制才能转换

二、加密补充说明

1.加密算法不变 内容如果相同 那么结果肯定相同

	 # md5.update(b'hello~world~python~666')  # 一次性传可以

    md5.update(b'hello')  # 分多次传也可以

    md5.update(b'~world')  # 分多次传也可以

    md5.update(b'~python~666')  # 分多次传也可以

2.加密之后的结果是无法反解密的

	 只能从明文到密文正向推导 无法从密文到明文反向推导

    常见的解密过程其实是提前猜测了很多种结果

    	123		  密文

       321	     密文

    	222      密文

3.加盐处理

	 在明文里面添加一些额外的干扰项

    # 1.选择加密算法

    md5 = hashlib.md5()

    # 2.传入明文数据

    md5.update('公司设置的干扰项'.encode('utf8'))

    md5.update(b'hello python')  # 一次性传可以

    # 3.获取加密密文

    res = md5.hexdigest()

    print(res)  # e53024684c9be1dd3f6114ecc8bbdddc

4.动态加盐

	 干扰项是随机变化的

    	eg:当前时间、用户名部分...

5.加密实战操作

	1.用户密码加密

	2.文件安全性校验

 	3.文件内容一致性校验

  	4.大文件内容加密

    	截取部分内容加密即可

        比如一种情况就是，在一个大文件的每隔四分之一处取一千个字节进行加密，如果两个文件的密文一样说明，这里就是一样的两个文件

三、subprocess模块

subprocess是python内置的模块，这个模块中的Popen可以查看用户输入的命令行是否存在

如果存在，把内容写入到stdout管道中

如果不存在，把信息写入到stderr管道

需要注意的是，这个模块的返回结果只能让开发者看一次，如果想多次查看，需要在第一次输出的时候，把所有信息写入到变量中。

1、subprocess中的popen用法：

Popen基本格式：subprocess.Popen(‘命令’, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
shell=True 表示要在终端中运行的命令

stdout=sbuprocess.PIPE 表示当命令存在的时候，把结果写入到stdout管道

stderr=sbuprocess.PIPE 表示当命令不存在的时候，把结果吸入到stderr管道

import subprocess

res = subprocess.Popen(

    'asdas',  # 操作系统要执行的命令

    shell=True,  # 固定配置

    stdin=subprocess.PIPE,  # 输入命令

    stdout=subprocess.PIPE,  # 输出结果

)

print('正确结果', res.stdout.read().decode('gbk'))  # 获取操作系统执行命令之后的正确结果

print('错误结果', res.stderr)  # 获取操作系统执行命令之后的错误结果

2. subprocess模块中的常用函数

函数	描述
subprocess.run()	Python 3.5中新增的函数。执行指定的命令，等待命令执行完成后返回一个包含执行结果的CompletedProcess类的实例。
subprocess.call()	执行指定的命令，返回命令执行状态，其功能类似于os.system(cmd)。
subprocess.check_call()	Python 2.5中新增的函数。执行指定的命令，如果执行成功则返回状态码，否则抛出异常。其功能等价于subprocess.run(…, check=True)。
subprocess.check_output()	Python 2.7中新增的的函数。执行指定的命令，如果执行状态码为0则返回命令执行结果，否则抛出异常。
subprocess.getoutput(cmd)	接收字符串格式的命令，执行命令并返回执行结果，其功能类似于os.popen(cmd).read()和commands.getoutput(cmd)。
subprocess.getstatusoutput(cmd)	执行cmd命令，返回一个元组(命令执行状态, 命令执行结果输出)，其功能类似于commands.getstatusoutput()。

说明：

1.在Python 3.5之后的版本中，官方文档中提倡通过subprocess.run()函数替代其他函数来使用subproccess模块的功能；

2.在Python 3.5之前的版本中，我们可以通过subprocess.call()，subprocess.getoutput()等上面列出的其他函数来使用subprocess模块的功能；

3.subprocess.run()、subprocess.call()、subprocess.check_call()和subprocess.check_output()都是通过对subprocess.Popen的封装来实现的高级函数，因此如果我们需要更复杂功能时，可以通过subprocess.Popen来完成。

4.subprocess.getoutput()和subprocess.getstatusoutput()函数是来自Python 2.x的commands模块的两个遗留函数。它们隐式的调用系统shell，并且不保证其他函数所具有的安全性和异常处理的一致性。另外，它们从Python 3.3.4开始才支持Windows平台。

3、上面各函数的定义及参数说明

subprocess.run(args, *, stdin=None, input=None, stdout=None, stderr=None, shell=False, timeout=None, check=False, universal_newlines=False)

subprocess.call(args, *, stdin=None, stdout=None, stderr=None, shell=False, timeout=None)

subprocess.check_call(args, *, stdin=None, stdout=None, stderr=None, shell=False, timeout=None)

subprocess.check_output(args, *, stdin=None, stderr=None, shell=False, universal_newlines=False, timeout=None)

subprocess.getstatusoutput(cmd)

subprocess.getoutput(cmd)

参数说明：

args：要执行的shell命令，默认应该是一个字符串序列，如[‘df’, ‘-Th’]或(‘df’, ‘-Th’)，也可以是一个字符串，如’df -Th’，但是此时需要把shell参数的值置为True。

shell：如果shell为True，那么指定的命令将通过shell执行。如果我们需要访问某些shell的特性，如管道、文件名通配符、环境变量扩展功能，这将是非常有用的。当然，python本身也提供了许多类似shell的特性的实现，如glob、fnmatch、os.walk()、os.path.expandvars()、os.expanduser()和shutil等。

check：如果check参数的值是True，且执行命令的进程以非0状态码退出，则会抛出一个CalledProcessError的异常，且该异常对象会包含参数、退出状态码、以及stdout和stderr(如果它们有被捕获的话)。

stdout, stderr：input：该参数是传递给Popen.communicate()，通常该参数的值必须是一个字节序列，如果universal_newlines=True，则其值应该是一个字符串。

run()函数默认不会捕获命令执行结果的正常输出和错误输出，如果我们向获取这些内容需要传递subprocess.PIPE，然后可以通过返回的CompletedProcess类实例的stdout和stderr属性或捕获相应的内容；

call()和check_call()函数返回的是命令执行的状态码，而不是CompletedProcess类实例，所以对于它们而言，stdout和stderr不适合赋值为subprocess.PIPE；

check_output()函数默认就会返回命令执行结果，所以不用设置stdout的值，如果我们希望在结果中捕获错误信息，可以执行stderr=subprocess.STDOUT。

universal_newlines：该参数影响的是输入与输出的数据格式，比如它的值默认为False，此时stdout和stderr的输出是字节序列；当该参数的值设置为True时，stdout和stderr的输出是字符串。

四、logging日志模块

1、如何理解日志

所谓日志就是一个用来记录我们行为举止的代码，类似以前的史官，我们在平时的使用中并不要求自己可以写出来，会用别人的代码并且会改就可以了。因为以后会使用整合更好的模块来使用。

2、日志的五种级别

logging模块日志级别有DEBUG < INFO < WARNING < ERROR < CRITICAL 五种。

DEBUG - 调试模式，应用场景是问题诊断；

INFO - 通常只记录程序中一般事件的信息，用于确认工作一切正常；

WARNING - 打印警告信息，系统还在正常运行；

ERROR - 错误导致某些功能不能正常运行时记录的信息；

CRITICAL - 当发生严重错误，导致应用程序不能继续运行时记录的信息。

3、组成部分

logger：提供记录日志的方法。
handler：选择日志的输出地方（一个logger添加多个handler）。
filter：给用户提供更加细粒度的控制日志的输出内容。
format：用户格式化输出日志的信息。

4、配置方法

1.基础配置

logging.basicConfig(filename="config.log",

                    filemode="w",

                    format="%(asctime)s-%(name)s-%(levelname)s-%(message)s",

                    level=logging.INFO)

2.使用配置文件的方式

fileConfig(filename,defaults=None,disable_existing_loggers=Ture )

3.使用一个字典方式来写配置信息

使用dictConfig(dict,defaults=None, disable_existing_loggers=Ture )函数

3、日志输出

StreamHandler

logging.StreamHandler:日志输出到流，可以是sys.stderr，sys.stdout或者文件

FileHandler

logging.FileHandler:日志输出到文件

BaseRotatingHandler

logging.handlers.BaseRotatingHandler:基本的日志回滚方式

RotatingHandler

logging.handlers.RotatingHandler:日志回滚方式，支持日志文件最大数量和日志文件回滚

4、format常用格式说明

    %(levelno)s: 打印日志级别的数值

    %(levelname)s: 打印日志级别名称

    %(pathname)s: 打印当前执行程序的路径，其实就是sys.argv[0]

    %(filename)s: 打印当前执行程序名

    %(funcName)s: 打印日志的当前函数

    %(lineno)d: 打印日志的当前行号

    %(asctime)s: 打印日志的时间

    %(thread)d: 打印线程ID

    %(threadName)s: 打印线程名称

    %(process)d: 打印进程ID

    %(message)s: 打印日志信息

五、日志的执行过程

1、产生日志

2、过滤日志

这里我们需要注意，通常来说我们会在产生日志的时候设置需要产生的日志。其他不需要的日志就不会生成，所以基本用不到这个模块

3、输出日志

4、日志格式

六、字段解释

# 字段解释

filename：日志文件名的prefix；

when：是一个字符串，用于描述滚动周期的基本单位，字符串的值及意义如下：

“S”: Seconds

“M”: Minutes

“H”: Hours

“D”: Days

“W”: Week day (0=Monday)

“midnight”: Roll over at midnight

interval: 滚动周期，单位有when指定，比如：when=’D’,interval=1，表示每天产生一个日志文件

backupCount: 表示日志文件的保留个数

举例：

import logging

# 1.日志的产生(准备原材料)        logger对象

logger = logging.getLogger('购物车记录')

# 2.日志的过滤(剔除不良品)        filter对象>>>:可以忽略 不用使用

# 3.日志的产出(成品)             handler对象

hd1 = logging.FileHandler('a1.log', encoding='utf-8')  # 输出到文件中

hd2 = logging.FileHandler('a2.log', encoding='utf-8')  # 输出到文件中

hd3 = logging.StreamHandler()  # 输出到终端

# 4.日志的格式(包装)             format对象

fm1 = logging.Formatter(

        fmt='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',

        datefmt='%Y-%m-%d %H:%M:%S %p',

)

fm2 = logging.Formatter(

        fmt='%(asctime)s - %(name)s:  %(message)s',

        datefmt='%Y-%m-%d',

)

# 5.给logger对象绑定handler对象

logger.addHandler(hd1)

logger.addHandler(hd2)

logger.addHandler(hd3)

# 6.给handler绑定formmate对象

hd1.setFormatter(fm1)

hd2.setFormatter(fm2)

hd3.setFormatter(fm1)

# 7.设置日志等级

logger.setLevel(10)  # debug

# 8.记录日志

logger.debug('写了半天 好累啊 好热啊')

六、日志配置字典

通常来说我们都是使用日志字典的形式来达成功能的（功能多又方便，谁不喜欢呢）。这里也是跟之前的说的一样，会用就好，不需要了解。

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 = 'a3.log'

LOGGING_DIC = {

    'version': 1,

    'disable_existing_loggers': False,

    'formatters': {

        'standard': {

            'format': standard_format

        },

        'simple': {

            'format': simple_format

        },

    },

    'filters': {},  # 过滤日志

    'handlers': {

        # 打印到终端的日志

        'console': {

            'level': 'DEBUG',

            '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,

                # 这里两个参数的意思是一个日志文件最多写5M，最多可以存在五个不同的日志文件，但是当数量达到五个之后就会出现最早的那个会被删除，

                # 然后再产生一个新的文件（类似于覆盖了最早的那个文件）

            'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了

        },

    },

    'loggers': {

        # logging.getLogger(__name__)拿到的logger配置

        '': {

            'handlers': ['default', 'console'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕

            'level': 'DEBUG',

            'propagate': True,  # 向上（更高level的logger）传递

        },  # 当键不存在的情况下 (key设为空字符串)默认都会使用该k:v配置

        # '购物车记录': {

        #     'handlers': ['default','console'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕

        #     'level': 'WARNING',

        #     'propagate': True,  # 向上（更高level的logger）传递

        # },  # 当键不存在的情况下 (key设为空字符串)默认都会使用该k:v配置

    },

}

logging.config.dictConfig(LOGGING_DIC)  # 自动加载字典中的配置

# logger1 = logging.getLogger('购物车记录')

# logger1.warning('尊敬的VIP客户 晚上好 您又来啦')

# logger1 = logging.getLogger('注册记录')

# logger1.debug('jason注册成功')

logger1 = logging.getLogger('红浪漫顾客消费记录')

# 当这里的getLogger内部的参数如果字典中没有，就会自动使用字典中名称为空的那个模版来执行

logger1.debug('慢男 猛男 骚男')

七、作业

完善购物车程序尝试拆分成软件开发目录规范并添加日志功能

start.py

import weekends_work.core.src

# 完善购物车程序 尝试拆分成软件开发目录规范并添加日志功能

import os

# 获取文件目前所在位置

out_path = os.path.dirname(os.path.dirname(__file__))

db_path = os.path.join(out_path, 'db')

print(__name__)

if __name__ == '__main__':

    weekends_work.core.src.choice_user()

src.py

import json

import os

import hashlib

import weekends_work.lib.common

good_list = [['挂壁面', 3],

             ['印度飞饼', 22],

             ['极品木瓜', 666],

             ['土耳其土豆', 999],

             ['伊拉克拌面', 1000],

             ['董卓戏张飞公仔', 2000],

             ['仿真玩偶', 10000]]

now_path = os.getcwd()

os.chdir('..')

all_path = os.getcwd()

db_path = os.path.join(all_path, 'db')

log_user = {'name': ''}

def choice_user():

    while True:

        choice_user = input(

            '''请选择需要执行的功能：\n1、用户登陆\n2、用户注册\n3、添加购物车\n4、结算购物车\n5、充值\n6、查看购物车中当前内容\n7、清空购物车中内容\n8、修改购物车中内容\n9、转账\n10、查看消费记录\n请输入需要执行的指令（q退出）：''')

        if choice_user == 'q':

            print('退出成功')

            break

        if choice_user not in user_choice:

            print('功能编号不存在 请重新输入')

            continue

        func_name = user_choice.get(choice_user)  # 获取函数名

        res = func_name()  # 调用函数

        if res:

            print(res)

# 整个装饰器判断是否登陆了

def is_log_z(func):

    def intter(*args, **kwargs):

        if log_user["name"] == '':

            return '请先进行登陆'

        else:

            res = func(*args, **kwargs)

            return res

    return intter

def log_in():

    is_log_bool = True

    while is_log_bool:

        log_name = input('请输入登陆的用户名(q退出)：')

        # 获取用户名

        if log_name == 'q':

            break

            # 输q退出

        if log_name == '':

            # 如果用户名为空就重新注册

            print('用户名不能为空！')

            continue

        file_name = f'{log_name}.json'

        file_path = os.path.join(db_path, file_name)

        # 拼接路径，查找这个文件是不是存在（判断这个用户名是否已经存在）

        is_file = os.path.exists(file_path)

        if not is_file:

            print('用户名错误')

            lg = weekends_work.lib.common.get_logger('登录记录')

            lg.debug('用户名错误')

            continue

        # 如果有这个文件（有这个用户）

        print('用户名正确')

        log_pwd = input('请输入密码：')

        # 获取密码

        file_name = f'{log_name}.json'

        file_path = os.path.join(db_path, file_name)

        with open(file_path, 'r', encoding='utf8') as f1:

            res = json.load(f1)

        log_pwd_md5 = hashlib.md5()

        log_pwd_md5.update(log_pwd.encode())

        log_pwd_md5_get = log_pwd_md5.hexdigest()

        if res['password'] != log_pwd_md5_get:

            print('密码错误')

            lg = weekends_work.lib.common.get_logger('登录记录')

            lg.debug(f'用户{log_name}密码错误')

            continue

        print('登陆成功')

        log_user['name'] = log_name

        is_log_bool = False

        lg = weekends_work.lib.common.get_logger('登录记录')

        lg.debug(f'用户{log_name}登陆成功')

def sign_in():

    while True:

        # 获取注册的用户名

        sign_name = input('请输入注册的用户名(q退出)：').strip()

        if sign_name == 'q':

            break

        if sign_name == '':

            # 如果用户名为空就重新注册

            print('用户名不能为空！')

            lg = weekends_work.lib.common.get_logger('注册记录')

            lg.debug('用户名为空')

            continue

        file_name = f'{sign_name}.json'

        file_path = os.path.join(db_path, file_name)

        # 拼接路径，查找这个文件是不是存在（判断这个用户名是否已经存在）

        is_file = os.path.exists(file_path)

        if is_file:

            # 当这个文件存在了（用户名重复了），重新注册

            print('用户名重复请重新输入！')

            lg = weekends_work.lib.common.get_logger('注册记录')

            lg.debug(f'用户{sign_name}重复')

            continue

        # 如果前面的操作都没出错，就获取密码，需要输入两次进行确定

        sign_pwd = input('请输入密码：').strip()

        check_sign_pwd = input('请确认密码：').strip()

        if sign_pwd != check_sign_pwd:

            # 如果两次密码不一致，重新注册

            print('两次密码不一致，请重新输入！')

            lg = weekends_work.lib.common.get_logger('注册记录')

            lg.debug(f'用户{sign_name}两次密码不一致')

            continue

        doc_name = f'{sign_name}.json'

        user_path = os.path.join(db_path, doc_name)

        sign_pwd_md5 = hashlib.md5()

        sign_pwd_md5.update(sign_pwd.encode())

        sign_pwd_md5_get = sign_pwd_md5.hexdigest()

        with open(user_path, 'w', encoding='utf8') as f1:

            user_infor = {'name': sign_name, 'password': sign_pwd_md5_get, 'balance': 15000, 'shop_car': {},

                          'record': []}

            json.dump(user_infor, f1, ensure_ascii=False)

            print('注册成功')

            lg = weekends_work.lib.common.get_logger('注册记录')

            lg.debug(f'用户{sign_name}注册成功')

            break

@is_log_z

def shop_add():

    user_d = f'{log_user["name"]}.json'

    add_path = os.path.join(db_path, user_d)

    res_befor = {}

    little_shop_car = {}

    while True:

        count = 1

        print('-----------------商品目录如下：----------------')

        for i, j in enumerate(good_list, start=1):

            lis_shop = f'''

商品编号：{i}

商品名：{j[0]}

商品价格：{j[1]}元

            '''

            print(lis_shop)

        choice_shop = input('请输入需要添加到购物车的物品(输入编号)：').strip()

        # 获取用户需要购买商品的编号

        if not choice_shop.isdigit():

            # 判断是否是纯数字编号,不是就重新来过

            print('请输入正确的数字编号！')

            lg = weekends_work.lib.common.get_logger('添加购物车记录')

            lg.debug(f'用户{log_user["name"]}商品编号错误')

            continue

        if int(choice_shop) not in range(1, 8):

            print('你他奶奶的商品编号超出范围了！')

            lg = weekends_work.lib.common.get_logger('添加购物车记录')

            lg.debug(f'用户{log_user["name"]}商品编号错误')

            continue

        # 判断编号范围是否在范围内

        shop_name = good_list[int(choice_shop) - 1][0]

        shop_price = good_list[int(choice_shop) - 1][1]

        choice_number = input(f'请输入需要购买{shop_name}数量：')

        # 编号在范围内就获取需要购买的数量

        if not choice_number.isdigit():

            # 如果购买数量不是纯数字也重新来过

            print('数量需要是纯数字！')

            lg = weekends_work.lib.common.get_logger('添加购物车记录')

            lg.debug(f'用户{log_user["name"]}商品编号错误')

            continue

        if little_shop_car.get(shop_name) == None:

            # 临时购物车中如果没有这个商品的信息就直接加入

            little_shop_car[shop_name] = [int(choice_number), shop_price]

        else:

            # 如果有信息就相加

            little_shop_car[shop_name][0] += int(choice_number)

        with open(add_path, 'r', encoding='utf8') as f1:

            res_befor = json.load(f1)

        old_car = res_befor.get('shop_car')

        if old_car and count == 1:

            # 如果数据库中不为空，把里面的数据值加进来

            for i in old_car:

                print(i)

                print(old_car[i][0])

                if little_shop_car.get(i) == None:

                    little_shop_car[i] = old_car[i]

                else:

                    little_shop_car[i][0] += old_car[i][0]

        print('商品添加成功')

        lg = weekends_work.lib.common.get_logger('添加购物车记录')

        lg.debug(f'用户{log_user["name"]}商品成功加入临时购物车')

        count += 1

        if_continue = input('输入q退出，其他字符继续购物')

        if if_continue == 'q':

            if little_shop_car:

                res_befor['shop_car'] = little_shop_car

                with open(add_path, 'w', encoding='utf8') as f2:

                    json.dump(res_befor, f2, ensure_ascii=False)

                print('退出成功')

                lg = weekends_work.lib.common.get_logger('添加购物车记录')

                lg.debug(f'用户{log_user["name"]}购物结束')

                break

            else:

                print('退出成功')

                lg = weekends_work.lib.common.get_logger('添加购物车记录')

                lg.debug(f'用户{log_user["name"]}未购物直接退出')

                break

@is_log_z

def settle_account():

    user_d = f'{log_user["name"]}.json'

    add_path = os.path.join(db_path, user_d)

    with open(add_path, 'r', encoding='utf8') as f1:

        res_befor = json.load(f1)

    count_money_all = 0

    for i in res_befor['shop_car']:

        list_i = res_befor['shop_car'][i]

        count_money = list_i[1] * list_i[0]

        count_money_all += count_money

    print(count_money_all)

    balance_u = res_befor['balance'] - count_money_all

    res_befor['record'].append(f'-{count_money_all}')

    if balance_u <= 0:

        print('余额不足')

        lg = weekends_work.lib.common.get_logger('结算记录')

        lg.debug(f'用户{log_user["name"]}余额不支持结算')

    res_befor['balance'] = balance_u

    res_befor['shop_car'] = {}

    with open(add_path, 'w', encoding='utf8') as f2:

        json.dump(res_befor, f2, ensure_ascii=False)

    print(f'尊敬的{log_user["name"]} 您本次消费{count_money} 卡上余额剩余{balance_u} 欢迎下次再来挥霍!!!')

    lg = weekends_work.lib.common.get_logger('结算记录')

    lg.debug(f'用户{log_user["name"]}结算成功')

@is_log_z

def balance_add():

    user_d = f'{log_user["name"]}.json'

    add_path = os.path.join(db_path, user_d)

    with open(add_path, 'r', encoding='utf8') as f1:

        res_befor = json.load(f1)

    balance_add_number = int(input('请输入充值金额：').strip())

    res_befor['balance'] += balance_add_number

    res_befor['record'].append(f'+{balance_add_number}')

    with open(add_path, 'w', encoding='utf8') as f2:

        json.dump(res_befor, f2, ensure_ascii=False)

    print('添加成功')

    lg = weekends_work.lib.common.get_logger('充值记录')

    lg.debug(f'用户{log_user["name"]}充值成功')

@is_log_z

def shop_car_print():

    user_d = f'{log_user["name"]}.json'

    add_path = os.path.join(db_path, user_d)

    with open(add_path, 'r', encoding='utf8') as f1:

        res_befor = json.load(f1)

    print(f'-------------用户：{log_user["name"]}当前购物车中物品如下：------------')

    if res_befor['shop_car'] == {}:

        print('空')

        lg = weekends_work.lib.common.get_logger('查看购物车记录')

        lg.debug(f'用户{log_user["name"]}购物车为空')

    else:

        for i in res_befor['shop_car']:

            number_i = res_befor['shop_car'][i][0]

            price_i = res_befor['shop_car'][i][1]

            infor_p = f'''

--------------------------------------------------

商品名：{i}

单价：{price_i}

已添加数量：{number_i}

--------------------------------------------------

                        '''

            print(infor_p)

            lg = weekends_work.lib.common.get_logger('查看购物车记录')

            lg.debug(f'用户{log_user["name"]}购物车内容已查看')

@is_log_z

def shop_car_clear():

    user_d = f'{log_user["name"]}.json'

    add_path = os.path.join(db_path, user_d)

    with open(add_path, 'r', encoding='utf8') as f1:

        res_befor = json.load(f1)

    res_befor['shop_car'] = {}

    with open(add_path, 'w', encoding='utf8') as f1:

        res_befor = json.dump(res_befor, f1, ensure_ascii=False)

    lg = weekends_work.lib.common.get_logger('清空购物车记录')

    lg.debug(f'用户{log_user["name"]}购物车已清空')

@is_log_z

def change_shop_car():

    while True:

        user_d = f'{log_user["name"]}.json'

        add_path = os.path.join(db_path, user_d)

        with open(add_path, 'r', encoding='utf8') as f1:

            res_befor = json.load(f1)

        print(f'-------------用户：{log_user["name"]}当前购物车中物品如下：------------')

        if res_befor['shop_car'] == {}:

            print('空')

            lg = weekends_work.lib.common.get_logger('修改购物车记录')

            lg.debug(f'用户{log_user["name"]}购物车为空')

            break

        else:

            for i in res_befor['shop_car']:

                number_i = res_befor['shop_car'][i][0]

                price_i = res_befor['shop_car'][i][1]

                infor_p = f'''

    --------------------------------------------------

    商品名：{i}

    单价：{price_i}

    已添加数量：{number_i}

    --------------------------------------------------

                                '''

                print(infor_p)

        change_name = input('请输入需要更改的商品名称（要中文输完整,输入q退出）：').strip()

        if change_name == 'q':

            print('成功退出')

            lg = weekends_work.lib.common.get_logger('修改购物车记录')

            lg.debug(f'用户{log_user["name"]}直接退出')

            break

        if change_name in res_befor['shop_car']:

            change_number = int(input('需要更改的数量：').strip())

            if change_number == 0:

                res_befor['shop_car'][change_name].pop

                print(res_befor)

                lg = weekends_work.lib.common.get_logger('修改购物车记录')

                lg.debug(f'用户{log_user["name"]}购物车内容已修改')

            else:

                res_befor['shop_car'][change_name][0] = change_number

                print(res_befor)

                lg = weekends_work.lib.common.get_logger('修改购物车记录')

                lg.debug(f'用户{log_user["name"]}购物车内容已修改')

            with open(add_path, 'w', encoding='utf8') as f1:

                json.dump(res_befor, f1, ensure_ascii=False)

@is_log_z

def log_shopping():

    user_d = f'{log_user["name"]}.json'

    add_path = os.path.join(db_path, user_d)

    with open(add_path, 'r', encoding='utf8') as f1:

        res_befor = json.load(f1)

    print(f'---------------用户{log_user}流水：----------------')

    lg = weekends_work.lib.common.get_logger('查看流水记录')

    lg.debug(f'用户{log_user["name"]}查看流水')

    for i in res_befor['record']:

        print(f'''

        {i}元

        ''')

@is_log_z

def send_money():

    while True:

        user_d = f'{log_user["name"]}.json'

        add_path = os.path.join(db_path, user_d)

        with open(add_path, 'r', encoding='utf8') as f1:

            res_befor = json.load(f1)

        money_now = res_befor['balance']

        # 获取用户当前余额

        # 获取转账对象并判断是否存在

        send_user = input('请输入转账对象：')

        if send_user == 'q':

            print('成功退出')

            lg = weekends_work.lib.common.get_logger('转账记录')

            lg.debug(f'用户{log_user["name"]}直接退出')

            break

        user_s_d = f'{send_user}.json'

        send_path = os.path.join(db_path, user_s_d)

        ans = os.path.exists(send_path)

        if not ans:

            print('用户不存在')

            lg = weekends_work.lib.common.get_logger('转账记录')

            lg.debug(f'用户{log_user["name"]}转账用户不存在')

        # 如果用户存在就转账

        send_number = input('请输入转账金额：')

        print('111')

        if int(send_number) <= money_now:

            print('余额不足')

            lg = weekends_work.lib.common.get_logger('转账记录')

            lg.debug(f'用户{log_user["name"]}余额不足')

        # 如果转账金额足够就转账

        with open(send_path, 'r', encoding='utf8') as f2:

            res_befor_s1 = json.load(f2)

        res_befor_s1['balance'] += int(send_number)

        with open(send_path, 'w', encoding='utf8') as f3:

            json.dump(res_befor_s1, f3, ensure_ascii=False)

        # 转账之后把转账用户中的金额扣除

        res_befor['balance'] -= int(send_number)

        res_befor['record'].append(f'-{send_number}')

        with open(add_path, 'w', encoding='utf8') as f4:

            json.dump(res_befor, f4, ensure_ascii=False)

        lg = weekends_work.lib.common.get_logger('转账记录')

        lg.debug(f'用户{log_user["name"]}转账成功')

user_choice = {'1': log_in,

               '2': sign_in,

               '3': shop_add,

               '4': settle_account,

               '5': balance_add,

               '6': shop_car_print,

               '7': shop_car_clear,

               '8': change_shop_car,

               '9': send_money,

               '10': log_shopping,

               }

settings.py

import os

# 定义日志输出格式 开始

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'

# 自定义文件路径

out_path = os.path.dirname(os.path.dirname(__file__))

log_path = os.path.join(out_path,'log')

if not os.path.exists(log_path):

    os.mkdir(log_path)

logfile_path = os.path.join(log_path, 'z1.log')

LOGGING_DIC = {

    'version': 1,

    'disable_existing_loggers': False,

    'formatters': {

        'standard': {

            'format': standard_format

        },

        'simple': {

            'format': simple_format

        },

    },

    'filters': {},  # 过滤日志

    'handlers': {

        # 打印到终端的日志

        'console': {

            'level': 'DEBUG',

            '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,

                # 这里两个参数的意思是一个日志文件最多写5M，最多可以存在五个不同的日志文件，但是当数量达到五个之后就会出现最早的那个会被删除，

                # 然后再产生一个新的文件（类似于覆盖了最早的那个文件）

            'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了

        },

    },

    'loggers': {

        # logging.getLogger(__name__)拿到的logger配置

        '': {

            'handlers': ['default', 'console'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕

            'level': 'DEBUG',

            'propagate': True,  # 向上（更高level的logger）传递

        },  # 当键不存在的情况下 (key设为空字符串)默认都会使用该k:v配置

        # '购物车记录': {

        #     'handlers': ['default','console'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕

        #     'level': 'WARNING',

        #     'propagate': True,  # 向上（更高level的logger）传递

        # },  # 当键不存在的情况下 (key设为空字符串)默认都会使用该k:v配置

    },

}

common.py

import logging

import logging.config

from weekends_work.conf import settings

def get_logger(name):

    logging.config.dictConfig(settings.LOGGING_DIC)  # 自动加载字典中的配置

    logger1 = logging.getLogger(name)

    return logger1

巴特西