0、项目概览
1、项目实现
-
2.1、建包：D:\code\python\day24\shopcar_project
-
2.2、构造模块
- 商品类、仓库类、购物车类、用户类、操作类
-
2.3、模块存储形式
-
商品类
'''
商品类：
商品名称 商品价格 商品剩余量
'''
class Goods(object):
__slots__ = ('gname','gprice','gremain') #限制动态绑定的属性
def __init__(self,gname,gprice,gremain):
self.gname = gname
self.gprice = gprice
self.gremain = gremain
def __str__(self):
return f"【商品】名称：{self.gname}，价格：{self.gprice}"
__repr__ = __str__
#测试
if __name__ == '__main__':
a = Goods('1',2,3)
print(a)
- 仓库类
'''
仓库类：【信息保存在本地磁盘：程序刚启动时把列表先存储到文件中，之后使用再读取出来】
商品列表
商品名称 价格 剩余量
Mac电脑 20000 100
PythonBook 30 200
草莓键盘 80 60
iPhone 7000 70
因为仓库类是用来访问文件对象的，所以仓库类是一个单例类。
对象的序列化：将Python中的对象持久化到磁盘上
对象的反序列化：将磁盘上一个文件中的内容转换为Python对象
放在商品列表类当中的应该是一个列表，列表每个元素都是一个商品对象
'''
import pickle,os
from shopcar_project.goods import Goods
#商品列表存储位置
path = r'goodslist.txt'
#a.闭包，商品仓库是一个单例类
def fout(cls):
ins = None
def inner(*args,**kwargs):
nonlocal ins
if ins == None:
ins = cls(*args,**kwargs)
return ins
return inner
#b.类
@fout
class Storage(object):
__slots__ = ('goods_list',)
def __init__(self):
self.load_goods() #程序刚启动时把列表先存储到文件中，之后使用再读取出来
def __str__(self):
return f"【商品列表】:\n{self.goods_list}"
__repr__ = __str__
def load_goods(self):
self.goods_list = [] #虽然goo_list是类的动态绑定属性，但是用的时候还是要说一下它是什么
if os.path.exists(path): #【exists v. 存在】
# print('文件已存在')
self.goods_list = self.read_storage()
else:
# 初始化数据库,把仓库类属性“列表”序列化到文件中去
gname = ['Mac','pythonbook','键盘','iphone']
gprice = [20000,30,100,8000]
gremain = [100,200,60,70]
for i in range(4):
ob = Goods(gname[i],gprice[i],gremain[i])
self.goods_list.append(ob)
self.write_storage()
#把序列化和反序列化功能单独写出来
def write_storage(self):
with open(path, 'wb') as f:
pickle.dump(self.goods_list, f)
def read_storage(self):
with open(path, 'rb') as f:
return pickle.load(f)
#校验商品是否在商品列表中：
def is_in_goos_list(self,name):
self.goods_list = self.read_storage() #刷新数据===============================
for i in self.goods_list:
if name == i.gname:
return True
else:
print(f'{name}在商品列表中不存在')
return False
#通过输入商品名来返回商品信息：
#a.通过商品名得到商品余量
def get_goods_remain(self,name):
self.goods_list = self.read_storage() # 刷新数据===============================
for i in self.goods_list:
if name == i.gname:
return i.gremain
else:
print(f'{name}在商品列表中不存在')
return None
#b.通过商品名得到商品价格
def get_goods_price(self,name):
self.goods_list = self.read_storage() # 刷新数据===============================
for i in self.goods_list:
if name == i.gname:
return i.gprice
else:
print(f'{name}在商品列表中不存在')
return None
#回收购物车删除数据：
def add_goods(self,name,num):
self.goods_list = self.read_storage() # 刷新数据===============================
for i in self.goods_list:
if name == i.gname:
i.gremain += num #把goos_list当中的某个元素重写
#同步数据到商品列表：
self.write_storage() #将goods_list重写到文件中
#c.类的调用测试
if __name__ == '__main__':
a = Storage()
print(a)
- 购物车类
'''
购物车类：
商品列表：程序初始时，商品列表为空
商品列表是一种通俗说法，实际代码中将商品列表设置为一个字典，将商品名设置为key，将商品购买数量设置为value
购物车到底是如何存储数据的?
'''
from shopcar_project.storage import Storage
import pickle
path = r'shoppingcar.txt'
class ShoppingCar(object):
__slots__ = ('shopcar_dict')
def __init__(self):
#程序初始时，商品列表为空
self.shopcar_dict = {}
def __str__(self):
return f"【购物车】：{self.shopcar_dict}"
__repr__ = __str__
#添加商品
def add_goods(self,name,number):
self.read_shoppingcar() # 刷新数据============================
if name in self.shopcar_dict:
self.shopcar_dict[name] += number
else:
self.shopcar_dict[name] = number
#保存数据
self.write_shoppingcar()
# print(f"添加商品：{name}")
self.show_shopping_car() #留着
print('商品添加成功')
#删除商品【storage添加商品】
def del_goods(self,name,number):
#【如果没有下一行代码，每次执行删除不论输入的商品是什么，都显示‘该商品不在购物车当中’】
self.read_shoppingcar() # 刷新数据============================
if name in self.shopcar_dict:
# 校验要删除的商品数量，对购物车字典进行操作
if (self.shopcar_dict[name] - number) > 0:
self.shopcar_dict[name] -= number
# 将对应数据在返回到Storage当中【调用storage当中的函数】
Storage().add_goods(name, number)
else:
# 将对应数据在返回到Storage当中【调用storage当中的函数】
number1 = self.shopcar_dict[name]
Storage().add_goods(name, number1)
del self.shopcar_dict[name] #删除字典中的键值对
self.write_shoppingcar() # 保存数据
else:
print('该商品不在购物车当中')
#展示购物车信息
def show_shopping_car(self):
self.read_shoppingcar() # 刷新数据============================
print('--------购物车信息--------')
for key,value in self.shopcar_dict.items():
print(f'【商品名】：{key}【购买数量】：{value}')
print('--------over--------')
#计算总价
def get_price(self):
self.read_shoppingcar() # 刷新数据============================
total_price = 0
# a.先获取购物车有哪些物品
print('您的购物车商品如下：')
self.show_shopping_car() #展示购物车物品
for key,value in self.shopcar_dict.items():
price = Storage().get_goods_price(key)
total_price += (value * price) #计算这些物品总价
return total_price
#清空购物车
def clear_shoppingcar(self):
self.read_shoppingcar() # 刷新数据============================
self.shopcar_dict = {}
self.write_shoppingcar()
#将信息写入到购物车文件
def write_shoppingcar(self):
with open(path,'wb') as f:
pickle.dump(self.shopcar_dict,f)
#将信息从购物车文件读出
def read_shoppingcar(self):
with open(path,'rb') as f:
self.shopcar_dict = pickle.load(f)
- 用户类
'''
用户类：
姓名 用户id【这个标识对于每个用户而言是唯一的]】 密码 拥有购物车 用户登录状态【默认为 False 表示没有登录】
'''
from shopcar_project.shoppingcar import ShoppingCar
class User(object):
__slots__ = ("uid","uname","upwd","ushopcar","ulog")
def __init__(self,uid,uname,upwd): #写在init当中的参数可以理解为其他文件可以访问的接口
self.uid = uid
self.uname = uname
self.upwd = upwd
self.ushopcar = ShoppingCar() #每次用户初始化一个购物车，都为空
self.ulog = False
def __str__(self):
return f"【用户】(uid:{self.uid},uname:{self.uname},ulog:{self.ulog})"
__repr__ = __str__
if __name__ == '__main__':
a = User('01','zh',134,)
a.ulog = True
print(a)
- 操作类
'''
操作类
因为一个程序可能有很多用户，则需要将用户保存在本地
将注册的用户添加在字典中
key：用户id 【用户id随机产生即可，从10000~99999中随机产生一个】
value：对应的用户对象
行为：
用户注册——》根据下面信息生成一个用户，并将用户保存在本地
随机产生 id
输入姓名和密码
创建一个购物车对象
登录 ——》 登录成功返回为 True 否则返回为 False
输入用户id 检测是否有该用户 没有的话提示注册
有的话检测用户登录状态 若为 True 提示已登录
否则 再输入密码进行登录
不要忘记修改用户的登录状态
购买商品 ——》验证用户是否登录，没有登录提示登录
否则，列出仓库中商品名单
1. Mac电脑
2.PythonBook
3.草莓键盘
4.iPhone
用户输入对应的编号 在仓库中获得对应的商品
用户输入数量 — 与该商品的的剩余量对比
> 剩余量:让用户重新输入并提示该商品的剩余量
<=剩余量:将该商品添加在该用户的购物车中,并将仓库中的数据量做出相应的减少
注意：将修改之后的结果同步在本地文件中，时刻保持数据的正确性
删除购物车的商品——》验证用户是否登录，没有登录提示登录
否则,请用户输入商品名字 查看该用户的购物车中是否有该商品
如果没有，提示购物车中没有该商品,否则：
先选择要删除的商品
请用户设置删除的数量
数量 >= 购物车中商品数量
购物车清单中删除该商品
否则：
购物车清单中做出相应的减少
注意：将修改之后的结果同步在本地文件中，时刻保持数据的正确性
结算——》验证用户是否登录 没有登录提示登录
否则获取该用户的购物车中商品清单，计算总额
注意： 结算完成 购物车清空
注意：将修改之后的结果同步在本地文件中，时刻保持数据的正确性
退出登录———》验证用户是否登录 没有登录提示登录
否则修改用户登录状态
注意：将修改之后的结果同步在本地文件中，时刻保持数据的正确性
您的注册id为18793,您的注册账号是：dd123，您的注册密码是：123456
'''
import os,pickle,random,string
from shopcar_project.user import User
from shopcar_project.storage import Storage
from shopcar_project.shoppingcar import ShoppingCar
path = r"user_list.txt"
'''
新建一个存储数据的类，首先要思考的是数据是通过什么格式存放到文件中的，
然后根据这种格式设置类当中的属性
'''
class Option(object):
__slots__ = ("user_dict",)
def __init__(self):
self.__load_user()
# __init__-判断文件是否存在
def __load_user(self):
if os.path.exists(path):
#文件存在,直接反序列化获取
self.user_dict = self.read_user_list()
else:
#文件不存在,将user_dict初始化
self.user_dict = {}
# 所有需要更新的函数-定义一个序列化函数
def write_user_list(self,ob):
with open(path,'wb') as f:
pickle.dump(ob,f)
# __load_user-定义一个反序列化函数
def read_user_list(self):
with open(path,'rb') as f:
return pickle.load(f)
# =====以下是功能实现=====
# 用户注册-产生随机id
def __make_id(self):
while 1:
r = random.choice(range(10000,100000))
if r not in self.user_dict:
return r
# 用户注册-校验用户名
def __check_uname(self,uname):
while 1:
if len(uname) == 5:
for i in uname:
if i not in string.ascii_letters + string.digits:
print('只能输入字母和数字！')
break
else:
return uname
else:
print('长度错误，请重新输入！')
uname = input('请输入你要注册的用户名（字母和数字组成，长度为5位）：')
# 用户注册-校验密码
def __check_upwd(self,upwd):
while 1:
if len(upwd) == 6:
for i in range(3):
passward = input('请重新输入密码确认:')
if passward == upwd:
return upwd
else:
print(f'你还有{3 - i - 1}次机会')
else:
print('长度不够，请重新输入！')
upwd = input('请输入你的密码（字母和数字和符号组成，长度为6位）：')
#1.用户注册
def user_register(self):
uid = self.__make_id()
uname = input('请输入你要注册的用户名（字母和数字组成，长度为5位）：')
uname = self.__check_uname(uname)
upwd = input('请输入你的密码（字母和数字和符号组成，长度为6位）：')
upwd = self.__check_upwd(upwd)
print("注册成功!")
uobj = User(uid,uname,upwd)
self.user_dict[uid] = uobj
self.write_user_list(self.user_dict) #更新到数据库当中
print(f'您的注册id为{uid},您的注册账号是：{uname}，您的注册密码是：{upwd}')
#用户登录-检查密码正确性
def __check_np(self,uid,upwd):
if upwd == self.user_dict[uid].upwd:
self.user_dict[uid].ulog = True
self.write_user_list(self.user_dict)
return True
else:
return False
#2.用户登录
def user_login(self,uid):
self.user_dict = self.read_user_list() #读入数据++++++++++++++++++++++++++++++++++
if uid in self.user_dict:
#用户已经登录
if self.user_dict[uid].ulog == True:
print('该账号已经登陆成功！')
return True
else:
#修改登录状态
upwd = input('请输入您的登录密码：')
if self.__check_np(uid,upwd):
print('登陆成功！')
return True
else:
print('您输入的密码有误，登录失败！')
return False
else:
print('该id未注册！')
#购买商品-显示商品列表
def __show_good_list(self):
L1 = [] #暂时记录商品名称的列表，方便查询，最后返回
i1 = 1 #记录商品编号
print('=====商品列表=====')
for i in Storage().goods_list: #单例类
L1.append(i.gname)
print(f'{i1}.{i.gname}---剩余：{i.gremain}')
i1 += 1
print('=====over=====')
return L1
# 购买商品-把商品添加到购物车当中
def __add_shopcar(self,uid,name,number):
storage = Storage() #创建一个商品库对象
self.user_dict = self.read_user_list() # 读入数据++++++++++++++++++++++++++++++++++
for i in storage.goods_list: #goods_list是一个列表，其中每个元素是商品对象
if name == i.gname:
i.gremain -= number
# 把商品添加到购物车当中，这里没有导入Shoppingcar类，是通过User类动态绑定的属性去访问Shoppingcar当中的方法 （★★★★★）
# 必须要通过对象去访问对应对象的购物车，这样才不会出错
self.user_dict[uid].ushopcar.add_goods(name,number)
storage.write_storage() #修改商品列表
self.write_user_list(self.user_dict) #修改用户信息列表
# 购买商品-校验用户输入的商品编号是否在现有商品列表中：
def is_goos_in_glist(self,g_num,L):
while True:
if g_num in range(1, len(L) + 1):
# print('该商品存在~')
return L[g_num - 1] #返回商品名
else:
print('该商品不存在！')
g_num = int(input('请重新输入你要购买的商品编号：'))
#3.购买商品
def add(self,uid):
self.user_dict = self.read_user_list() #读入数据++++++++++++++++++++++++++++++++++
if uid in self.user_dict:
if self.user_dict[uid].ulog == True:
# a.用户已经登录,显示仓库中商品名单，
L2 = self.__show_good_list()
# b.用户购买
g_num = int(input('输入你要购买的商品编号：'))
#校验g_num并且返回g_num对应的商品名
gname = self.is_goos_in_glist(g_num,L2)
print(f"您要购买的商品是{gname}")
g = int(input('输入你要购买的商品个数：'))
# 校验要购买的商品个数
g_remain = Storage().get_goods_remain(gname)
while 1:
if g <= g_remain:
#购物车添加对应商品
self.__add_shopcar(uid,gname,g)
break
else:
g = int(input(f'你要购买的商品个数余量不足，请重新输入：'))
else:
# b.用户未登录
print('用户未登录，请登录！')
else:
print('该用户未注册！')
#4.删除购物车商品
def del_shop_car_goods(self,uid):
self.user_dict = self.read_user_list() #读入数据++++++++++++++++++++++++++++++++++
if uid in self.user_dict:
if self.user_dict[uid].ulog == False:
print('该账号未登录！')
else:
#a.先展示购物车信息
ShoppingCar().show_shopping_car()
#b.提示选择要删除的商品以及数量
d_name = input('请输入您要在购物车当中删除的商品名：')
d_num = int(input('请输入您要在购物车当中删除的商品数量：'))
#c.调用shoppingcar当中的删除函数删除购物车当中的商品
ShoppingCar().del_goods(d_name, d_num)
#d.展示购物车信息【记得测试商品列表有没有发生变化】
ShoppingCar().show_shopping_car()
#e.数据同步到两个表当中【用户表和商品列表】
#del_goods已经通过storage当中的add_goods把数据同步到了商品列表中
self.write_user_list(self.user_dict) #数据同步到用户表
else:
print('该用户未注册！')
#5.结算【清空购物车】
def close_account(self,uid):
self.user_dict = self.read_user_list() #读入数据++++++++++++++++++++++++++++++++++
if uid in self.user_dict:
if self.user_dict[uid].ulog == False:
print('该账号未登录！')
else:
# 调用shoppingcar当中类的方法计算购物车总价
total_price = ShoppingCar().get_price()
if total_price != 0:
# 支付
print(f'您需要支付的总价是：{total_price}元')
a = input('是否确认支付（输入y确认支付，任意键退出支付）：')
if a == 'y':
print('支付成功！')
# 调用shoppingcar当中类的方法清空购物车
# ShoppingCar().clear_shoppingcar() #这里只是清空了新创建购物车对象的购物车
self.user_dict[uid].ushopcar.clear_shoppingcar() #这里只是清空了该对象的购物车
self.write_user_list(self.user_dict) # 数据同步到用户表
# 测试购物车是否清空
ShoppingCar().show_shopping_car()
else:
print('已退出支付！')
else:
print('您的购物车为空！')
else:
print('该用户未注册！')
#6.退出登录
def logout(self,uid):
self.user_dict = self.read_user_list() #读入数据++++++++++++++++++++++++++++++++++
if uid in self.user_dict:
if self.user_dict[uid].ulog == False:
print('该账号未登录！')
else:
print('账号退出登录成功！')
self.user_dict[uid].ulog = False
self.write_user_list(self.user_dict) #数据同步到用户表
else:
print('该用户未注册！')
if __name__ == '__main__':
a = Option()
# a.user_login(26562) #该账号已经登陆成功！
# a.add(26562)
# a.del_shop_car_goods(26562)
# a.close_account(26562)
#测试购物车异常【每次购物车清空后再调用里面还存放了信息】
# a.user_register() #注册完的id是随机的，所以每次注册都是新账号，要记下
# a.user_login(18793)
# a.add(18793)
# a.close_account(18793)
# a.logout(18793)
# a.user_login(18793)
# a.add(18793) #有问题
# a.close_account(18793)
# a.del_shop_car_goods(18793)
# a.add(18793)
# a.close_account(18793)
# a.close_account(18793)
# a.add(18793)
# a.del_shop_car_goods(88846)
# a.del_shop_car_goods(88846)
- 测试模块
from shopcar_project.option import Option
def main():
admin = Option()
print("欢迎进入疋瓞的自助购物系统".center(40,"*"))
while True:
print("""该系统有如下功能：
1.用户注册
2.用户登录
3.退出系统""")
choice = input("请输入你需要进行的操作：")
if choice == "1":
admin.user_register()
elif choice == "2":
a = int(input('请输入用户id：'))
if admin.user_login(a):
print("========登陆成功========")
while True:
print("""选择操作：
1.购买商品
2.删除商品
3.结算购物车
4.退出登录""")
choice1 = input("请输入你需要进行的操作：")
if choice1 == "1":
admin.add(a)
elif choice1 == "2":
admin.del_shop_car_goods(a)
elif choice1 == "3":
admin.close_account(a)
elif choice1 == "4":
admin.logout(a)
break
else:
print("输入有误，没有此操作")
elif choice == "3":
print("=============欢迎再次使用=============")
break
else:
print("输入有误，没有此功能")
if __name__ == '__main__':
main()
2、项目难点
-
2.1、项目过程中遇到的报错
-
错误1：错写init
-
错误2：写错单例类
-
错误3：对类中动态绑定属性理解有误
-
错误4：从同一包当中导入模块当中的类
-
错误5：给同一文件夹建一个txt文件写路劲的
-
错误6：不会写类中的动态绑定属性
-
错误7：没有加载类中属性字典
-
错误8：没法清空购物车【错误在于：修改对象不是想要修改的而是新建的】
-
错误9：字典错误
-
3、项目总结
- 3.1、各个模块之间的关系：
- 3.2、遇到的问题笔记：
1、疑问：单例类中那个闭包函数可以复用吗？
#疑问：单例类中那个闭包函数中做标记的变量可以保持多久？
def decorate_class1(cls):
sign = None
print(f'sign = None被执行，sign为：{sign}')
def inner_solo(*args,**kwargs): #打包
nonlocal sign
if sign == None:
sign = cls(*args, **kwargs) #拆包 创建对象
return sign
return inner_solo
@decorate_class1 #这里执行过程为：decorate_class1(Solo)，执行结果为：Solo指向inner_solo()
class Solo(object):
def __init__(self,name,age):
self.name = name
self.age = age
@decorate_class1 #这里执行过程为：decorate_class1(Double)，执行结果为：Double指向inner_solo()
class Double(object):
def __init__(self,time):
self.time = time
#测试能否通过一个模板，来写两个单例类
a = Solo('zhangsan',14)
print(a,a.name,a.age)
b = Solo('lisi',20)
print(b,b.name,b.age)
c = Double(67)
print(c,c.time)
d = Double(96)
print(d,d.time)
'''
sign = None被执行，sign为：None
sign = None被执行，sign为：None
<__main__.Solo object at 0x000001B7C3F66DF0> zhangsan 14
<__main__.Solo object at 0x000001B7C3F66DF0> zhangsan 14
<__main__.Double object at 0x000001B7C3F66CA0> 67
<__main__.Double object at 0x000001B7C3F66CA0> 67
总结：
单例类模板可以多次复用
'''
2、疑问：类初始化没有设置形参的属性，在init中给了默认值，在类外访问能否修改该属性默认值
# 疑问：类初始化没有设置形参的属性，在init中给了默认值，在类外访问能否修改该属性默认值
class Name(object):
__slots__ = ("name","time") #这里面放属性名
def __init__(self,name):
self.name = name
self.time = 18
def __str__(self):
return f"name:{self.name};time:{self.time}"
a = Name('zhangsan')
a.time = 20
print(a) #name:zhangsan;time:20
3、对象可以做字典key吗？
# 疑问：类初始化没有设置形参的属性，在init中给了默认值，在类外访问能否修改该属性默认值
class Ob(object):
def __init__(self,eat):
self.eat = eat
class Name(object):
def __init__(self,name):
self.name = name
self.Ob_ject = Ob(55)
def __str__(self):
return f"Ob_ject:{self.Ob_ject};"
a = Name('ad')
print(a) #Ob_ject:<__main__.Ob object at 0x000001C07EB30C70>;
4、购物车项目中的购物车数据能否保留到用户下次登录
答：【不会，参考析构函数】如果想要保留就给购物车建个文件
5、python中A模块调用B模块，B模块能否调用A模块【答案是不能，理由是这是循环导入的一种错误，具体实验如下】
路径一：“D:\code\python\test_package\module1.py”，建立一个模块
from test_package.module2 import Module2
class Module1(object):
def __init__(self,name,food):
self.name = name
self.food = food
def eat(self):
print(f'{self.name}eat{self.food}')
b = Module2('m2_xiaoming','米饭')
'''
执行结果：
ImportError: cannot import name 'Module1' from partially initialized module ImportError: cannot import name 'Module2' from partially initialized module 'test_package.module2'
(most likely due to a circular import) (D:\code\python\day24\test_package\module2.py)
'''
路径二：“D:\code\python\test_package\module2.py”，建立一个模块
from test_package.module1 import Module1
class Module2(object):
def __init__(self,name,food):
self.name = name
self.food = food
def eat(self):
print(f'{self.name}eat{self.food}')
b = Module1('m1_xiaoming','米饭')
'''
执行结果：
ImportError: cannot import name 'Module1' from partially initialized module 'test_package.module1'
(most likely due to a circular import) (D:\code\python\day24\test_package\module1.py)
'''
6、python中找错的方法：先定位到系统提示位置，然后在分析，从上面代码中就近原则找错
878
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
