笔试题：
1. 什么是迭代器?（1分）
迭代器知道是用来迭代取值的工具。
这里的迭代是一个重复的过程，每次重复是基于上一次的结果而继续的，单纯的重复并不是迭代。
2. 为何要有迭代器?（1分）
迭代去是用来迭代取值的工具，把多个值循环取出来的类型。
其中：列表、字符串、元组都是索引取值的，有局限性。
Python提供了一种能够不依赖索引取值的方式，那就是迭代器。
3. 什么是可迭代的对象?（1分）
内置有__iter__方法的都是可迭代对象。
4. 什么是迭代器对象？（1分）
调用可迭代对象下面的__iter__方法后，会将其转换成迭代器对象。
5. 如何得到自定义的迭代器？（1分）
生成器就是自定义的迭代器。
再函数内存在yield关键字，调用函数后，并不会执行函数体代码，和return不同。
6. 多个叠加装饰器的加载顺序与执行顺序是？（1分）
加载顺序：自下而上
执行顺序：自上而下
7. 什么是三元表达式？语法是什么？（1分）
三元表达式就是把if-else写到一行中，并且返回一个值
语法：条件成立时返回的值 if 条件 else 条件不成立时返回的值
8. 递归的两个阶段是什么？（1分）
回溯：一层一层地调用下去
递推：满足某种条件后，结束递归调用，一层一层地往上推，往上返回值
9. 什么面向过程的编程思想？优缺点是？（1分）
就是“过程”：先干什么，再干什么，后干什么
优点：可以把复杂的问题流程化、简单化
缺点：扩展性很差
10. 请列举5个或以上的内置函数。（1分）
input()
output()
len()
max()
min()
list()
type()
id()
11. 表达式“[3] in [1, 2, 3, 4]”的值为_________？（1分）
True
12. 转义字符’
’的含义是________?（1分）
换行符，用来换行
13. 任意长度的Python列表、元组和字符串中最后一个元素的下标为__________?（1分）
-1
14. Python语句‘‘.join(list(‘hello world!‘))执行的结果是____________?（1分）
hello world!
15. Python语句list(range(1,10,3))执行结果为__________？（1分）
[1,4,7]
16. 什么命令既可以删除列表中的一个元素，也可以删除整个列表？（1分）
del
17. 已知a = [1, 2, 3]和b = [1, 2, 4]，那么id(a[1])==id(b[1])的执行结果为___________?（1分）
True
18. 表达式 int(‘123‘) 的值为_________?（1分）
123
19. 切片操作list(range(10))[::2]执行结果为?（1分）
[0,2,4,6,8]
20. 语句sorted([1, 2, 3], reverse=True) == reversed([1, 2, 3])执行结果为_________?（1分）
False
21. 表达式 ‘ab‘ in ‘acbed‘ 的值为________?（1分）
False
22. Python的内置函数_______可以返回列表、元组、字典、集合、字符串以及range对象中元素个数？（1分）
len()
23. Python内置函数____________用来返回序列中的最大元素?（1分）
max()
24. Python内置函数____________用来返回序列中的最小元素?（1分）
min()
25. Python内置函数________________用来返回数值型序列中所有元素之和?（1分）
sum()
26. 已知列表对象x = [‘11‘, ‘2‘, ‘3‘]，则表达式 max(x) 的值为___________?（1分）
11
27. 表达式 min([‘11‘, ‘2‘, ‘3‘]) 的值为_________________?（1分）
2
28. 已知列表对象x = [‘11‘, ‘2‘, ‘3‘]，则表达式max(x, key=len) 的值为___________?（1分）
1
29. 表达式 {1, 2, 3, 4} - {3, 4, 5, 6}的值为____________?（1分）
{1, 2}
30. 表达式set([1, 1, 2, 3])的值为_____________?（1分）
[1,2,3]
31. 假设re模块已导入，那么表达式re.findall(‘(d)1+‘, ‘33abcd112‘)的值为_________？（1分）
[‘3‘, ‘1‘]
32. 语句 print(re.match(‘abc‘, ‘defg‘)) 输出结果为____________?（1分）
None
33. 表达式 list(filter(lambda x: x%2==0, range(10))) 的值为_________?（1分）
[0, 2, 4, 6, 8]
34. 表达式 isinstance(‘abc‘, str) 的值为_________?（1分）
True
35. Python标准库random中的___________方法作用是从序列中随机选择1个元素?（1分）
choice()
36. random模块中_____________方法的作用是将列表中的元素随机乱序?（1分）
shuffle()
37. 模块可以分为四类分别是什么（1分）
1.用Python编写的.py文件
2.第三方库
3.有__init__.py的包
4.Python内置模块
38. 包的作用是什么?（1分）
包可以当做模块被导入
39. init.py文件有什么用?（1分）
1.首次导包，就会运行包下面的__init__.py的代码
2.会产生__init__的名称空间，运行时产生的名字都在该名称空间中
3.在执行文件中，导包，产生的全局名称空间，指向__init__的名称空间
40. 使用相对导入时的注意事项（1分）
只能在包内使用，不能跨出包。
41. 模块的搜索顺序（1分）
1.内存（内置模块）
2.硬盘（按照sys.path中的顺序依次查找）
42. 有如下目录（1分）
bin
start.py
core
src.py
在start.py中有以下代码
import core.src
问:在pycharm中正常执行 而在cmd中执行报错 为什么?
因为在pycharm中，会自动寻找路径。
在cmd中，找不到，就报错。
43. datetime.now() 与 time.time() 的区别是什么（1分）
datetime.now()：显示的是当前时间，格式为：2020-04-05 10:40:02.654654
time.time()：显示的是从1970年到现在经过的秒数，主要用于时间间隔的运算
44. sys.argv()有什么用（1分）
可以在用cmd执行py文件的同时，传入参数。
s1 = ‘email1:378533872@qq.com email2:333312312@163.com eamil3:alexsb123@gmail.com‘
l1 = [‘378533872@qq.com‘, ‘333312312@163.com‘, [‘alexsb123@gmail.com‘]](mailto:‘alexsb123@gmail.com‘])
46. 编写一个xml文档,存储三个好友的信息（1分）
<?xml version="1.0" encoding="utf-8" ?>
<infomation>
<friend1>
<name>Tank</name>
<height>185</height>
<age>18</age>
<sex>男</sex>
</friend1>
<friend2>
<name>Egon</name>
<height>150</height>
<age>78</age>
<sex>女</sex>
</friend2>
<friend3>
<name>XXQ</name>
<height>180</height>
<age>17</age>
<sex>男</sex>
</friend3>
</infomation>
47. 编写一个json文档,存储三个好友的信息（1分）
{
"0": {"friend_name": "Tank", "height": 185, "is_man": true},
"1": {"friend_name": "Egon", "height": 150, "is_man": false},
"2": {"friend_name": "XXQ", "height": 180, "is_man": true}
}
48. json模块中的load 和 loads的区别（1分）
json.load()是用来读取文件的。
json.loads()是用来读取字符串的。
49. logging模块的默认日志级别是什么（1分）
WARNING
50. 在项目中使用logging的步骤（1分）
1.先在conf的settings.py中进行logging配置
定义日志的输出格式，编写log文件目录，编写LOGGING_DIC(可以复制粘贴的那种！)
2.在lib的common.py的公共方法中先导入import logging.config
再编写添加日志的功能函数（加载日志篇日志信息，获取日志对象）
3.日志功能在接口层（interface）使用
51. 可以用来做MD5加密的模块是哪个？（1分）
hashlib模块
52. os和sys模块的作用？（1分）
os:与操作系统交互的接口。
sys:访问解释器和变量的接口。
53. 如何生成一个随机数？（1分）
先导入random模块，然后用random生成随机数
54. 如何使用python删除一个文件？（1分）
import os
os.remove(文件的完整路径)
55. json序列化时，可以处理的数据类型有哪些？如何定制支持datetime类型？（1分）
可以处理的数据类型：字符串(str)、列表(list)、字典(dict)、数字类型(int / float)、布尔类型(True / False)
56. json序列化时，默认遇到中文会转换成unicode，如果想要保留中文怎么办？（1分）
把ensuer_ascii的值设置为False
57. 你工作中都用过哪些内置模块？（1分）
os sys hashlib re random time json pickle
可以调整函数、扩展函数，不需要自己重写他们
59. 如何在一个function里面设置一个全局的变量？（1分）
global
60. 什么是深拷贝与浅拷贝？（1分）
深拷贝：把一个列表复制过来，2个列表完全独立开，互不影响。
浅拷贝：把列表的第一层内存地址 不加区分地完全复制给一份新列表。
ATM+购物车:
conf
settings.py
# 存放配置信息
import os
# 获取项目的 根目录路径
BASE_PATH = os.path.dirname(
os.path.dirname(__file__)
)
# 获取商品的json路径
GOODS_PATH = os.path.join(
BASE_PATH, ‘db‘, ‘goods_list.json‘
)
# 获取user_data的路径
USER_DATA_PATH = os.path.join(
BASE_PATH, ‘db‘, ‘user_data‘
)
# 导入logging配置
"""
logging配置
"""
# 定义三种日志输出格式 开始
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‘
id_simple_format = ‘[%(levelname)s][%(asctime)s] %(message)s‘
# 定义日志输出格式 结束
# ****************注意1: log文件的目录
BASE_PATH = os.path.dirname(os.path.dirname(__file__))
logfile_dir = os.path.join(BASE_PATH, ‘log‘)
# print(logfile_dir)
# ****************注意2: log文件名
logfile_name = ‘log.log‘
# 如果不存在定义的日志目录就创建一个
if not os.path.isdir(logfile_dir):
os.mkdir(logfile_dir)
# log文件的全路径
logfile_path = os.path.join(logfile_dir, logfile_name)
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,
‘encoding‘: ‘utf-8‘, # 日志文件的编码，再也不用担心中文log乱码了
},
},
‘loggers‘: {
# logging.getLogger(__name__)拿到的logger配置
‘‘: {
‘handlers‘: [‘default‘, ‘console‘], # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
‘level‘: ‘DEBUG‘,
‘propagate‘: True, # 向上（更高level的logger）传递
},
},
}
core
admin.py
# 管理员视图层
from core import src
from interface import admin_interface
# 添加用户
def add_user():
src.register()
# 修改用户额度
def change_balance():
while True:
change_user = input(‘请输入要修改额度的用户名：‘).strip()
money = input(‘请输入要修改的额度‘).strip()
if not money.isdigit():
print(‘输入数字啊！憨憨！‘)
continue
flag, msg = admin_interface.change_balance_interface(
change_user, money
)
if flag:
print(msg)
break
else:
print(msg)
# 冻结用户
def lock_user():
while True:
to_lock_user = input(‘请输入要冻结的用户名（按q退出）：‘).strip()
if to_lock_user.lower() == ‘q‘:
print(‘退出成功！‘)
break
flag, msg = admin_interface.lock_user_interface(
to_lock_user
)
if flag:
print(msg)
break
else:
print(msg)
# 解冻用户
def unlock_user():
while True:
to_unlock_user = input(‘请输入要冻结的用户名（按q退出）：‘).strip()
if to_unlock_user.lower() == ‘q‘:
print(‘退出成功！‘)
break
flag, msg = admin_interface.unlock_user_interface(
to_unlock_user
)
if flag:
print(msg)
break
else:
print(msg)
# 管理员功能字典
admin_dic = {
‘1‘: add_user,
‘2‘: change_balance,
‘3‘: lock_user,
‘4‘: unlock_user
}
def admin_run():
while True:
print(‘‘‘
======= 管理员功能 =======
| 1.添加用户 |
| 2.修改额度 |
| 3.冻结账户 |
| 4.解冻账户 |
======== THE END ========
‘‘‘)
choice = input(‘请输入管理员功能编号（按q退出）：‘).strip()
if choice.lower() == ‘q‘:
print(‘退出成功！‘)
break
if choice not in admin_dic:
print(‘只能输1-4，知道不？！再给你一次机会！‘)
continue
admin_dic.get(choice)()
src.py
# 用户视图层
from interface import user_interface
from interface import bank_interface
from interface import shop_interface
from lib import common
# 定义一个全局变量，记录用户是否登录
login_user = None
# 1.注册功能
def register():
print(‘注册功能执行中...‘)
while True:
# 1.让用户名输入用户名和密码
username = input(‘请输入用户名：‘).strip()
password = input(‘请输入密码：‘).strip()
re_password = input(‘请确认密码：‘).strip()
if password == re_password:
# 2.调用注册接口
flag, msg = user_interface.register_interface(
username, password
)
if flag:
print(msg)
break
else:
print(msg)
# 2.登录功能
def login():
print(‘登录功能执行中...‘)
while True:
# 1.让用户名输入用户名和密码
username = input(‘请输入用户名：‘).strip()
password = input(‘请输入密码：‘).strip()
flag, msg = user_interface.login_interface(
username, password
)
if flag:
print(msg)
# 记录全局变量，登录的用户
global login_user
login_user = username
break
else:
print(msg)
@common.login_auth
# 3.查询余额功能
def check_balance():
print(‘查询余额功能执行中...‘)
balance = user_interface.check_bal_interface(
login_user
)
print(f‘用户：[{login_user}] 账户余额：[{balance}]元！‘)
@common.login_auth
# 4.提现功能
def withdraw():
print(‘提现功能执行中...‘)
while True:
input_money = input(‘请输入提现金额：‘).strip()
# 判断是否是数字
if not input_money.isdigit():
print(‘注意审题！输入数字！数字！数字！‘)
continue
flag, msg = bank_interface.withdraw_interface(
login_user, input_money
)
if flag:
print(msg)
break
else:
print(msg)
@common.login_auth
# 5.还款功能
def repay():
print(‘还款功能执行中...‘)
while True:
input_money = input(‘请输入还款金额：‘).strip()
# 判断是否是数字
if not input_money.isdigit():
print(‘注意审题！输入数字！数字！数字！‘)
continue
if int(input_money) > 0:
flag, msg = bank_interface.withdraw_interface(
login_user, input_money
)
if flag:
print(msg)
break
else:
print(msg)
else:
print(‘没钱你存个鸟啊！‘)
@common.login_auth
# 6.转账功能
def transfer():
print(‘转账功能执行中...‘)
while True:
# 1.让用户输入转账用户和金额
to_user = input(‘请输入转账目标用户：‘).strip()
money = input(‘请输入转账金额：‘).strip()
# 2.判断用户输入金额是否是数字或者>0
if not money.isdigit():
print(‘请输入正确的金额！‘)
continue
money = int(money)
if money > 0:
# 3.调用转账接口
flag, msg = bank_interface.transfer_interface(
# 当前用户，目标用户，转账金额
login_user, to_user, money
)
if flag:
print(msg)
break
else:
print(msg)
else:
print(‘请输入正确的金额！‘)
@common.login_auth
# 7.查看流水功能
def check_flow():
print(‘查看流水功能执行中...‘)
flow_list = bank_interface.check_flow_interface(
login_user
)
if flow_list:
for flow in flow_list:
print(flow)
else:
print(‘你没有流水信息！‘)
@common.login_auth
# 8.购物功能
def shopping():
print(‘购物功能执行中...‘)
while True:
goods_dic = shop_interface.get_goods_interface()
print(‘================ Welcome To Hardware World ================
‘)
for number, goods_info in goods_dic.items():
print(f‘商品ID：[{number}] 商品名：[{goods_info.get("goods_name")}] 价格：[{goods_info.get("price")}]元‘)
print(‘‘)
print(‘========================= THE END =========================‘)
goods_id = input(‘请输入要购买的商品ID（输入q退出）：‘).strip()
if goods_id.lower() == ‘q‘:
print(‘退出成功！‘)
break
count = input(‘请输入要购买的数量（输入q退出）：‘).strip()
if count.lower() == ‘q‘:
print(‘退出成功！‘)
break
if not count.isdigit() or count == ‘0‘:
print(‘只能输入商品编号，知道不？‘)
continue
if goods_id not in goods_dic:
print(‘该商品不存在，选其他的凑合吧！‘)
continue
# 将对用编号的商品加入购物车
shop_interface.add_shop_car_interface(goods_dic[goods_id], int(count))
print(f"{goods_dic[goods_id][‘goods_name‘]}已加入购物车,请到购物车结算")
@common.login_auth
# 9.查看购物车功能
def check_shop_car():
print(‘查看购物车功能执行中...‘)
shop_car_dic = shop_interface.check_shop_car_interface(login_user)
while True:
shop_id = 0
print(‘========================= 购物车内容 =========================
‘)
for goods_name, goods_info in shop_car_dic.items():
print(
f‘商品ID：[{shop_id}] 商品名称：[{goods_name}] 数量：[{goods_info.get("count")}] 总价：[{goods_info.get("total")}]元‘)
shop_id += 1
print(‘‘)
print(‘========================== THE END ==========================‘)
pay_id = input(‘请输入要付款的商品ID（按q退出）：‘).strip()
if pay_id.lower() == ‘q‘:
print(‘退出成功！‘)
break
if int(pay_id) not in range(len(shop_car_dic)):
print(‘该商品不存在，请选择其他ID！‘)
continue
buy_goods_name = list(shop_car_dic.keys())[int(pay_id)]
buy_goods_count = shop_car_dic[buy_goods_name].get(‘count‘)
buy_goods_total = shop_car_dic[buy_goods_name].get(‘total‘)
print(f‘将付款的商品为：[{buy_goods_name}] 数量：[{buy_goods_count}] 总价：[{buy_goods_total}]‘)
# 付款操作
inp_pay = input(‘确认要付款吗（Y/N）：‘).strip()
if inp_pay.lower() == ‘y‘:
flag, msg = shop_interface.payment_interface(
login_user, buy_goods_name, buy_goods_total
)
if flag:
print(msg)
break
else:
print(msg)
elif inp_pay.lower() == ‘n‘:
print(‘付款失败，用户取消支付！‘)
else:
print(‘只能输入Y或者N‘)
continue
@common.login_auth
# 10.管理员功能
def admin():
print(‘管理员功能执行中...‘)
from core import admin
if login_user == ‘admin‘:
admin.admin_run()
else:
print(‘不是管理员还想用管理员功能，做梦呢！‘)
# 创建函数功能字典
func_dic = {
‘1‘: register,
‘2‘: login,
‘3‘: check_balance,
‘4‘: withdraw,
‘5‘: repay,
‘6‘: transfer,
‘7‘: check_flow,
‘8‘: shopping,
‘9‘: check_shop_car,
‘10‘: admin
}
# 编写视图层主程序
def run():
while True:
print(‘‘‘
======= ATM + 购物车 =======
| 1.注册功能 |
| 2.登录功能 |
| 3.查看余额 |
| 4.提现功能 |
| 5.还款功能 |
| 6.转账功能 |
| 7.查看流水 |
| 8.购物功能 |
| 9.查看购物车 |
| 10.管理员功能 |
========= THE END =========
‘‘‘)
choice = input(‘请输入功能编号：‘).strip()
if choice not in func_dic:
print(‘1-10都不会输入吗？！！！‘)
continue
func_dic.get(choice)()
db
userdata
db_handler.py
# 数据处理层
import os
import json
from conf import settings
# 查看数据
def select(username):
# 1.接收接口层传过来的username用户名，拼接用户json文件路径
user_path = os.path.join(
settings.USER_DATA_PATH, f‘{username}.json‘
)
# 2.校验用户json文件是否存在
if os.path.exists(user_path):
# 3.打开数据，并返回给接口层
with open(user_path, mode=‘rt‘, encoding=‘UTF-8‘) as f:
user_dic = json.load(f)
return user_dic
# 保存、修改、更新数据
def save(user_dic):
# 1.拼接用户的数据字典
username = user_dic.get(‘username‘)
user_path = os.path.join(
settings.USER_DATA_PATH, f‘{username}.json‘
)
# 2.保存用户数据
with open(user_path, mode=‘wt‘, encoding=‘UTF-8‘) as f:
json.dump(user_dic, f, ensure_ascii=False)
# 获取商品数据
def select_goods():
with open(settings.GOODS_PATH, mode=‘rt‘, encoding=‘UTF-8‘) as f:
goods_dic = json.load(f)
return goods_dic
goods_list.json
{
"0": {"goods_name": "logitech-G703", "price": 549},
"1": {"goods_name": "Antec-HCG750W", "price": 799},
"2": {"goods_name": "ROG-M11E-Z390", "price": 6999},
"3": {"goods_name": "G.SKILL-16G-RGB", "price": 769},
"4": {"goods_name": "Intel-i9-9900KF", "price": 3599},
"5": {"goods_name": "SAMSUNG-970Pro-1T", "price": 2699},
"6": {"goods_name": "Segotep-K1(ATX3.0)", "price": 499},
"7": {"goods_name": "ROG-RTX-2080Ti-11G", "price": 11999},
"8": {"goods_name": "CHERRY-MX6.0-BLUE RGB", "price": 1399},
"9": {"goods_name": "ASUS-ROG-360mm-RGB Aura", "price": 2299},
"10": {"goods_name": "SAMSUNG-27inch-Space-2K/144Hz", "price": 3499}
}
interface
admin_interface.py
# 管理员接口
import time
from db import db_handler
from lib import common
# 根据不同的接口类型，传入不同的日志对象
admin_logger = common.get_logger(log_type=‘admin‘)
# 记录当前操作的时间
now_time = time.strftime(‘%Y-%m-%d %X‘)
# 修改额度接口
def change_balance_interface(username, money):
user_dic = db_handler.select(username)
if user_dic:
user_dic[‘balance‘] = int(money)
# 保存数据
db_handler.save(user_dic)
msg = f‘{now_time} 管理员 修改用户：[{username}]额度为：[{money}]成功！‘
# 记录日志
admin_logger.info(msg)
return True, msg
return False, ‘该用户不存在！‘
# 冻结用户接口
def lock_user_interface(username):
user_dic = db_handler.select(username)
if user_dic:
if not user_dic[‘locked‘]:
user_dic[‘locked‘] = True
db_handler.save(user_dic)
msg = f‘{now_time} 用户：[{username}] 冻结成功！‘
# 记录日志
admin_logger.info(msg)
return True, msg
else:
return False, ‘该用户已经被冻结，无需再次冻结！‘
return False, ‘该用户不存在！‘
# 解冻用户接口
def unlock_user_interface(username):
user_dic = db_handler.select(username)
if user_dic:
if user_dic[‘locked‘]:
user_dic[‘locked‘] = False
db_handler.save(user_dic)
msg = f‘{now_time} 用户：[{username}] 解冻成功！‘
# 记录日志
admin_logger.info(msg)
return True, msg
else:
return False, ‘该用户未被冻结，无需解冻！‘
return False, ‘该用户不存在！‘
bank_interface.py
# 银行接口
import time
from db import db_handler
from lib import common
# 根据不同的接口类型，传入不同的日志对象
bank_logger = common.get_logger(log_type=‘bank‘)
# 记录当前操作的时间
now_time = time.strftime(‘%Y-%m-%d %X‘)
# 提现接口（手续费5%）
def withdraw_interface(username, money):
user_dic = db_handler.select(username)
# 账户余额
balance = int(user_dic.get(‘balance‘))
# 提现金额 + 5%手续费
money2 = int(money) * 1.05
# 判断用户余额是否足够
if balance >= money2:
balance -= money2
user_dic[‘balance‘] = balance
# 记录流水
flow = f‘{now_time} 用户：[{username}] 提现：[{money}]元 手续费：[{money2 - float(money)}]元‘
user_dic[‘flow‘].append(flow)
# 保存数据
db_handler.save(user_dic)
# 银行记录流水
bank_logger.info(flow)
return True, flow
return False, ‘钱不够取了，穷13！‘
# 还款接口
def repay_interface(username, money):
user_dic = db_handler.select(username)
user_dic[‘balance‘] += money
new_money = user_dic[‘balance‘]
# 记录流水
flow = f‘{now_time} 用户：[{username}] 还款：[{money}]元‘
user_dic[‘flow‘].append(flow)
# 保存数据
db_handler.save(user_dic)
# 银行记录流水
bank_logger.info(flow)
return True, flow
# 转账接口
def transfer_interface(login_user, to_user, money):
login_user_dic = db_handler.select(login_user)
to_user_dic = db_handler.select(to_user)
if not to_user_dic:
bank_logger.warning(f‘{now_time} 用户：[{login_user}] 转账失败，用户：[{to_user}]不存在‘)
return False, ‘目标用户不存在！‘
# 当前用户余额足够，就转账
if login_user_dic[‘balance‘] >= money:
login_user_dic[‘balance‘] -= money
to_user_dic[‘balance‘] += money
login_user_flow = f‘{now_time} 用户：[{login_user}] 给 用户：[{to_user}] 转账：[{money}]元‘
login_user_dic[‘flow‘].append(login_user_flow)
to_user_flow = f‘{now_time} 用户：[{to_user}] 接收 用户：[{login_user} 转账：[{money}]元‘
to_user_dic[‘flow‘].append(to_user_flow)
# 保存数据
db_handler.save(login_user_dic)
db_handler.save(to_user_dic)
# 银行记录日志
bank_logger.info(login_user_flow)
return True, login_user_flow
else:
bank_logger.warning(f‘{now_time} 用户：[{login_user}] 余额不足，转账失败！‘)
return False, ‘余额不足，转账失败，穷13‘
# 查看流水
def check_flow_interface(login_user):
user_flow_dic = db_handler.select(login_user)
return user_flow_dic[‘flow‘]
shop_interface.py
# 购物接口
import time
from db import db_handler
from lib import common
# 根据不同的接口类型，传入不同的日志对象
shop_logger = common.get_logger(log_type=‘shop‘)
# 记录当前操作的时间
now_time = time.strftime(‘%Y-%m-%d %X‘)
# 获取商品信息接口
def get_goods_interface():
goods_dic = db_handler.select_goods()
return goods_dic
# 添加购物车接口
def add_shop_car_interface(goods_dic, count):
from core import src
total = goods_dic["price"] * count
goods_name = goods_dic[‘goods_name‘]
shop_dic = {
f"{goods_name}": {"count": count, "total": total}
}
user_dic = db_handler.select(src.login_user)
shop_car_dic = user_dic[‘shop_car‘]
if user_dic.get(‘shop_car‘) == {}:
user_dic[‘shop_car‘] = shop_dic
else:
if goods_name not in shop_car_dic:
shop_car_dic.update(shop_dic)
user_dic[‘shop_car‘] = shop_car_dic
else:
user_dic[‘shop_car‘].get(goods_name)[‘count‘] += count
user_dic[‘shop_car‘].get(goods_name)[‘total‘] += total
db_handler.save(user_dic)
msg1 = f‘{now_time} 用户：[{src.login_user}] 添加商品：[{goods_name}] 数量：[{count}] 至购物车！‘
# 记录购物日志
shop_logger.info(msg1)
return True, msg1
# 获取购物车信息接口
def check_shop_car_interface(login_user):
user_dic = db_handler.select(login_user)
shop_car_dic = user_dic["shop_car"]
# 记录日志
shop_logger.info(f‘{now_time} 用户：[{login_user}] 查看了购物车！‘)
return shop_car_dic
# 付款接口
def payment_interface(login_user, buy_goods_name, buy_goods_total):
user_dic = db_handler.select(login_user)
shop_car_dic = user_dic[‘shop_car‘]
balance = user_dic[‘balance‘]
if buy_goods_total > balance:
shop_logger.warning(f‘{now_time} 用户：[{login_user}] 余额不足，支付失败！‘)
return False, ‘余额不足，支付失败！‘
balance -= buy_goods_total
shop_car_dic.pop(buy_goods_name)
user_dic[‘balance‘] = balance
user_dic[‘shop_car‘] = shop_car_dic
msg1 = f‘{now_time} 用户：[{login_user}] 购买商品：[{buy_goods_name}] 共计消费：[{buy_goods_total}]元‘
# 添加流水
user_dic[‘flow‘].append(msg1)
db_handler.save(user_dic)
# 记录日志
shop_logger.info(msg1)
return True, msg1
uer_interface.py
# 用户接口
import time
from db import db_handler
from lib import common
# 根据不同的接口类型，传入不同的日志对象
user_logger = common.get_logger(log_type=‘user‘)
# 记录当前操作的时间
now_time = time.strftime(‘%Y-%m-%d %X‘)
# 注册接口
def register_interface(username, password, balance=15000):
user_dic = db_handler.select(username)
if user_dic:
return False, ‘不好意思，该用户名已被注册，请换个用户名！‘
# 给密码加密
password = common.get_pwd_md5(password)
# 如果用户名是admin，就是管理员用户
if username == ‘admin‘:
user_dic = {
‘username‘: username,
‘password‘: password,
‘balance‘: balance,
‘flow‘: [],
‘shop_car‘: {},
‘is_admin‘: True,
}
# 用户数据字典
user_dic = {
‘username‘: username,
‘password‘: password,
‘balance‘: balance,
‘flow‘: [],
‘shop_car‘: {},
‘locked‘: False,
‘is_admin‘: False
}
# 保存数据
db_handler.save(user_dic)
msg = f‘{now_time} {now_time} [{username}]用户注册成功，初始额度为：[{balance}]元‘
# 记录日志
user_logger.info(msg)
return True, msg
# 登录接口
def login_interface(username, password):
user_dic = db_handler.select(username)
# 判断用户是否存在
if user_dic:
# 查看用户是否被冻结
if user_dic.get(‘locked‘):
return False, ‘你被冻结了，好好反省一下自己做了什么不该做的事！‘
# 给接收到的密码加密
password = common.get_pwd_md5(password)
# 校验密码是否一致
if password == user_dic.get(‘password‘):
msg = f‘{now_time} 用户：[{username}]登录成功！‘
# 记录日志
user_logger.info(msg)
return True, msg
else:
msg = f‘{now_time}用户：[{username}]密码错误！‘
# 记录日志
user_logger.warn(msg)
return False, msg
msg = f‘用户：[{username}]不存在，请重新输入！‘
return False, msg
# 查询余额接口
def check_bal_interface(username):
user_dic = db_handler.select(username)
return user_dic[‘balance‘]
lib
common.py
# 存放公共方法
import hashlib
from conf import settings
import logging.config
# 编写登录认证装饰器
def login_auth(func):
# 防止循环导入
from core import src
def inner(*args, **kwargs):
if src.login_user:
res = func(*args, **kwargs)
return res
else:
print(‘没登录，无法享用特殊服务！还不快去登录‘)
src.login()
return inner
# 编写添加日志的功能
def get_logger(log_type):
# 1.加载日志配置信息
logging.config.dictConfig(
settings.LOGGING_DIC
)
# 2.获取日志对象
logger = logging.getLogger(log_type)
return logger
# 编写密码加密
def get_pwd_md5(password):
md5_obj = hashlib.md5()
md5_obj.update(password.encode(‘UTF-8‘))
salt = ‘波罗波罗蜜‘
md5_obj.update(salt.encode(‘UTF-8‘))
return md5_obj.hexdigest()
log
log.log
# 初始为空，用于存放日志信息
readme.md
# 项目说明书
## 项目：AMT+购物车
# 项目需求：
1.注册（5分） ==> 注册功能
2.登录（5分） ==> 登录功能
3.查看余额（2分） ==> 查看余额功能
4.提现（5分） ==> 体现功能
5.还款（5分） ==> 类似充值功能
6.转账（10分） ==> 转账功能
7.查看流水（2分） ==> 查看流水功能
8.购物功能（15分） ==> 购物功能
9.查看购物车功能（2分） ==> 查看购物车功能
10.记录日志（5分） ==> 日志功能
11.登录认证装饰器（2分） ==> 装饰器
12.密码加密（2分） ==> hashlib的md5加密
13.管理员功能（5分） ==> 管理员功能
- 冻结账户
- 添加账户
- 修改额度
## 用户可以使用的功能
1.注册
2.登录
3.查看余额
4.提现
5.还款
6.转账
7.查看流水
8.购物功能
9.查看购物车功能
# 设计思路
## 启动文件的实现
首先，创建一个start.py作为整个项目启动的启动文件。
然后导入os和sys模块，从core中导入src，也就是用户视图层。
然后添加解释器的环境变量，再开始执行项目函数。
在src.py 用户视图层中，先写好各个功能函数名，然后创建一个函数功能字典。
然后就是视图层的主程序，打印选择列表让用户选择，根据选择的编号来调用不同的功能函数。
## 配置信息的实现
在conf的setting.py中，编写配置文件。
写好项目的根目录路径BASE_PATH。
写好商品信息路径GOODS_PATH。
写好用户信息路径USER_DATA_PATH
然后写上日志配置（日志格式可以复制粘贴过来）
## 公共方法的实现
在lib的common.py中存放公共方法。
导入conf的settings配置。
写上用户的登录认证装饰器。
导入hashlib模块，写上密码的md5加密，以json格式存储密码。
导入logging.config，添加日志功能，在接口层使用。
## 商品信息的实现
在db的goods_list.json中编写商品数据，以json的格式存储：
{
"0": {"goods_name": "logitech-G703", "price": 549},
"1": {"goods_name": "Antec-HCG750W", "price": 799},
"2": {"goods_name": "ROG-M11E-Z390", "price": 6999},
"3": {"goods_name": "G.SKILL-16G-RGB", "price": 769},
"4": {"goods_name": "Intel-i9-9900KF", "price": 3599},
"5": {"goods_name": "SAMSUNG-970Pro-1T", "price": 2699},
"6": {"goods_name": "Segotep-K1(ATX3.0)", "price": 499},
"7": {"goods_name": "ROG-RTX-2080Ti-11G", "price": 11999},
"8": {"goods_name": "CHERRY-MX6.0-BLUE RGB", "price": 1399},
"9": {"goods_name": "ASUS-ROG-360mm-RGB Aura", "price": 2299},
"10": {"goods_name": "SAMSUNG-27inch-Space-2K/144Hz", "price": 3499}
}
## 数据处理层的实现
在db的db_handler.py 数据处理层中，导入json和os模块，从conf中导入settings配置。
编写查看数据函数，接收接口层传过来的username用户名，拼接用户json文件路径。
校验用户json文件，打开数据，并返回给接口层。
编写保存数据函数，用于添加新数据或者更新数据。
拼接用户的数据字典，保存用户数据。
编写获取商品数据函数，用于获取商品数据。
商品数据也是以json格式读取的。
## 注册功能的实现
编写interface的user_interface.py的注册接口。
查看用户是否存在，若存在，返回“用户名已存在!”
若不存在，就编写一个用户字典保存为“用户名.json”。
其中，如果用户名是“admin”，就是管理员，字典信息中的“is_admin”为“True”。
然后调用数据处理层的db_handler的save功能进行保存。
在core的src.py 用户视图层中，编写注册函数。
先定义一个全局遍历login_user = None，用来记录用户是否已登录。
让用户输入用户名和密码进行注册，2次密码必须相同。
调用接口层的注册接口，将用户名与密码交给接口层来进行处理。
输入的用户名如果是admin，就是管理员，其余是普通用户。
根据flag判断用户注册是否成功，flag控制break的结束。
## 登录功能的实现
编写interface的user_interface.py的登录接口。
先调用数据处理层的db_handler的select功能查看当前用户数据是否存在。
如果存在，就继续执行，如果不存在，就输出“用户不存在，请重新输入！”
再根据get用户字典的‘locker’的True或False判断用户是否被冻结。
然后给用户的密码做一次加密，和取过来的加密的用户密码比对，查看是否一致。
如果一致，就登录成功；如果不一致，登录失败。
在core的src.py 用户视图层中，编写登录函数。
让用户输入用户名和密码。
调用接口层的登录接口，将用户名与密码交给接口层来进行处理。
输入的用户名如果是admin，就是管理员，其余是普通用户。
根据flag判断用户注册是否成功，flag控制break的结束。
## 查看余额功能的实现
编写interface的user_interface.py的查看余额接口。
编写user_dic调用数据处理层的db_handler的select功能查看当前用户的余额。
返回给用户视图层。
在core的src.py 用户视图层中，编写查看余额函数。
只有登录的用户才能查看。
调用接口层的查看余额接口，传入当前登录的用户名。
打印用户名和用户金额。
## 提现功能的实现
编写interface的user_interface.py的查看提现接口。
编写user_dic调用数据处理层的db_handler的select功能查看当前用户的余额。
把当前余额变成整型，然后计算手续费。
判断用户金额是否足够，如果足够，就修改用户字典中的金额，如果不足够，就退出并提示“余额不足！”
记录流水，调用数据处理层的db_handler的save和update功能保存并更新数据。
将结果返回给用户视图层。
在core的src.py 用户视图层中，编写提现函数。
只有登录的用户才能提现。
让用户输入提现金额，判断用户输入的金额是否是数字，如果不是，就重新输入。
用户提现金额，将提现的金额交付给接口层来处理，传入当前登录的用户名。
调用接口层的查看余额接口，传入当前登录的用户名。
打印用户名和提现信息和余额信息。
## 还款功能的实现
编写interface的user_interface.py的查看还款接口。
编写user_dic调用数据处理层的db_handler的select功能查看当前用户的余额。
把当前余额变成整型，然后计算还款额。
记录流水，调用数据处理层的db_handler的save和update功能保存并更新数据。
将结果返回给用户视图层。
在core的src.py 用户视图层中，编写还款函数。
只有登录的用户才能提现。
让用户输入提现金额，判断用户输入的金额是否是数字，如果不是，就重新输入。
用户还款金额，将还款的金额交付给接口层来处理，传入当前登录的用户名。
调用接口层的查看余额接口，传入当前登录的用户名。
打印用户名和还款信息和余额信息。
## 转账功能的实现
编写interface的bank_interface.py的转账接口。
编写login_dic和to_user_dic调用数据处理层的db_handler的select功能。
获取“当前用户”和“目标用户”字典，判断目标用户是否存在，若用户存在，则判断“当前用户转账金额”是否足够。
若足够，给当前用户的数据，做减钱操作；给目标用户的数据，做加钱操作，然后记录双方流水。
调用数据处理层的db_handler的save功能保存数据。
将结果返回给用户视图层。
在core的src.py 用户视图层中，编写转账函数。
只有登录的用户才能提现。
判断用户输入金额是否是数字或者>0，如果不是，就重新输入。
让用户输入转账的用户和金额。将输入的信息交付给接口层来处理，传入当前登录的用户名、对方用户名、金额。
调用接口层的，打印用户名和还款信息和余额信息。
## 流水功能的实现
编写interface的bank_interface.py的查看流水接口。
编写user_flow_dic字典，调用调用数据处理层的db_handler的select功能，传入当前用户。
将结果返回给用户视图层。
在core的src.py 用户视图层中，编写查看流水函数。
调用interface的bank_interface.py接口，传入当前用户。
调用流水接口，输出流水信息。
购物功能的实现
编写interface的shop_interface.py的购物接口。
编写goods_dic字典，调用数据处理层的db_handler的select_goods功能查看商品信息。
将结果返回给用户视图层。
编写interface的shop_interface.py的add_shop_car_interface购物车添加接口。
将用户视图层传来的视频信息存入字典。
如果商品不在购物车中则直接加入，商品在购物车中，修改商品数量以及总价。
将结果返回给用户视图层。
在core的src.py 用户视图层中，编写购物函数。
调用interface的bank_interface.py接口，获取全部商品信息并打印。
将对应编号的商品加入购物车，调用add_shop_car_interface购物车添加接口。
调用购物车添加接口，已经入购物车的信息。
## 购物车结算功能的实现
编写interface的shop_interface.py的查看购物车接口。
编写user_dic字典，调用调用数据处理层的db_handler的select功能，传入当前用户。
编写shop_car_dic字典，取出user_dic字典中的"shop_car"，然后记录流水信息。
将结果返回给用户视图层。
在core的src.py 用户视图层中，编写查看购物车函数。
调用interface的shop_interface.py接口，获取用户字典里的"shop_car"。
打印购物车内的信息，让用户选择要购买的购物车内的商品ID，输入c清空购物车，输入q退出该界面。
如果ID不存在，就跳过本次循环，输出信息“商品不存在”。
获取选择付款商品的商品信息并打印。
## 管理员功能的实现
编写interface的admin_interface.py的查看管理员接口。
编写4种功能：添加用户直接调用注册函数；修改额度调用用户字典直接修改，冻结和解冻用户修改用户字典的“locker”的bool值。
将结果返回给用户视图层。
在core下单独编写一个admin.py。
编写4个功能函数，调用各个接口。
编写管理员功能字典：
admin_dic = {
‘1‘: add_user,
‘2‘: change_balance,
‘3‘: lock_user,
‘4‘: unlock_user
}
编写管理员视图和功能选项，打印选择列表让用户选择，根据选择的编号来调用不同的功能函数。
在core的src.py 用户视图层中，编写管理员函数。
直接调用core下的admin.py的admin.run()函数执行功能。
如果用户名是admin的话，就是管理员，如果不是，就是普通用户，没有资格使用该功能。
start.py
# 整个项目的启动文件
import os
import sys
from core import src
# 先添加解释器的环境变量
sys.path.append(
os.path.dirname(__file__)
)
# 然后开始执行项目函数
if __name__ == ‘__main__‘:
# 执行用户视图层
src.run()