ATM购物车

1. 先把主要用到的文件夹在项目根目录下创建一下！！！

2. 再先把简单的几个常用的文件创建一下

bin start.py # 直接写，固定的
core src.py
conf settings.py
db db_handler.py
interface bank_interface shop_interface user_interface admin_interface
lib common.py

3. src里面先把各个功能函数用pass自定义出来，再把功能函数名对应的字典写出来，再把输入函数编号运行对应函数的几行代码写一下，src暂时写好了。

3.2 第一层 src里面只负责，用户输入，输出，及调用对应的接口函数，不负责逻辑判断

3.3 第二层 代码的的核心逻辑在对应的接口层

3.4 第三层 负责数据相关的操作，比如查询，写入的功能

3.5 settings里面放一些配置文件，比如创建创建db文件目录，提现手续费，日志配置字典等不会改变，很多功能可能会用的功能代码

3.6 common里面放一些装饰器函数，加密函数，判断输入的数字是否为存数字函数，日志器生成函数

4. 开始从src里面功能函数代码编写及对应接口文件代码编写，再调其他需要的函数，在接口层开始写核心逻辑代码，写到哪，需要什么，就导什么，再写要导的函数，一步一步来

5. src代码

from interface import user_interface, shop_interface, bank_interface
from lib import common

is_login = {'username': ''}


def register():
    while True:
        username = input('输入用户名(q)>>:').strip()
        if username == 'q':
            break
        password = input('请输入密码>>:').strip()
        ag_password = input('请再次输入密码>>:').strip()
        if not password == ag_password:
            print('两次密码不一致，请重新输入')
            continue
        # 调用第二层，核心的注册功能函数
        flag, msg = user_interface.register_interface(username, password)
        if not flag:
            continue
        print(msg)


def login():
    while True:
        username = input('输入用户名(q)>>:').strip()
        if username == 'q':
            break
        password = input('请输入密码>>:').strip()
        # 调用第二层核心的登录函数
        flag, msg = user_interface.login_interface(username, password)
        print(msg)
        if not flag:
            continue
        else:
            is_login['username'] = username


@common.login_auth
def check_balance():
    username = is_login.get('username')
    # 直接调用第二层核心的查看余额的函数
    flag, msg = bank_interface.check_balance_interface(username)
    print(msg)


@common.login_auth
def withdraw():
    username = is_login.get('username')
    # 1.获取用户想要提现的具体金额即可
    target_money = input('请输入要提现的金额>>:').strip()
    # 2.直接调用提现接口函数
    flag, msg = bank_interface.withdraw_interface(username, target_money)
    print(msg)


@common.login_auth
def charge_money():
    username = is_login.get('username')
    # 1. 获取想要充值的金额即可
    target_money = input('请输入要充值的金额>>:').strip()
    # 2. 直接调用充值还款的接口函数
    flag, msg = bank_interface.charge_money_interface(username, target_money)
    print(msg)


@common.login_auth
def transfer():
    # 获取想要转账的金额及转账的人
    username = is_login['username']
    target_user = input('请输入要转账的人>>:').strip()
    target_money = input('请输入要转帐的金额>>:').strip()
    # 调用转账接口函数
    flag, msg = bank_interface.transfer_interface(username, target_user, target_money)
    print(msg)


@common.login_auth
def check_flow():
    username = is_login['username']
    flag, msg = bank_interface.check_flow_interface(username)
    if flag:
        for i in msg:
            print(i)
    else:
        print(msg)


@common.login_auth
def add_shop_car():
    username = is_login.get('username')
    flag, msg = shop_interface.add_shop_car_interface(username)
    print(msg)


@common.login_auth
def check_shop_car():
    # 1.直接调用查看购物车接口
    username = is_login.get('username')
    flag, msg = shop_interface.check_shop_car_interface(username)
    if flag:  # msg 拿到的是shop_car {'商品名称':[个数，单价]}
        for i, j in msg.items():
            print(f"商品:{i} | 商品个数:{j[0]} | 商品单价:{j[1]}")
    else:
        print(msg)


@common.login_auth
def pay_shop_car():
    username = is_login.get('username')
    flag, msg = shop_interface.pay_shop_car_interface(username)
    print(msg)


@common.login_auth
def admin():
    pass


func_dict = {
    '1': register,
    '2': login,
    '3': check_balance,
    '4': withdraw,
    '5': charge_money,
    '6': transfer,
    '7': check_flow,
    '8': add_shop_car,
    '9': check_shop_car,
    '10': pay_shop_car,
    '11': admin
}


def run():
    while True:
        print("""
        1.注册
        2.登陆
        3.查看余额
        4.提现
        5.充值还款
        6.转账
        7.查看流水
        8.添加购物车功能
        9.查看购物车功能
        10.结算购物车功能
        11.管理员功能
        """)
        func_n = input('请输入要执行的函数功能编号>>:').strip()
        if func_n in func_dict:
            func_dict.get(func_n)()
        else:
            print('您输入的编号不存在，请重新输入！！')

6. user_interface 代码

from db import db_handler
from lib import common


logger = common.get_logger('注册登录模块')

def register_interface(username, password):
    # 第一步判断用户名是否存在,调用查询函数
    res = db_handler.select(username)
    if res:  # 这个地方别弄反了！！！有返回值时，说明用户名已存在了,刚刚犯错了，多加了个not了
        return False, '用户名已存在,请重新注册！！！'
    # 第二步对密码加密)
    hash_pwd = common.get_hash(password)
    # 第三步定义用户字典
    user_dict = {
        'username': username,
        'password': hash_pwd,
        'balance': 800000,
        'shop_car': {},
        'is_lock': False,  # 这样拿到用户数据先判断这个键的值，如果是True，说账户被冻结！
        'bank_flow': []
    }
    # 第四步用户字典写入用户文件
    db_handler.save(user_dict)
    logger.info(f'{username}注册成功，ni_ma_dan_de!!!')
    return True, '注册成功'


def login_interface(username, password):
    # 判断用户名是否存在，调用查询函数
    user_dict = db_handler.select(username)  # 如果用户名存在，返回值就是用户字典
    if not user_dict:  # 如果用户名不存在，返回值就是None
        return False, '用户名不存在'

    # 对输入的密码加密
    hash_pwd = common.get_hash(password)
    # 判断加密后的密码是否正确
    if user_dict.get('password') == hash_pwd:
        logger.info(f'{username}登录成功，日志器鸟用没有!!!')
        return True, '登录成功'
    else:
        return False, '密码不正确'

.
.
.

7. bank_interface.py 代码

from db import db_handler
from conf import settings
from lib import common
import time

logger = common.get_logger('银行模块')


def check_balance_interface(username):
    # 1.查询当前登录用户的字典数据
    user_dict = db_handler.select(username)
    # 2.从字典中获取余额信息并返回给第一层
    user_balance = user_dict.get('balance')
    logger.debug(f'用户{username}查看了自己的账户余额')
    return True, f'尊敬的{username},您目前的账户余额为{user_balance}'


def withdraw_interface(username, target_money):
    flag, value = common.get_num(target_money)
    if not flag:
        return False, '请输入符合要求的金额数字'
    # 1.获取当前登录用户的字典数据
    user_dict = db_handler.select(username)
    # 2.获取用户余额并判断是否满足提现要求  还应该收取手续费
    user_balance = user_dict.get('balance')
    if user_balance >= value * (1 + settings.MONEY_RATE):
        user_dict['balance'] -= value * (1 + settings.MONEY_RATE)
        # 添加账户流水信息
        ctime = time.strftime('%Y-%m-%d %H:%M:%S')
        user_dict['water_flow'].append(f'时间{ctime}:账户提现了{value},收取了手续费{value * settings.MONEY_RATE}')
        db_handler.save(user_dict)

        logger.debug(f'用户{username}提现了{value}')

        return True, f'尊敬的客户{username},您已经提现了{value},手续费{value * settings.MONEY_RATE},账户余额{user_dict.get("balance")}'
    return False, f'尊敬的客户{username}您的账户不够提现哦，请先充值!'


def pay_back_interface(username, target_money):
    flag, value = common.get_num(target_money)
    if not flag:
        return False, '请输入符合要求的金额数字'
    # 1.获取用户字典数据
    user_dict = db_handler.select(username)
    # 2.直接添加余额
    user_dict['balance'] += value
    # 添加流水记录
    ctime = time.strftime('%Y-%m-%d %H:%M:%S')
    user_dict['water_flow'].append(f'时间{ctime}:账户充值了{value},该阶段账户余额{user_dict.get("balance")}')
    # 3.保存用户数据
    db_handler.save(user_dict)

    logger.debug(f'用户{username}充值了{value}')

    return True, f'尊敬的用户{username},您充值了{value},目前账户余额{user_dict.get("balance")}'


def transfer_interface(current_user, target_user, target_money):
    # 1.先校验目标用户是否存在
    target_user_dict = db_handler.select(target_user)
    if not target_user_dict:
        return False, f'目标用户{target_user}不存在'
    # 2.再校验用户输入的金额是否是整数或者小数
    flag, value = common.get_num(target_money)
    if not flag:
        return False, '请输入符合要求的金额数字'
    # 3.获取当前登录用户的数据
    current_user_dict = db_handler.select(current_user)
    # 4.判断当前用户余额是否充足
    if current_user_dict.get('balance') >= value:
        current_user_dict['balance'] -= value
        # 记录账户扣钱的流水
        ctime = time.strftime('%Y-%m-%d %H:%M:%S')
        current_user_dict['water_flow'].append(f'时间{ctime}:给{target_user}账户转了{value}')
        target_user_dict['balance'] += value
        # 记录账户加钱的流水
        target_user_dict['water_flow'].append(f'时间{ctime}:收{current_user}账户转过来的钱{value}')
        db_handler.save(current_user_dict)
        db_handler.save(target_user_dict)

        logger.debug(f'用户{current_user}给{target_user}账户转了{value}')

        return True, f'尊敬的用户{current_user},您给{target_user}账户转了{value},您目前账户余额为{current_user_dict.get("balance")}'
    return False, '您当前余额不够转账'


def check_flow_interface(username):
    # 1.获取用户名对应的用户字典
    user_dict = db_handler.select(username)
    if user_dict.get('water_flow'):
        logger.debug(f'{username}查看了自己的流水记录')
        return True, user_dict.get('water_flow')
    return False, '该用户暂无流水记录'

.
.
.

8.shop_interface.py 代码

from db import db_handler
from lib import common
import time

logger = common.get_logger('购物车模块')


def add_shop_car_interface(username):
    temp_shop_car = {}  # {'商品名':[数量，价格]}
    while True:
        good_list = [
            ['挂壁面', 3],
            ['印度飞饼', 22],
            ['极品木瓜', 666],
            ['土耳其土豆', 999],
            ['伊拉克拌面', 1000],
            ['董卓戏张飞公仔', 2000],
            ['仿真玩偶', 10000]
        ]
        for i, j in enumerate(good_list):
            print(f'商品编号：{i}     |    商品名称：{j[0]}    |    商品价格：{j[1]}')
        good_id = input('请输入商品编号(q)>>:').strip()
        # 第三部分
        if good_id == 'q':
            # 打开用户文件，拿到老的shop_car
            user_dict = db_handler.select(username)
            old_shop_car = user_dict.get('shop_car')
            for i_name, j_list in temp_shop_car.items():
                if i_name in old_shop_car:
                    old_shop_car.get(i_name)[0] += j_list[0]
                else:
                    old_shop_car[i_name] = j_list
            user_dict['shop_car'] = old_shop_car
            # 写入用户文件
            db_handler.save(user_dict)
            # 记录日志
            logger.info(f'{username}用户添加购物车成功，fuck')
            return True, '添加购物车成功！！！'

        # 第二部分
        if not good_id.isdigit():
            print('请输入纯数字！！')
            continue
        good_id = int(good_id)
        if good_id not in range(len(good_list)):
            print('没有您要购买的商品编号，请重新选择编号')
            continue
        good_name = good_list[good_id][0]
        good_price = good_list[good_id][1]
        good_num = input('请输入该商品的购买数量').strip()
        if not good_num.isdigit():
            print('商品数量必须是纯数字')
            continue
        good_num = int(good_num)
        if good_name in temp_shop_car:  # 商品名在里面，就数量增加
            temp_shop_car.get(good_name)[0] += good_num
        else:  # 不在里面就将选购的{商品名称:[数量，价格]}加到临时字典里面去
            temp_shop_car[good_name] = [good_num, good_price]


def check_shop_car_interface(username):
    # 调用查询功能函数,获取当前登录用户的字典数据,获取当前用户购物车数据
    user_dict = db_handler.select(username)
    user_shop_car = user_dict.get('shop_car')
    if user_shop_car:   # 判断购物车是否为空，
        # 并加个日志记录
        logger.info(f'用户{username}查看了购物车数据，shit')
        return True, user_shop_car
    else:
        return False, '暂无购物车数据，感觉去选购吧'


def pay_shop_car_interface(username):
    # 调用查询功能函数,获取当前用户购物车数据及账户余额
    user_dict = db_handler.select(username)
    user_shop_car = user_dict.get('shop_car')
    current_balance = user_dict.get('balance')
    if not user_shop_car:
        return False, '购物车为空，赶紧选购吧'
    # 统计购物车商品总价
    total_money = 0
    for i in user_shop_car.values():
        total_money = total_money + i[0]*i[1]
    # 比较余额是否充足
    if total_money > current_balance:
        return False, '余额不足，请充值'
    else:
        user_dict['balance'] = current_balance

    # 添加账户流水信息到用户字典里的'bank_flow'值里面去
    ctime = time.strftime('%Y-%m-%d %X')
    user_dict['bank_flow'].append(f'时间{ctime}:购物消费了{total_money}')
    # 清空购物车
    user_dict['shop_car'] = {}
    # 记录日志
    logger.info(f'{username}疯狂消费了{total_money}，bitch')
    # 再写入功能函数
    db_handler.save(user_dict)
    return True, f"本次消费{total_money}，卡上余额{user_dict['balance']}欢迎下次再来！！"

.
.

9.db_handler.py 代码

import os
import json
from conf.settings import DB_DIR


# 用户查询
def select(username):
    user_file_path = os.path.join(DB_DIR, f'{username}.json')
    if os.path.isfile(user_file_path):
        with open(user_file_path, 'r', encoding='utf8')as f:
            return json.load(f)  # 有返回值说明用户名已经存在了
    # 用户名不存在，不会走if的代码，所以返回值为None！！！


# 用户写入
def save(user_dict):
    username = user_dict.get('username')
    user_file_path = os.path.join(DB_DIR, f'{username}.json')
    with open(user_file_path, 'w', encoding='utf8')as f:
        json.dump(user_dict, f, ensure_ascii=False)   # 涉及到汉字写入字典时要再加一个参数

.
.

10. common.py 代码

import hashlib
import logging
import logging.config
from conf import settings


# 加密功能
def get_hash(msg):
    md555 = hashlib.md5()
    md555.update(msg.encode('utf8'))
    hash_msg = md555.hexdigest()
    return hash_msg


# 装饰器
def login_auth(func):
    def inner(*args, **kwargs):
        from core import src
        if src.is_login:
            res = func(*args, **kwargs)
            return res
        else:
            print('您还未登录，请先登录')
            src.login()

    return inner


# 判断输入的钱是否为纯数字
def get_num(target_money):
    try:
        target_money = float(target_money)
    except ValueError:
        return False, '请输入整数或者小数'
    else:
        return True, target_money


# 日志器生成的函数
def get_logger(msg):
    logging.config.dictConfig(settings.LOGGING_DIC)  # 自动加载字典中的配置
    logger1 = logging.getLogger(msg)
    return logger1

.
.

12.代码编写注意事项：

有空补充