• python从入门到实践：项目1-ATM取款机（完成代码）

    目录

    一、项目视图分析

    二、文件结构分析

    三、完整代码

    1.start.py

    2.conf

    -settings.py

    3.core

    -src.py

    -admin.py

    4.interface

     -user_interface.py

    -shop_interface.py

    -bank_interface.py

    -admin_interface.py

    5.db

    -db_handler.py

    6.lib

    -common.py

    7.log

    8.readme

    一、项目视图分析

    通过上图，我们可以看到，一个完整的项目，基本包括三个部分：用户视图层、接口层、数据处理层，其中，用户视图层是用来接收用户的数据输入的，比如：有户名，密码；接口层是要接收用户视图层传来的数据，然后做判断：名字是否存在、密码是否正确，这就要求接口层调用数据处理层的方法；数据处理层就需要接收接口层的参数，把接口层需要的增、删、改、查的数据结果返回给接口层，接口层再把判断的结果返回给用户层。

    二、文件结构分析

    文件主要有以下几个部分：conf（setting.py-参数配置，比如：日志文件的配置、路径等）、core（src.py\admin.py-用户视图层，分为图通用户和管理员）、interface（接口层，里面有很多接口：用户接口，购物接口，银行接口，管理员接口，分这么细是为了“解耦合”）、db（用户数据存放；数据处理层：主要负责数据的增、删、改、查）、lib（公共方法：比如登录功能的装饰器）、log（日志文件）、readme（文档说明）、strat启动

    三、完整代码

    1.start.py

    1. # -*- coding: utf-8 -*-
    2.  
    3. '''
    4. @Time    : 2022/09/02 14:59
    5. @Author  : Rice
    6. @CSDN : C_小米同学
    7. @FileName: start.py
    8. '''
    9. '''
    10. 程序的入口
    11. '''
    12. import sys
    13. import os
    14.  
    15. #添加解释器的环境变量
    16. sys.path.append(
    17.     os.path.dirname(__file__)
    18. )
    19.  
    20. #导入用户视图层
    21. from core import src
    22. # 开始执行项目函数
    23.  
    24. if __name__ == '__main__':
    25.     # 1.先执行用户视图层
    26.     src.run()

    2.conf

    -settings.py

    1. # -*- coding: utf-8 -*-
    2.  
    3. '''
    4. @Time    : 2022/09/02 14:49
    5. @Author  : Rice
    6. @CSDN : C_小米同学
    7. @FileName: settings.py
    8. '''
    9. '''
    10. 存放配置信息
    11. '''
    12. import os
    13.  
    14. #获取项目根目录路劲
    15. BASE_PATH = os.path.dirname(
    16.     os.path.dirname(__file__)
    17. )
    18.  
    19. # 获取user_data文件夹目录路径
    20. USER_DATA_PATH = os.path.abspath(os.path.join(BASE_PATH, 'db','user_data'))
    21. #USER_DATA_PATH2 = os.path.join(BASE_PATH, 'db','user_data').replace('\\','/')
    22. username = 'rice'
    23. user_path = os.path.abspath(os.path.join(USER_DATA_PATH, f'{username}.json')).replace('\\','/')
    24.  
    25. """
    26. logging配置
    27. """
    28. BASE_PATH2 = os.path.dirname(os.path.dirname(__file__))
    29. logfile_dir = os.path.abspath(os.path.join(BASE_PATH2,'log')).replace('\\','/')
    30. logfile_name = 'atm.log'
    31.  
    32. #如果不存在定义的日志目录就创建一个
    33. if not os.path.isdir(logfile_dir):
    34.     os.mkdir(logfile_dir)
    35.  
    36. #log文件的全路径
    37. logfile_path = os.path.join(logfile_dir, logfile_name).replace('\\','/')
    38.  
    39. standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
    40.                   '[%(levelname)s][%(message)s]'
    41.  
    42. simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
    43.  
    44. test_format = '%(asctime)s] %(message)s'
    45.  
    46. # 3、日志配置字典
    47. LOGGING_DIC = {
    48.     'version': 1,
    49.     'disable_existing_loggers': False,
    50.     'formatters': {
    51.         'standard': {
    52.             'format': standard_format
    53.         },
    54.         'simple': {
    55.             'format': simple_format
    56.         },
    57.     },
    58.     'filters': {},
    59.     'handlers': {
    60.         # 打印到终端的日志
    61.         'console': {
    62.             'level': 'DEBUG',
    63.             'class': 'logging.StreamHandler',  # 打印到屏幕
    64.             'formatter': 'simple'
    65.         },
    66.         # 打印到文件的日志,收集info及以上的日志
    67.         'default': {
    68.             'level': 'DEBUG',
    69.             'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件,日志轮转
    70.             'formatter': 'simple',
    71.             # 可以定制日志文件路径
    72.             # BASE_DIR = os.path.dirname(os.path.abspath(__file__))  # log文件的目录
    73.             # LOG_PATH = os.path.join(BASE_DIR,'a1.log')
    74.             'filename': logfile_path,  # 日志文件
    75.             'maxBytes': 1024 * 1024 * 5,  # 日志大小 5M
    76.             'backupCount': 5,
    77.             'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了
    78.         },
    79.     },
    80.     'loggers': {
    81.         # logging.getLogger(__name__)拿到的logger配置
    82.         '': {
    83.             'handlers': ['default', 'console'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
    84.             'level': 'DEBUG',  # loggers(第一层日志级别关限制)--->handlers(第二层日志级别关卡限制)
    85.             'propagate': True,  # 默认为True，向上（更高level的logger）传递，通常设置为False即可，否则会一份日志向上层层传递
    86.         },
    87.     },
    88. }
    89.  
    90.  
    91.  
    92. if __name__ == '__main__':
    93.  
    94.     print(user_path)

    3.core

    -src.py 

    1. # -*- coding: utf-8 -*-
    2.  
    3. '''
    4. @Time    : 2022/09/02 14:51
    5. @Author  : Rice
    6. @CSDN : C_小米同学
    7. @FileName: src.py
    8. '''
    9. '''
    10. 用户视图层
    11. '''
    12.  
    13. from interface import user_interface
    14. from lib import common
    15. from interface import bank_interface
    16. from interface import shop_interface
    17.  
    18. #全局变量，记录用户是否已登录
    19. login_user = None
    20.  
    21. # 1.注册功能
    22. def register():
    23.     while True:
    24.         # 1）让用户输入用户名和密码校验
    25.         username = input('请输入用户名：').strip()
    26.         password = input('请输入密码：').strip()
    27.         re_password = input('请确认密码：').strip()
    28.         #可以输入自定义的金额
    29.  
    30.         # 小的逻辑错误：比如两次密码是否一致
    31.         if password == re_password:
    32.             #2)调用接口层的注册接口，将用户名与密码交给接口层来进行处理
    33.  
    34.             #一个元祖
    35.             flag, msg = user_interface.register_interface(username, password)
    36.  
    37.  
    38.             # 3）根据flag判断用户注册是否成功,用于控制break
    39.             if flag:
    40.                 print(msg)
    41.                 break
    42.             else:
    43.                 print(msg)
    44.  
    45. # 2.登录功能
    46. #成功登录了之后，一定会修改全局变量：login_user
    47. def login():
    48.     #登录视图
    49.     while True:
    50.         #1)让用户输入用户名和密码
    51.         username = input('请输入用户名：').strip()
    52.         password = input('请输入密码：').strip()
    53.  
    54.         #2)调用接口层，将数据传给登录接口
    55.         flag, msg = user_interface.login_interface(username, password)
    56.         if flag:
    57.             print(msg)
    58.             global login_user
    59.             login_user = username
    60.             break
    61.         else:
    62.             print(msg)  #有一个小bug，输入错误后，我想返回主页  #d  #成功登录了#
    63.  
    64.  
    65. # 3.查看余额
    66. @common.login_auth
    67. def check_balance():
    68.     #1.直接调用查看余额接口，获取用户余额
    69.     #装饰器本身是有login_user
    70.     balance = user_interface.check_bal_interface(login_user)
    71.     print(f'用户{login_user} 账户余额为:{balance}')
    72.  
    73. # 4.提现功能
    74. @common.login_auth
    75. def withdraw():
    76.     while True:
    77.         #1)让用户输入提现金额
    78.         input_money = input('请输入提现金额：').strip()
    79.  
    80.         #2)判断用户输入的金额是否是数字
    81.         if not input_money.isdigit(): #isdigit()-可以判断字符串
    82.             print('请输入')
    83.             continue
    84.         #3)用户提现金额，将数据提现的金额交给接口层处理
    85.         flag, msg = bank_interface.withdraw_interface(login_user, input_money)
    86.         if flag:
    87.             print(msg)
    88.             break
    89.  
    90. # 5.还款功能
    91. @common.login_auth
    92. def repay():
    93.     '''
    94.     银行卡还款,无论是信用卡或储蓄卡,是否能任意大小的金额
    96.     :return:
    97.     '''
    98.     while True:
    99.         #1） 让用户输入还款金额
    100.         input_money = input('请输入需要还款的金额：').strip()
    101.         #2）判断用户输入的是否是数字
    102.         if not input_money.isdigit():
    103.             print('请输入正确的金额')
    104.             continue
    105.         input_money = int(input_money)
    106.         #3)判断用户输入的金额大于0
    107.         if input_money > 0:
    108.             #4)调用还款接口
    109.             flag, msg = bank_interface.repay_interface(login_user, input_money)
    110.             if flag:
    111.                 print(msg)
    112.                 break
    113.         else:
    114.             print('输入的金额不能小于0')
    115.  
    116. # 6.转账功能
    117. @common.login_auth
    118. def transfer():
    119.     '''
    120.     1.接收 用户输入的 转账金额
    121.     2.接收用户输入的 转账目标用户
    122.     :return:
    123.     '''
    124.     while True:
    125.  
    126.         #1) 让用户输入转账用户与金额
    127.         to_user = input('请输入转账目标用户').strip()
    128.         money = input('请输入转账金额').strip()
    129.  
    130.         #2）数据判断
    131.         if not money.isdigit():
    132.             print('请输入数字')
    133.             continue
    134.         money = int(money)
    135.         if money > 0:
    136.             #调用转账接口
    137.             flag, msg = bank_interface.transfer_interface(
    138.                 login_user,to_user,money
    139.             )
    140.             if flag:
    141.                 print(msg)
    142.                 break
    143.             else:
    144.                 print(msg)
    145.         else:
    146.             print('请输入正确的金额')
    147.  
    148. # 7.查看流水
    149. @common.login_auth
    150. def check_flow():
    151.     #直接调用查看流水接口
    152.     flow_list = bank_interface.check_flow_interface(login_user)
    153.     if flow_list:
    154.         for flow in flow_list:
    155.             print(flow)
    156.     else:
    157.         print('当前用户没有流水！')
    158.  
    159. # 8.购物功能
    160. @common.login_auth
    161. def shop():
    162.     #不从文件中读取商品数据，直接写
    163.     #创建商品列表
    164.     # shop_list = {
    165.     #     '0': {'name': '包子', 'price': 30}
    166.     # }
    167.     shop_list = [
    168.         ['包子',  3], #0
    169.         ['可乐', 5], #1
    170.         ['book', 200],
    171.         ['pc', 9999],
    172.     ]
    173.     #初始化当前购物车
    174.     shopping_car = {}  #{'商品名称'：['单价','数量']]}
    175.     while True:
    176.         #枚举：enumerate(可迭代对象)--->元祖（可迭代对象的索引，索引对应的值）
    177.         for index, shop in enumerate(shop_list):
    178.             shop_name, shop_price = shop
    179.             print(f'商品编号为{index}, 商品名称{shop_name}, 商品单价：{shop_price}')
    180.             print(shop)
    181.         choice = input('请输入商品编号：（是否结账输入y or n）').strip()
    182.         #让用户根据商品编号进行选择
    183.  
    184.         #输入的是y进行支付结算功能
    185.         if choice == 'y':
    186.             if not shopping_car:
    187.                 print('购物车是空的，不能支付，请重新输入')
    188.                 continue
    189.             #调用支付接口进行支付
    190.             flag, msg = shop_interface.shopping_interface(login_user,shopping_car)
    191.             if flag:
    192.                 print(msg)
    193.                 break
    194.             else:
    195.                 print(msg)
    196.         #输入的是n添加购物车(把shopping_car添加到json中)
    197.         elif choice == 'n':
    198.             #调用添加购物车接口
    199.             if not shopping_car:
    200.                 print('购物车是空的，不能添加，请重新输入')
    201.                 continue
    202.             flag, msg = shop_interface.add_shop_car_interface(login_user, shopping_car)
    203.             if flag:
    204.                 print(msg)
    205.                 break
    206.             else:
    207.                 print(msg)
    208.         if not choice.isdigit():
    209.             print('请输入正确的编号！')
    210.             continue
    211.  
    212.  
    213.         if not choice.isdigit():
    214.             print('请输入正确的编号！')
    215.             continue
    216.         choice = int(choice)
    217.  
    218.         if choice not in range(len(shop_list)):
    219.             print('请输入正确的编号！')
    220.             continue
    221.         shop_name, shop_price = shop_list[choice]
    222.  
    223.         #加入购物车
    224.         #判断用户选择的商品是否重复，重复加1
    225.         if shop_name in shopping_car:
    226.             #添加商品数量
    227.             shopping_car[shop_name][1] += 1
    228.         else:
    229.             #否则数量默认为1
    230.             shopping_car[shop_name] = [shop_price, 1]
    231.  
    232. # 9.查看购物车
    233. @common.login_auth
    234. def check_shop_car():
    235.     shop_car = shop_interface.check_shop_car_interface(login_user)
    236.     print(shop_car)
    237.  
    238.  
    239. # 10.管理员功能
    240. @common.login_auth
    241. def admin():
    242.     '''
    243.     管理员功能：课后作业
    244.     :return:
    245.     '''
    246.     from core import admin
    247.     admin.admin_run()
    248.  
    249.  
    250.  
    251.  
    252. # 创建函数功能字典
    253. func_dic = {
    254.     '1': register,
    255.     '2': login,
    256.     '3': check_balance,
    257.     '4': withdraw,
    258.     '5': repay,
    259.     '6': transfer,
    260.     '7': check_flow,
    261.     '8': shop,
    262.     '9': check_shop_car,
    263.     '10': admin
    264. }
    265.  
    266. # 视图层主程序
    267. def run():
    268.     while True:
    269.         print('''
    270.         ======= ATM + 购物车 =======
    271.             1.注册功能
    272.             2.登录功能
    273.             3.查看余额
    274.             4.提现功能
    275.             5.还款功能
    276.             6.转账功能
    277.             7.查看流水
    278.             8.购物功能
    279.             9.查看购物车
    280.             10.管理员功能
    281.         ========== end ============
    282.         ''')
    283.         choice = input('请输入功能编号：').strip()
    284.         if choice not in func_dic:
    285.             print('请输入正确的功能编号！')
    286.             continue
    287.         func_dic.get(choice)()

    -admin.py

    1. # -*- coding: utf-8 -*-
    2.  
    3. '''
    4. @Time    : 2022/09/04 11:50
    5. @Author  : Rice
    6. @CSDN : C_小米同学
    7. @FileName: admin.py
    8. '''
    9. from core import src
    10. from interface import admin_interface
    11. # 添加用户
    12. def add_user():
    13.     src.register()
    14.  
    15.  
    16. # 修改用户额度
    17. def change_balance():
    18.     while True:
    19.         change_user = input('请输入需要修改额度的用户').strip()
    20.  
    21.         money = input('请输入需要修改的用户额度：').strip()
    22.         if not money.isdigit():
    23.             print('请输入数字')
    24.             continue
    25.  
    26.         flag, msg = admin_interface.change_balance_interface(change_user, money)
    27.         if flag:
    28.             print(msg)
    29.             break
    30.         else:
    31.             print(msg)
    32.             break
    33.  
    34.  
    35. # 输入修改额度
    36. # 输入修改用户
    37. # 调用修改额度接口
    38.  
    39. # 冻结账户
    40. def lock_user():
    41.     while True:
    42.         change_user = input('请输入需要修改额度的用户：').strip()
    43.  
    44.         flag, msg = admin_interface.lock_user_interface(change_user)
    45.         if flag:
    46.             print(msg)
    47.             break
    48.         else:
    49.             print(msg)
    50.             break
    51.  
    52.  
    53. # 管理员功能字典
    54. admin_dic = {
    55.     '1': add_user,
    56.     '2': change_balance,
    57.     '3': lock_user
    58. }
    59.  
    60.  
    61. def admin_run():
    62.     while True:
    63.         print('''
    64.            1、添加用户
    65.            2、修改额度
    66.            3、冻结账户
    67.            ''')
    68.         choice = input('请输入管理员功能编号：').strip()
    69.  
    70.         # 判断功能编号是否存在
    71.         if choice not in admin_dic:
    72.             print('请输入正确的功能编号！')
    73.             continue
    74.  
    75.         # 调用用于选择的功能函数
    76.         admin_dic.get(choice)()

    4.interface

     -user_interface.py

    1. # -*- coding: utf-8 -*-
    2.  
    3. '''
    4. @Time    : 2022/09/02 14:52
    5. @Author  : Rice
    6. @CSDN : C_小米同学
    7. @FileName: user_interface.py
    8. '''
    9. '''
    10. 逻辑接口层
    11.     用户接口
    12. '''
    13.  
    14. import json
    15. import os
    16. from conf import settings
    17. from db import db_handler
    18. from lib import common
    19. user_logger = common.get_logger('user')
    20. #user_logger.setLevel(10)
    21. #注册接口
    22. def register_interface(username, password, balance=5000):
    23.     # 2）查看用户是否存在
    24.     #2.1)调用 数据处理层中的select函数，会返回用户字典或None
    25.     user_dic = db_handler.select(username)
    26.  
    27.     #若用户存在，则return，告诉用户重新输入(是通过用户名来判断是否存在的，跟密码没关系)
    28.     if user_dic:
    29.         return False, '用户名已存在！'
    30.  
    31.     #3)用户不存在，则保存用户数据
    32.     #做密码加密
    33.     password = common.get_pwd_md5(password)
    34.     user_dic = {
    35.         'username': username,
    36.         'password': password,
    37.         'balance': balance,
    38.         # 用于记录用户流水的列表
    39.         'flow': [],
    40.         # 用于记录用户购物车
    41.         'shop_car': {},
    42.         # locked: 用于记录用户是否被冻结
    43.         # False:未冻结 True：已冻结
    44.         'locked': False
    45.     }
    46.  
    47.     #3.2）保存数据
    48.  
    49.     db_handler.save(user_dic)
    50.     msg = f'{username} 用户注册成功'
    51.     #记录日志
    52.     user_logger.info(msg)
    53.     return True, msg
    54.  
    55. #登录接口
    56. def login_interface(username, password):
    57.  
    58.     #1)先查看当前用户数据是否存在
    59.  
    60.     user_dic = db_handler.select(username)
    61.     #2)判断用户是否存在
    62.  
    63.     #若有冻结用户，则需要判断是否被锁定
    64.  
    65.     if user_dic:
    66.         if user_dic.get('locked'):
    67.             return False, '当前用户已被锁定'
    68.         #给用户输入的密码做一次加密
    69.         password = common.get_pwd_md5(password)
    70.         #3)校验密码是否一致
    71.         if password == user_dic.get('password'):
    72.             msg = f'用户{username}登录成功!'
    73.             user_logger.info(msg)
    74.             return True, msg
    75.         else:
    76.             msg = f'用户{username}密码错误!'
    77.             user_logger.warn(msg)
    78.             return False, msg
    79.     msg = f'用户{username}不存在!'
    80.     user_logger.warn(msg)
    81.     return False, msg
    82.  
    83. #查看余额接口
    84. def check_bal_interface(username):
    85.     user_dic = db_handler.select(username)
    86.     return user_dic['balance']

    -shop_interface.py

    1. # -*- coding: utf-8 -*-
    2.  
    3. '''
    4. @Time    : 2022/09/02 14:53
    5. @Author  : Rice
    6. @CSDN : C_小米同学
    7. @FileName: shop_interface.py
    8. '''
    9. '''
    10. 商城购物接口层
    11. '''
    12. from db import db_handler
    13. #商品准备结算接口
    14. def shopping_interface(login_user, shopping_car):
    15.     #计算消费金额
    16.     cost = 0
    17.     for price_number in shopping_car.values():
    18.         price, number = price_number
    19.         cost += (price*number)
    20.     #导入银行接口
    21.     from interface import bank_interface
    22.  
    23.     #逻辑校验成功后，在调用银行支付接口
    24.     flag = bank_interface.pay_interface(login_user,cost)
    25.     if flag:
    26.         return True, '支付成功，准备发货'
    27.     return False, '支付失败，金额不足'
    28.  
    29. #购物车添加接口
    30. def add_shop_car_interface(login_user, shopping_car):
    31.  
    32.     #获取当前用户的购物车
    33.     user_dic = db_handler.select(login_user)
    34.  
    35.     shop_car = user_dic.get('shop_car')
    36.     #添加购物车
    37.     for shop_name, price_number in shopping_car.items():
    38.         #每个商品的数量
    39.         number = price_number[1]
    40.         if shop_name in shop_car:
    41.             user_dic['shop_car'][shop_name] += number
    42.             db_handler.save(user_dic)
    43.             print('添加到json成功')
    44.         else:
    45.             user_dic['shop_car'].update({shop_name: price_number})
    46.             db_handler.save(user_dic)
    47.             print('添加到json成功')
    48.  
    49.  
    50.     return True, '添加购物车成功'
    51.  
    52. #查看购物车接口
    53. def check_shop_car_interface(username):
    54.     user_dic = db_handler.select(username)
    55.     return user_dic.get('shop_car')

    -bank_interface.py

    1. # -*- coding: utf-8 -*-
    2.  
    3. '''
    4. @Time    : 2022/09/02 14:53
    5. @Author  : Rice
    6. @CSDN : C_小米同学
    7. @FileName: bank_interface.py
    8. '''
    9. '''
    10. 银行先关业务的接口
    11. '''
    12. from db import db_handler
    13. #提现接口(手续费5%)
    14. def withdraw_interface(username, money):
    15.     #1)先获取用户字典
    16.     user_dic = db_handler.select(username)
    17.     #校验用户的钱是否足够
    18.     balance = int(user_dic.get('balance'))
    19.  
    20.     #本金+手续费
    21.     momey2 = int(money) * 1.05  #money是str，用int类型转换
    22.  
    23.     #判断用户金额是否足够
    24.     if balance >= momey2:
    25.  
    26.     #2）修改用户字典中的金额
    27.         balance -= momey2
    28.         user_dic['balance'] = balance
    29.  
    30.         #记录流水
    31.         flow = f'用户{username} 提现金额{money}成功，手续费是：{momey2 - float(money)}$ 剩余{balance}'
    32.         user_dic['flow'].append(flow)
    33.     #3）再保存数据，或更新数据
    34.         db_handler.save(user_dic)
    35.         # money是str，用int类型转换
    36.         return True, flow
    37.  
    38. def repay_interface(username, money):
    39.     '''
    40.     1.获取用户的金额
    41.     2.给用户加钱操作
    42.     :param username:
    43.     :param money:
    44.     :return:
    45.     '''
    46.     #1.获取用户字典
    47.     user_dic = db_handler.select(username)
    48.  
    49.     #2.直接做加钱的操作
    50.     user_dic['balance'] += money
    51.  
    52.     #记录流水
    53.     flow = f'用户{username} 还款{money}成功！ 当前额度为{user_dic["balance"]}'
    54.     user_dic['flow'].append(flow)
    55.     #3.调用数据处理层，将修改后的数据进行更新
    56.     db_handler.save(user_dic)
    57.     return True, flow
    58.  
    59. def transfer_interface(login_user, to_user, money):
    60.     '''
    61.     1.获取'当前用户' 数据
    62.     2.获取'目标用户' 数据
    63.     3.获取转账金额
    64.     :return:
    65.     '''
    66.     login_user_dic = db_handler.select(login_user)
    67.  
    68.     to_user_dic = db_handler.select(to_user)
    69.  
    70.     if not to_user_dic:
    71.         return False, '目标用户不存在'
    72.  
    73.     #4）若用户存在，则判断'当前用户的转账金额' 是足够的
    74.     if login_user_dic['balance'] >= money:
    75.          login_user_dic['balance'] -= money
    76.          to_user_dic['balance'] += money
    77.          #当前用户流水
    78.          login_user_flow = f'用户{login_user} 给用户 {to_user} 转账 {money}$ 成功'
    79.          login_user_dic['balance'].append(login_user_flow)
    80.  
    81.          #目标用户流水
    82.          to_user_flow = f'用户{to_user} 给用户 {login_user} 转账 {money}$ 成功'
    83.          to_user_dic['flow'].append(to_user_flow)
    84.          #调用数据处理层，保存数据
    85.          db_handler.save(login_user_dic)
    86.          db_handler.save(to_user_dic)
    87.  
    88.          return True, login_user_flow
    89.     return False, '当前用户转账金额不足'
    90.  
    91. def check_flow_interface(login_user):
    92.     user_dic = db_handler.select(login_user)
    93.     return user_dic.get('flow')
    94.  
    95. #支付接口
    96.  
    97. def pay_interface(login_user, cost):
    98.     user_dic = db_handler.select(login_user)
    99.  
    100.     #判断用户金额
    101.     if user_dic.get('balance') >= cost:
    102.         user_dic['balance'] -= cost
    103.         flow = f'用户消费金额:{cost}$'
    104.         user_dic['flow'].append(flow)
    105.  
    106.         #保存数据
    107.         db_handler.save(user_dic)
    108.         return True
    109.     return False

    -admin_interface.py

    1. # -*- coding: utf-8 -*-
    2.  
    3. '''
    4. @Time    : 2022/09/04 12:39
    5. @Author  : Rice
    6. @CSDN : C_小米同学
    7. @FileName: admin_interface.py
    8. '''
    9.  
    10. from db import db_handler
    11. from lib import common
    12. admin_logger = common.get_logger('admin')
    13. #修改额度接口
    14. def change_balance_interface(username, money):
    15.     user_dic = db_handler.select(username)
    16.  
    17.     if user_dic:
    18.         #修改额度
    19.         user_dic['balance'] = int(money)
    20.  
    21.         db_handler.save(user_dic)
    22.         msg = f'管理员修改用户：{username}额度修改成功'
    23.         admin_logger.info(msg)
    24.         return True, '额度修改成功！'
    25.     return False, '修改额度用户不存在'
    26.  
    27. #冻结账户接口
    28.  
    29. def lock_user_interface(username):
    30.     user_dic = db_handler.select(username)
    31.     if user_dic:
    32.         user_dic['locked'] = True
    33.         db_handler.save(user_dic)
    34.  
    35.         return True, f'用户{username}冻结成功'
    36.     return False, '冻结用户不存在'

    5.db

    -db_handler.py

    1. # -*- coding: utf-8 -*-
    2.  
    3. '''
    4. @Time    : 2022/09/02 14:57
    5. @Author  : Rice
    6. @CSDN : C_小米同学
    7. @FileName: db_handler.py
    8. '''
    9. '''
    10. 数据处理层
    11.     -专门用户处理数据
    12. '''
    13. import json
    14. import os
    15. from conf import settings
    16.  
    17.  
    18. #查看数据
    19. def select(username):
    20.  
    21.     #1)接收接口层传过来的username用户名，拼接用户json文件路劲
    22.     user_path = os.path.abspath(os.path.join(settings.USER_DATA_PATH, f'{username}.json')).replace('\\', '/')
    23.     #2）校验用户json文件是否存在
    24.     if os.path.exists(user_path):
    25.         #3）打开数据，并返回给接口层
    26.         with open(user_path, 'r', encoding='utf-8') as f:
    27.             user_dic = json.load(f)  # 导出数据
    28.             return user_dic
    29.     #3）不return，默认返回return None
    30.  
    31. #保存数据
    32. def save(user_dic):
    33.     #1）拼接用户的数据字典
    34.     username = user_dic.get('username')
    35.     user_path = os.path.abspath(os.path.join(settings.USER_DATA_PATH, f'{username}.json')).replace('\\', '/')
    36.     #2）保存用户数据
    37.     with open(user_path, 'w', encoding='utf-8') as f:
    38.         # 导入数据(ensure_ascii=False,让文件中的中文数据显示更美观)
    39.         json.dump(user_dic, f, ensure_ascii=False)

    6.lib

    -common.py

    1. # -*- coding: utf-8 -*-
    2.  
    3. '''
    4. @Time    : 2022/09/02 14:50
    5. @Author  : Rice
    6. @CSDN : C_小米同学
    7. @FileName: common.py
    8. '''
    9. '''
    10. 存放公共方法
    11. '''
    12.  
    13. import hashlib
    14. import logging.config
    15. from conf import settings
    16.  
    17. def get_pwd_md5(password):
    18.     md5_obj = hashlib.md5()
    19.     md5_obj.update(password.encode('utf-8')) #传入的数据需要时"字节串"
    20.     salt = 'rice这是一个ATM'
    21.     md5_obj.update(salt.encode('utf-8'))
    22.     return md5_obj.hexdigest()
    23.  
    24. #登录认证装饰器
    25. def login_auth(func):
    26.     from core import src
    27.  
    28.     def inner(*args, **kwargs):
    29.         if src.login_user:
    30.             res = func(* args, ** kwargs)
    31.             return res
    32.         else:
    33.             print('使用功能前，请先登录')
    34.             src.login()
    35.     return inner
    36.  
    37. #添加日子功能:（日志功能在接口层使用）
    38.  
    39.  
    40. #获取日志功能
    41. #获取日志对象
    42. def get_logger(log_type):
    43.     '''
    45.     :param log_type: 比如是user日子，bank日子，购物商城日志
    46.     :return:
    47.     '''
    48.     #1、加载日志配置信息
    49.     logging.config.dictConfig(settings.LOGGING_DIC)
    50.     #2、获取日志对象
    51.     logger = logging.getLogger(log_type)
    52.     return logger

    7.log

    8.readme

    # 项目说明书
## 项目：ATM + 购物车

# 项目需求
    模拟实现一个ATM + 购物商城程序

        1.额度 15000或自定义 ->注册功能
        2.实现购物商城，买东西加入 购物车，调用信用卡接口结账-》购物、支付
        3.可以提现，手续费5%-》提现功能
        4.支持多账户登录-》登录功能
        5.支持账户间转账  -》转账功能
        6.记录日常消费流水-》记录流水功能
        7.提供还款接口  -》还款功能
        8.ATM记录操作日志 —》记录日志功能
        9.提供管理接口，包括添加账户、用户额度，冻结账户等。。。-》管理员功能
        10.用户认证用装饰器-》登录认证装饰器

## "用户视图层"展示给用户选择的功能
    1.注册功能
    2.登录功能
    3.查看余额
    4.提现功能
    5.还款功能
    6.转账功能
    7.查看流水
    8.购物功能
    9.查看购物车
    10.管理员功能
   

# 一个项目如何从无到有
## 一 需求分析
    1.拿到项目，想在客户那里讨论需求
    商量项目的功能能否实现，周期，价格，得到需求文档
    2.最后在公司内部需要开一次会议，得到最终的开发文档，
    交给不同的岗位的程序员进行开发
        -Python:后端，爬虫
        -不同的岗位：
            -UI界面设计：
                -设计软件的布局，会根据软件的外观切成一张张图片
            -前端：
                -拿到UI交给他的图片，去搭建网页页面
                -设计一些页面中，哪些位置需要接收数据，需要进行数据交互
            -后端：
                -直接核心的业务逻辑，调度数据库进行数据的增删
            -测试：
                -会给代码进行全面测试，比如压力测试，界面测试
            -运维
                -部署项目
## 二 程序的架构设计
### 1、程序设计的好处
    1）思路不清晰
    2）不会出现写一半推翻重写
    3）方便自己或以后的同时更好维护
### 2、 三层架构设计的好处
    1）每个功能都分成三部分
    2）如果用户更换不同的用户界面或不同的数据储存机制，这样
    都不会影响接口层的核心逻辑代码。拓展性强
    3）可以在接口层，准确的记录接口和流水
### 3、三层架构
#### 一 用户视图层
    用于与用户交互的，可以接受用户输入，打印接口返回的数据
#### 二 逻辑接口层
    接受 用户视图层 传递过来的参数，根据逻辑判断调用数据层加以处理，
    并返回一个结果给用户视图层
#### 三 数据处理层
    接受接口层传递过来的参数，做数据的
        - 保存 save()
        - 查看数据 select()
        - 更新数据
        - 删除数据
## 三 分任务开发
## 四 测试
## 五 上线

# 统计代码

  • 相关阅读:
    iText7画发票PDF——小tips
    一幅长文细学华为MRS大数据开发（五）——MapReduce和Yarn
    Linux使用正则匹配配置文件有效内容
    linux驱动开发.之spi测试工具spidev_test源码（一）
    中国石油大学(北京)-《 油气藏经营管理》第一阶段在线作业
    R语言和医学统计学（6）：重复测量方差分析
    k8s的ClusterIP和NodePort类型有何不同
    springboot常用注解
    Spring学习笔记(四)--spring配置文件schema约束
    Xlua在unity中使用luaide打断点
  • 原文地址：https://blog.csdn.net/weixin_43507744/article/details/126692924