ATM+购物车项目流程

目录

• 需求分析
• 架构设计
• 功能实现
  • 搭建文件目录
  • conf配置文件夹
  • lib公共功能文件夹
  • db数据文件夹
  • interface业务逻辑层文件夹
  • core表现层文件夹
• 测试
  • 最外层功能(src.py)
  • 银行的功能(bank.py)
  • 购物功能(shopping.py)
  • 管理员功能(administrator.py)
  • 结束

需求分析

• 登录注册功能
• 管理员功能（删除用户、拉黑用户等）
• 购物功能
• 银行功能

架构设计

编程语言：python

界面显示：控制台

数据库：文本文件

框架：无

功能实现

搭建文件目录

• conf存放配置文件
• core为表现层，展示给用户的界面
• db存储数据，为数据访问层，访问数据用
• interface为业务逻辑层，存放核心代码
• lib存放公共功能模块
• log存放日志文件，记录日志
• run.py为启动文件

conf配置文件夹

db_path.py提供存放用户数据和商品信息的路径

db_path.py

import os

# 获取ATM路径
path = os.path.dirname(os.path.dirname(__file__))
DB_PATH = os.path.join(path, 'db')
if not os.path.exists(DB_PATH):
    os.mkdir(DB_PATH)
# user文件夹路径
USER_PATH = os.path.join(DB_PATH, 'user')
# product文件夹路径
PRODUCT_PATH = os.path.join(DB_PATH, 'product')

if not os.path.exists(USER_PATH):
    os.mkdir(DB_PATH)
if not os.path.exists(PRODUCT_PATH):
    os.mkdir(DB_PATH)

if __name__ == '__main__':
    print(USER_PATH)
    print(PRODUCT_PATH)

log_dict.py提供日志字典

log_dict.py

import os
# 自动创建log文件夹
log_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'log')
if not os.path.isdir(log_path):
    os.mkdir(log_path)

# 自定义文件路径
logfile_path = os.path.join(log_path, 'log.log')

# 定义复杂的日志输出格式, 其中name为getlogger指定的名字
standard_format = '%(levelname)s :%(asctime)s - %(name)s - %(filename)s:  %(message)s'

# 配置日志字典
LOG_DICT = {
    'version': 1,  # 不用管
    'disable_existing_loggers': False,  # 不用管
    'formatters': {  # 绑定输出格式
        'standard': {
            'format': standard_format  # 绑定复杂的输出格式
        },
    },
    'filters': {},  # 过滤日志  不用管
    'handlers': {  # 配置输出日志位置
        '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配置
        # loggers配置中使用空字符串作为字典的键，兼容性最好
        '': {  # 可以当作是日志输出的分类信息
            'handlers': ['default'],  # log数据写入文件
            'level': 'DEBUG',  # 定义日志可以输出的等级
            'propagate': True,  # 向上（更高level的logger）传递
        },
    },
}

lib公共功能文件夹

encrypt.py提供加密功能

encrypt.py

import hashlib

def encrypt(data):
    md5 = hashlib.md5()
    md5.update(data.encode('utf8'))
    return md5.hexdigest()

if __name__ == '__main__':
    print(encrypt('123'))

get_logger.py提供日志logger对象，用于输出日志

get_logger.py

import logging.config
from conf import log_dict

def get_logger(msg):
    logging.config.dictConfig(log_dict.LOG_DICT)  # 自动加载字典中的配置
    # 自定义分类信息会传给日志字典中'logger'中的空字符串
    logger1 = logging.getLogger(msg)
    # 输出到日志的信息
    return logger1

time_print.py提供了根据时间的不同输出内容不同的功能

time_print.py

import time

def time_print(username):
    import time
    hour = time.localtime()[3]

    if hour < 5:
        print(f'凌晨好， {username}')
    elif hour < 8:
        print(f'早晨好， {username}')
    elif hour < 11:
        print(f'上午好， {username}')
    elif hour < 13:
        print(f'中午好， {username}')
    elif hour < 17:
        print(f'下午好， {username}')
    elif hour < 19:
        print(f'傍晚好， {username}')
    elif hour < 24:
        print(f'晚上好， {username}')

if __name__ == '__main__':
    time_print(1)

db数据文件夹

user文件夹存放用户数据，product文件夹存放商品数据

db_handler.py提供了数据的增删改查功能

db_handler.py

import json
import os
from conf import db_path

# 根据用户名获取用户数据
def get_user_data(username):
    # 获取ATM下的db文件的user文件夹
    user_path = os.path.join(db_path.USER_PATH, '%s.txt' % username)
    # 如果用户名不存在
    if not os.path.isfile(user_path):
        return False
    with open(user_path, 'r', encoding='utf8') as f:
        user_dict = json.load(f)
    return user_dict

# 更新用户数据
def update_user_data(user_dict):
    username = user_dict['username']
    # 获取ATM下的db文件的user文件夹
    user_path = os.path.join(db_path.USER_PATH, '%s.txt' % username)
    with open(user_path, 'w', encoding='utf8') as f:
        json.dump(user_dict, f, ensure_ascii=False)
    return

# 删除用户数据
def remove_user_data(username):
    # 获取ATM下的db文件的user文件夹
    user_path = os.path.join(db_path.USER_PATH, '%s.txt' % username)
    if os.path.isfile(user_path):
        os.remove(user_path)
        return True
    return False

# 获取所有用户字典
def select_all_user():
    # 获取用户名的文本文件
    user_file_list = os.listdir(db_path.USER_PATH)
    # 获取用户名的名字
    user_list = [user.split('.txt')[0] for user in user_file_list]
    return user_list

# 获取商品信息
def select_product():
    # 商品信息路径
    product_path = os.path.join(db_path.PRODUCT_PATH, 'product.txt')
    # 获取商品信息
    with open(product_path, 'r', encoding='utf8') as f:
        product_list = json.load(f)
    return product_list

if __name__ == '__main__':
    print(select_all_user())

interface业务逻辑层文件夹

user_interface.py提供了登录和注册接口

user_interface.py

from db import db_handler
from lib import encrypt, get_logger

# 注册接口
def register_interface(username, password):
    # 判断用户名和密码是否符合条件
    if username == '' or password == '':
        return False, "用户名或密码不能为空！请重新输入..."
    elif db_handler.get_user_data(username):
        return False, "用户名已存在！请重新输入..."
    password = encrypt.encrypt(password)
    # 创建用户对应的文本文件
    temp_dict = {'administrator': 0, 'black': 0,
                 'username': username, 'password': password,
                 'store': {'money': 1000, 'shopping': {}},
                 'ATM': {'money': 1000, 'bill': []}
                 }
    db_handler.update_user_data(temp_dict)
    logger = get_logger.get_logger('用户注册记录')
    logger.info('%s成功注册!!' % username)
    return True, "用户:%s注册成功！" % username

# 登录接口
def login_interface(username, password):
    # 判断用户名和密码是否符合条件
    if username == '' or password == '':
        return False, "用户名或密码不能为空！请重新输入..."
    elif not db_handler.get_user_data(username):
        return False, "用户名不存在！请重新输入..."
    password = encrypt.encrypt(password)
    # 创建用户对应的文本文件
    user_dict = db_handler.get_user_data(username)
    if user_dict['black']:
        return False, "你已被拉黑，无法登录！"
    if username == user_dict['username'] and password == user_dict['password']:
        logger = get_logger.get_logger('用户登录记录')
        logger.info('%s成功登录!!' % username)
        return True, "用户:%s登录成功！" % username
    else:
        return False, "用户名或密码错误！请重新输入..."

if __name__ == '__main__':
    register_interface('asd', '123')

administrator_interface.py提供了管理员操作的接口

administrator_interface.py

from db import db_handler

# 判断用户的管理员权限
def check_administrator_interface(username):
    user_dict = db_handler.get_user_data(username)
    if user_dict:
        if user_dict['administrator']:
            return True

# 获取所有用户名
def select_user_interface():
    # 获取用户名的名字
    user_list = db_handler.select_all_user()
    temp_dict = {}
    for user in user_list:
        user_dict = db_handler.get_user_data(user)
        if user_dict['administrator'] == 1:
            temp_dict[user] = ['管理员', user_dict['black']]
        else:
            temp_dict[user] = ['普通用户', user_dict['black']]

    return temp_dict

# 删除用户
def remove_user_interface(username):
    return db_handler.remove_user_data(username)

# 拉黑用户
def black_user_interface(username):
    user_dict = db_handler.get_user_data(username)
    if user_dict:
        user_dict['black'] = 1
        db_handler.update_user_data(user_dict)
        return True

# 拉白用户
def white_user_interface(username):
    user_dict = db_handler.get_user_data(username)
    if user_dict:
        user_dict['black'] = 0
        db_handler.update_user_data(user_dict)
        return True

bank_interface.py提供了银行操作的接口

bank_interface.py

from db import db_handler

# 查询atm余额
def look_money_interface(username):
    user_dict = db_handler.get_user_data(username)
    return user_dict['ATM']['money']

# 查询用户是否存在的接口
def check_user_interface(username):
    if db_handler.get_user_data(username):
        return True

# 转账
def transfer_accounts(gived_name, received_name, transfer_money):
    if received_name == gived_name:
        return False, '不能给自己转账！'
    # 判断存不存在此用户
    if not db_handler.get_user_data(received_name):
        return False, '用户不存在！请重新输入...'
    # 判断是否纯数字
    if not transfer_money.isdigit():
        return False, '输入格式错误！'
    # 字符串转整型
    transfer_money = int(transfer_money)
    # 获取用户数据
    gived_user_dict = db_handler.get_user_data(gived_name)
    received_user_dict = db_handler.get_user_data(received_name)
    # 判断转账的金额是否超出了转账方的余额
    if transfer_money > gived_user_dict['ATM']['money']:
        return False, '余额不足，转账失败!'
    # 修改双方数据
    gived_user_dict['ATM']['money'] -= transfer_money
    received_user_dict['ATM']['money'] += transfer_money
    # 获取当前时间
    import time
    t = time.strftime("%Y-%m-%d %X")
    # 添加账单
    gived_user_dict['ATM']['bill'].append(f'{t} 你转给了{received_name}金额{transfer_money}')
    received_user_dict['ATM']['bill'].append(f'{t} 收到了来自{gived_name}的转账{transfer_money}')
    # 更新双方数据
    db_handler.update_user_data(gived_user_dict)
    db_handler.update_user_data(received_user_dict)
    return True, gived_user_dict['ATM']['money']

# 账单
def select_bill(username):
    user_dict = db_handler.get_user_data(username)
    return user_dict['ATM']['bill']

# 充值
def put_money_interface(username, money):
    user_dict = db_handler.get_user_data(username)
    money = int(money)
    user_dict['ATM']['money'] += money
    import time
    t = time.strftime("%Y-%m-%d %X")
    user_dict['ATM']['bill'].append(f'{t} 你充值了{money}')
    db_handler.update_user_data(user_dict)
    return user_dict['ATM']['money']

shopping_interface.py提供了购物操作的接口

shopping_interface.py

from db import db_handler

# 获取商品信息接口
def select_product_interface():
    return db_handler.select_product()

# 查询购物车接口
def select_shopping_car_interface(username):
    user_dict = db_handler.get_user_data(username)
    shopping_car_dict = user_dict['store']['shopping']
    return shopping_car_dict

# 更新购物车接口
def update_shopping_car_interface(username, shopping_car_dict):
    user_dict = db_handler.get_user_data(username)
    user_dict['store']['shopping'] = shopping_car_dict
    db_handler.update_user_data(user_dict)
    return True

# 结算购物车
def clear_shopping_car_interface(username, total_money):
    user_dict = db_handler.get_user_data(username)
    # 余额
    user_money = user_dict['store']['money']
    if user_money >= total_money:
        user_dict['store']['shopping'] = {}
        user_dict['store']['money'] -= total_money
        db_handler.update_user_data(user_dict)
        return True, user_dict['store']['money']
    return False, False

# 获取用户余额
def get_user_shopping_money_interface(username):
    user_dict = db_handler.get_user_data(username)
    return user_dict['store']['money']

# 充值购物卡
def put_money_in_shopping_interface(username, money):
    user_dict = db_handler.get_user_data(username)
    # 判断银行卡余额是否足够
    if money > user_dict['ATM']['money']:
        return False, False, False
    # 修改数据
    user_dict['store']['money'] += money
    user_dict['ATM']['money'] -= money
    # 获取当前时间
    import time
    t = time.strftime("%Y-%m-%d %X")
    user_dict['ATM']['bill'].append(f'{t} 向购物卡中充值了{money}')
    db_handler.update_user_data(user_dict)
    return True, user_dict['store']['money'], user_dict['ATM']['money']

# 提现购物卡
def get_money_in_shopping_interface(username, money):
    user_dict = db_handler.get_user_data(username)
    # 判断购物卡余额是否足够
    if money > user_dict['store']['money']:
        return False, False, False
    # 修改数据
    user_dict['store']['money'] -= money
    user_dict['ATM']['money'] += money
    # 获取当前时间
    import time
    t = time.strftime("%Y-%m-%d %X")
    user_dict['ATM']['bill'].append(f'{t} 向购物卡中充值了{money}')
    db_handler.update_user_data(user_dict)
    return True, user_dict['store']['money'], user_dict['ATM']['money']

core表现层文件夹

user.py展示登录注册功能

user.py

from interface import user_interface

def user_login():
    username = input('请输入用户名(输入q退出登录)：').strip()
    # 输入q则退出
    if username == 'q':
        print()
        print("已退出登录".center(30, '-'))
        print()
        return 'q'
    password = input('请输入密码：').strip()

    flag, msg = user_interface.login_interface(username, password)
    if flag:
        print()
        print(msg.center(30, '-'))
        print()
        return username
    else:
        print()
        print(msg.center(30, '-'))
        print()
        return

def user_register():
    username = input('请输入用户名(输入q退出注册)：').strip()
    # 输入q则退出
    if username == 'q':
        print()
        print("已退出注册".center(30, '-'))
        print()
        return 'q'
    password = input('请输入密码：').strip()
    flag, msg = user_interface.register_interface(username, password)
    if flag:
        print()
        print(msg.center(30, '-'))
        print("已自动登录！".center(30, '-'))
        print()
        return username
    else:
        print()
        print(msg.center(30, '-'))
        print()

def register():
    while True:
        res = user_register()
        if res == 'q':
            return None
        elif res:
            return res

def login():
    while True:
        res = user_login()
        if res == 'q':
            return None
        elif res:
            return res

if __name__ == '__main__':
    register()

shopping.py展示购物功能

shopping.py

from interface import shopping_interface
from lib.time_print import time_print

def shopping():
    from core.src import logged_user_name
    # 获取商品信息
    product_list = shopping_interface.select_product_interface()

    # 获取所有商品信息
    def select_product():
        print()
        print('序号'.ljust(3, chr(12288)) +
              '商品名称'.ljust(10, chr(12288)) +
              '商品单价'.ljust(6, chr(12288)))

        for i, product in enumerate(product_list, 1):
            print(str(i).ljust(3, chr(12288)) + chr(12288) +
                  product[0].ljust(10, chr(12288)) +
                  str(product[1]).ljust(6, chr(12288)))
        print()

    # 逛商品
    def go_shopping():
        select_product()
        # 获取购物车内容，临时存储
        temp_shopping_dict = shopping_interface.select_shopping_car_interface(logged_user_name)
        while True:
            get_product_id = input('请选择你要购买的商品序号(输入q结束购物, 输入ls查看商品)：').strip()
            if get_product_id == 'q':
                # 更新购物车
                shopping_interface.update_shopping_car_interface(logged_user_name, temp_shopping_dict)
                print('已返回初始界面！'.center(30, '-'))
                print()
                return
            if get_product_id == 'ls':
                select_product()
                continue
            get_num = input('请输入你要购买的数量：').strip()
            # 判断输入是否是纯数字
            if not get_product_id.isdigit() or not get_num.isdigit():
                print('输入的格式不正确！'.center(30, '-'))
                print()
                continue
            get_product_id = int(get_product_id) - 1
            get_num = int(get_num)
            # 判断商品是否存在
            if get_product_id in range(len(product_list)):
                # product_list: [["挂壁面", 3], ["印度飞饼", 22]]
                product_name = product_list[get_product_id][0]
                product_price = product_list[get_product_id][1]
                # 判断购物车是否有了这个商品
                if product_name in temp_shopping_dict:
                    temp_shopping_dict[product_name][1] += get_num
                else:
                    temp_shopping_dict[product_name] = [product_price, get_num]
                print('添加商品成功！'.center(30, '-'))
                print()
            else:
                print('所选的商品不存在！'.center(30, '-'))
                print()

    # 查询购物车
    def select_shopping_car():
        # 总金额
        total_money = 0
        # 获取用户购物车数据
        temp_shopping_dict = shopping_interface.select_shopping_car_interface(logged_user_name)
        print()
        print('你的购物车'.center(30, '-'))
        print('商品名称'.ljust(10, chr(12288)) +
              '商品数量'.ljust(6, chr(12288)) +
              '商品单价'.ljust(6, chr(12288)))

        # temp_shopping_dict：{'挂壁面': [3, 15], '仿真玩偶': [10000, 1]}
        for i in temp_shopping_dict:
            # 商品名称
            product_name = i
            # 商品数量
            product_num = temp_shopping_dict[product_name][1]
            # 商品单价
            product_price = temp_shopping_dict[product_name][0]
            # 购物车总金额
            total_money += product_num * product_price
            print(product_name.ljust(11, chr(12288)) +
                  str(product_num).ljust(9, ' ') +
                  str(product_price))
        print('总计\t%d'.center(30, '-') % total_money)
        print()
        return temp_shopping_dict, total_money

    # 支付购物车
    def look_shopping_cart():
        # 获取购物车数据和总价格
        temp_shopping_dict, total_money = select_shopping_car()

        while True:
            get_is_clear = input('是否支付(y/n)?:').strip()
            if get_is_clear == 'y':
                flag, money = shopping_interface.clear_shopping_car_interface(logged_user_name, total_money)
                if not flag:
                    print('抱歉！你的余额不足！'.center(30, '-'))
                    print('已退出购物车！'.center(30, '-'))
                    print()
                    return
                else:
                    print('感谢惠顾！你的余额还有：%d'.center(30, '-') % money)
                    print()
                    return
            elif get_is_clear == 'n':
                print('已退出购物车！'.center(30, '-'))
                print()
                return
            else:
                print('请输入正确的指令！'.center(30, '-'))
                print()

    # 查询金额
    def get_money():
        money = shopping_interface.get_user_shopping_money_interface(logged_user_name)
        print()
        print('你的所剩余额：%d'.center(30, '-') % money)
        print()

    # 修改购物车
    def change_shopping_cart():
        print()
        print('修改购物车'.center(30, '-'))
        temp_shopping_dict, total_money = select_shopping_car()

        while True:
            # 获取用户输入
            product_name_input = input('请输入你要修改的商品名称(输入q退出修改)：').strip()
            if product_name_input == 'q':
                print('已退出修改！'.center(30, '-'))
                print()
                return
            product_num_input = input('请输入修改后的商品数量：').strip()

            # 判断输入是否正确
            if not product_num_input.isdigit() or product_name_input == '':
                print('输入格式错误！'.center(30, '-'))
                print()
                continue
            elif product_name_input not in temp_shopping_dict:
                print('你输入的商品不存在！'.center(30, '-'))
                print()
                continue

            # 修改商品数量
            temp_shopping_dict[product_name_input][1] = int(product_num_input)
            print('修改成功！'.center(30, '-'))
            print()

            cmd = input('是否继续修改(y/n)?:')
            if cmd == 'y':
                continue
            elif cmd == 'n':
                shopping_interface.update_shopping_car_interface(logged_user_name, temp_shopping_dict)
                print('已退出修改！'.center(30, '-'))
                print()
                return
            else:
                print('请输入正确的指令！'.center(30, '-'))
                print()

    # 充值金额
    def put_money():
        print()
        print('充值界面'.center(30, '-'))
        while True:
            get_input_money = input('请输入要充值的金额(输入q退出充值)：').strip()
            # 判断是否要退出
            if get_input_money == 'q':
                print('已退出充值！'.center(30, '-'))
                print()
                break
            # 判断是否是纯数字
            if not get_input_money.isdigit():
                print('输入格式错误！'.center(30, '-'))
                print()
                continue
            # 字符串转整型
            get_input_money = int(get_input_money)
            flag, shopping_money, atm_money = shopping_interface.put_money_in_shopping_interface(logged_user_name,
                                                                                                 get_input_money)
            if flag:
                print('充值成功！目前购物余额：%d，银行卡余额：%d'.center(30, '-') % (shopping_money, atm_money))
                print('已退出充值！'.center(30, '-'))
                print()
                break
            print('抱歉！你的银行卡余额不足！'.center(30, '-'))
            print()

    # 提现到银行卡
    def out_to_bank():
        print()
        print('提现界面'.center(30, '-'))
        while True:
            get_output_money = input('请输入要提现的金额(输入q退出提现)：').strip()
            # 判断是否要退出
            if get_output_money == 'q':
                print('已退出提现！'.center(30, '-'))
                print()
                break
            # 判断是否是纯数字
            if not get_output_money.isdigit():
                print('输入格式错误！'.center(30, '-'))
                print()
                continue

            # 字符串转整型
            get_output_money = int(get_output_money)
            flag, shopping_money, atm_money = shopping_interface.get_money_in_shopping_interface(logged_user_name,
                                                                                                 get_output_money)
            # 判断购物卡余额是否足够
            if flag:
                print('提现成功！目前购物余额：%d，银行卡余额：%d'.center(30, '-') % (shopping_money, atm_money))
                print('已退出提现！'.center(30, '-'))
                print()
                break
            print('抱歉！你的购物卡余额不足！'.center(30, '-'))
            print()

    # 初始化
    def init():
        print()
        time_print(logged_user_name)
        print("功能列表".center(15, '*'))
        print("  1.浏览商品")
        print("  2.查看并支付购物车")
        print("  3.修改购物车")
        print("  4.查询金额")
        print("  5.从银行卡充值金额")
        print("  6.提现到银行卡")
        print("  7.退出逛商品")
        print("".center(18, '*'))
        print()

    def quit_system():
        print()
        print("欢迎下次光临！".center(30, '-'))
        print()
        return 'quit'

    # 功能字典
    function_dict = {
        'ls': init,
        '1': go_shopping,
        '2': look_shopping_cart,
        '3': change_shopping_cart,
        '4': get_money,
        '5': put_money,
        '6': out_to_bank,
        '7': quit_system,
    }
    init()
    while True:
        choice = input('请输入你想要执行的功能(输入ls查看功能列表):')
        if choice in function_dict:
            if function_dict[choice]() == 'quit':
                break
        else:
            print('请输入正确指令！'.center(30, '-'))
            print()

if __name__ == '__main__':
    shopping()

bank.py展示银行功能

bank.py

from interface import bank_interface
from lib.time_print import time_print

def bank():
    from core.src import logged_user_name

    # 初始化
    def init():
        print()
        time_print(logged_user_name)
        print("功能列表".center(15, '*'))
        print("  1.查询金额")
        print("  2.转账")
        print("  3.查看账单")
        print("  4.充值")
        print("  5.退出银行")
        print("".center(18, '*'))
        print()

    def quit_system():
        print("欢迎下次光临！".center(30, '-'))
        print()
        return 'quit'

    # 查询金额
    def look_money():
        money = bank_interface.look_money_interface(logged_user_name)
        print()
        print('你的所剩余额：%d'.center(30, '-') % money)
        print()

    # 转账
    def transfer_accounts():
        print()
        print('转账界面'.center(30, '-'))
        while True:
            receive_user = input('请输入收账用户(输入q退出转账)：').strip()
            if receive_user == 'q':
                print()
                print('已退出转账'.center(30, '-'))
                print()
                break
            transfer_money = input('请输入转账金额：').strip()
            flag, msg = bank_interface.transfer_accounts(logged_user_name, receive_user, transfer_money)
            if flag:
                print()
                print('转账成功！你目前余额：%d'.center(30, '-') % msg)
                print('已退出转账'.center(30, '-'))
                print()
                break
            else:
                print()
                print(msg.center(30, '-'))
                print()

    # 查看账单
    def look_bill():
        bill_list = bank_interface.select_bill(logged_user_name)
        print()
        print('账单'.center(30, '-'))
        for i in bill_list:
            print(i)
        print(''.center(35, '-'))
        print()

    # 充值
    def put_money():
        print()
        print('充值界面'.center(30, '-'))
        while True:
            money = input('请输入你要充值的金额(输入q退出充值)：').strip()
            if money == 'q':
                print()
                print('已退出充值！'.center(30, '-'))
                print()
                break
            elif not money.isdigit():
                print()
                print('输入格式错误！'.center(30, '-'))
                print()
                continue
            atm_money = bank_interface.put_money_interface(logged_user_name, money)
            print()
            print('充值成功！你的目前余额：%d'.center(30, '-') % atm_money)
            print()

    # 功能字典
    bank_function_dict = {
        'ls': init,
        '1': look_money,
        '2': transfer_accounts,
        '3': look_bill,
        '4': put_money,
        '5': quit_system,
    }
    init()
    while True:
        choice = input('请输入你想要执行的功能(输入ls查看功能列表):')
        if choice in bank_function_dict:
            if bank_function_dict[choice]() == 'quit':
                break
        else:
            print('请输入正确指令！'.center(30, '-'))
            print()

if __name__ == '__main__':
    bank()

administrator.py展示管理员功能

administrator.py

from lib.time_print import time_print
from interface import administrator_interface

def administrator():
    from core.src import logged_user_name
    if not administrator_interface.check_administrator_interface(logged_user_name):
        print()
        print('你没有此权限！'.center(30, '-'))
        print()
        return

    # 初始化
    def init():
        print()
        time_print(logged_user_name)
        print("功能列表".center(15, '*'))
        print("  1.查看现有用户")
        print("  2.删除指定用户")
        print("  3.拉黑指定用户")
        print("  4.拉白指定用户")
        print("  5.退出管理员操作")
        print("".center(18, '*'))
        print()

    def quit_system():
        print("再见！".center(30, '-'))
        print()
        return 'quit'

    # 查看用户
    def select_user():
        print()
        print('用户类别'.center(8, '-') + '用户名'.center(7, '-') + '是否被拉黑'.center(7, '-'))
        # 获取业务逻辑层返回值
        res_dict = administrator_interface.select_user_interface()
        for res in res_dict:
            print('  ' + res_dict[res][0].ljust(8, chr(12288)), res.ljust(7, chr(12288)), res_dict[res][1])
        print(''.center(20, '-'))
        print()

    # 删除用户
    def remove_user():
        print()
        print('删除用户'.center(30, '-'))
        while True:
            need_remove_username = input('请输入要删除的用户名(输入q退出):').strip()
            # 判断是否输入q
            if need_remove_username == 'q':
                print('已返回初始界面！'.center(30, '-'))
                print()
                return
            # 如果输入的是自己
            if need_remove_username == logged_user_name:
                print()
                print('无法删除自己'.center(30, '-'))
                print()
            # 判断存不存在
            if administrator_interface.remove_user_interface(need_remove_username):
                print()
                print('删除成功，已返回初始界面！'.center(30, '-'))
                print()
                return
            print()
            print('没有此用户！'.center(30, '-'))
            print()

    # 拉黑用户
    def black_user():
        print()
        print('拉黑用户'.center(30, '-'))
        while True:
            need_black_username = input('请输入要拉黑的用户名(输入q退出):').strip()
            # 判断是否输入q
            if need_black_username == 'q':
                print('已返回初始界面！'.center(30, '-'))
                print()
                return
            # 如果输入的是自己
            if need_black_username == logged_user_name:
                print()
                print('无法拉黑自己'.center(30, '-'))
                print()
            # 判断存不存在
            if administrator_interface.black_user_interface(need_black_username):
                print()
                print('拉黑成功，已返回初始界面！'.center(30, '-'))
                print()
                return
            print()
            print('没有此用户！'.center(30, '-'))
            print()

    # 拉黑用户
    def white_user():
        print()
        print('拉白用户'.center(30, '-'))
        while True:
            need_black_username = input('请输入要拉白的用户名(输入q退出):').strip()
            # 判断是否输入q
            if need_black_username == 'q':
                print('已返回初始界面！'.center(30, '-'))
                print()
                return
            # 如果输入的是自己
            if need_black_username == logged_user_name:
                print()
                print('无法拉白自己'.center(30, '-'))
                print()
            # 判断存不存在
            if administrator_interface.white_user_interface(need_black_username):
                print()
                print('拉白成功，已返回初始界面！'.center(30, '-'))
                print()
                return
            print()
            print('没有此用户！'.center(30, '-'))
            print()

    # 功能字典
    bank_function_dict = {
        'ls': init,
        '1': select_user,
        '2': remove_user,
        '3': black_user,
        '4': white_user,
        '5': quit_system,
    }
    init()
    while True:
        choice = input('请输入你想要执行的功能(输入ls查看功能列表):')
        if choice in bank_function_dict:
            if bank_function_dict[choice]() == 'quit':
                break
        else:
            print('请输入正确指令！'.center(30, '-'))
            print()

if __name__ == '__main__':
    administrator()

src.py综合了上述展示功能

src.py

logged_user_name = None

# 登录注册装饰器
def login_register(function_name):
    def inner(*args, **kwargs):
        if logged_user_name:
            function_name(*args, **kwargs)
        else:
            print()
            print('你还未登录！'.center(30, '-'))
            print()

    return inner

# 系统的功能
def user_system():
    from lib.time_print import time_print

    # 初始化
    def init():
        print()
        if logged_user_name:
            time_print(logged_user_name)
        print("功能列表".center(17, '*'))
        print("  1.登录")
        print("  2.注册")
        print("  3.去银行")
        print("  4.逛商场")
        print("  5.切换账号")
        print("  6.管理用户(管理员权限)")
        print("  7.退出")
        print("".center(18, '*'))
        print()

    # 登录功能
    def go_to_login():
        global logged_user_name
        if logged_user_name:
            print()
            print('你已经登录过了！'.center(30, '-'))
            print()
            return
        print()
        print('登录界面'.center(30, '-'))
        print()
        from core import user
        logged_user_name = user.login()

    # 注册功能
    def go_to_register():
        global logged_user_name
        print()
        print('注册界面'.center(30, '-'))
        print()
        from core import user
        res = user.register()
        if res:
            logged_user_name = res

    @login_register
    # 去银行
    def go_to_bank():
        from core import bank
        bank.bank()

    @login_register
    # 购物
    def go_to_shopping():
        from core import shopping
        shopping.shopping()

    @login_register
    # 切换账号
    def change_user():
        global logged_user_name
        print()
        print('切换账号'.center(30, '-'))
        print()
        from core import user
        res = user.login()
        # 判断用户是否切换成功了，防止用户在切换时退出切换账号时返回None
        if res:
            logged_user_name = res
        init()

    @login_register
    # 管理员权限
    def go_to_administrator():
        from core import administrator
        administrator.administrator()

    # 退出系统
    def quit_system():
        print('bye')
        return 'quit'

    # 功能字典
    function_dict = {
        'ls': init,
        '1': go_to_login,
        '2': go_to_register,
        '3': go_to_bank,
        '4': go_to_shopping,
        '5': change_user,
        '6': go_to_administrator,
        '7': quit_system,
    }

    while True:
        # 先打印以下功能列表
        init()
        get_choice = input('请输入你要去的地方(输入ls可以查看)：')
        if get_choice in function_dict:
            if function_dict[get_choice]() == 'quit':
                break
        else:
            print()
            print('请输入正确的指令！'.center(30, '-'))
            print()

if __name__ == '__main__':
    user_system()

测试

目前管理员账号：'zbh' 密码：'123'，想要变成管理员可以到用户文本文件把'administrator'属性改成1

运行run.py文件。

最外层功能(src.py)

运行run.py首先出现的页面

如果这时候还没有登录，就输入3、4、5、6，就会提醒未登录

这时候看不到功能列表了，没关系，输入ls就可以查看功能列表了

先输入2进入注册功能

如果不想注册，可以输入q退出

回到注册页面，输入的账号密码如果有一个为空，或是用户已存在，都会提醒你，注册成功则会帮你自动登录

注意到了吗，你登录后，功能列表会根据时间向你问好。

登录后如果再次输入1，会提醒你

在已登录状态下在去注册一个账号，会顶替掉当前已登录账号

输入5也可以切换账号哦

银行的功能(bank.py)

在最外层的界面输入3就可以来到银行了

输入1查询银行卡余额

输入2可以给其他用户转钱，收账的用户不存在提醒你

如果你转账的钱超出了你的余额，也会提醒你

忘记有哪些功能了？输入ls查看一下

输入3查看一下账单，可以看到我们刚刚转的钱被记录了，在收账方的用户也会有记录

输入4往银行卡里充值，充值完了记得按q退出

输入5从银行卡提点钱出来，提现完了记得按q退出

这时候我们再去看一下账单，输入3

输入6退出银行，再输入ls查看功能

购物功能(shopping.py)

在最外层界面输入4去购物

输入1浏览商品，可以一直添加商品直到输入q退出，格式不对会提醒你

输入ls看一下功能

输入3修改购物车里的商品数量，需要输入商品名称更改(忘记搞序号了)，在输入数量就可以修改了，格式不对会提醒你，修改完后你可以选择是否继续修改，输入n回到功能列表界面

回到功能列表界面后输入4查看购物车的余额

输入2查看购物车，并可以自行选择是否结算购物车

这时候我们输入y钱是不够的

输入5从银行卡里拿点钱出来

输入4看一下现在的购物余额

现在可以结算购物车了，输入2，再输入y

这时候购物车就空了

我们把剩下的钱在提现回银行卡，输入6

最后输入7返回最外层的界面

我们输入3到银行再去看一下账单

管理员功能(administrator.py)

由于小功能太多，不想加上添加管理员的功能了，想要变成管理员可以到用户文本文件把'administrator'属性改成1

最外层界面输入6进入管理用户界面，需要管理员权限，权限不够会提醒你

输入1查看用户信息

输入3拉黑用户，用户不存在会提醒你，拉黑自己也会提醒你“不能拉黑自己”

输入1查看一下是否被拉黑了

输入4可以把他从黑名单移除

输入2可以删除用户，移除文本文件

输入5回到最外层界面

结束

完成啦