Python之面向对象的综合练习(模拟网上购物)

Pickle模块的使用

  • pickle提供了一个简单的持久化功能,可以将对象以文件的形式存放到磁盘上,此模块只能在Python中使用,且Python中所有数据类型【list,string,tuple,dict,set,对象】都可以使用pickle进行序列化和反序列化
  • pickle.dump(obj,file,protocol = None),其中obj:将要封装的对象;file:obj将要写入的文件对象【注意:必须以二进制可写形式打开,“wb”】;protocol:可选参数,表示告知pickle的协议,支持的协议有0,1,2,3,默认协议为3
import pickle
class Person(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def show(self):
        print("name:%s age:%d" %(self.name,self.age))
p = Person("李四",10)
p.show()

f = open("file1.txt","wb")     #类似于write的使用,文件不存在,则自动创建
pickle.dump(p,f)
f.close()
  • 反序列化:将本地磁盘上存储的对象读取出来
f1 = open("file1.txt","rb")    #要读取的文件对象,file必须以二进制可读的形式打开,"rb"
p1 = pickle.load(f1)
p1.show()

注意:pickle序列化的数据,人一般无法识别

综合练习 【模拟网上购物的整套流程:注册,登录,购买,删除,结算,退出】

  1. 分析:模拟网上购物,需要定义5个类:商品类,用户类,购物车类,仓库类,功能类
  2. 商品类:需要提供商品名称,商品价格和商品剩余量
  3. 用户类:需要提供用户id,用户的密码,用户拥有的购物车,用户的登录状态
  4. 购物车类:程序最始,商品列表为空
  5. 仓库类:信息保存在本地磁盘,程序刚启动时把列表先存储到文件中,之后使用的时候再读出来
  6. 功能类:一个程序可能有很多用户,则需要将用户以字典的形式保存在本地。实现用户的注册,登录,购买,删除,结算,退出操作
"""
商品类:
    商品名称  商品价格  商品剩余量
"""
class Goods(object):
       def __init__(self,name,price,balance):
              self.name = name
              self.prince = prince
              self.balance = balance
       def __str__(self):
              return "[goods] name:%s  prince:%d  balabce:%d" %(self.name,self.price,self.balance)
"""
用户类
    姓名  用户id【这个标识对于每个用户而言是唯一的]】    密码     拥有购物车  用户登录状态【默认为 False 表示没有登录】

"""
class User(object):
       def __init__(self,name,uid,psw,shopping_car,islogin):
              self.name = name
              self.uid = uid
              self.psw = psw
              self.shopping_car = shopping_car
              self.islogin = False
       def __str__(self):
              return "[user] name:%s  uid:%s  pws:%s  shopping_car:%s  islogin:%s" %(self.name,self.uid,self.psw,self.shopping,self.islogin)
"""
购物车类:
    商品列表
"""
class ShoppingCar(object):
       def __init__(self):
              self.good_list = {}
       def __str__(self):
              return "%s" %(self.good_list)
"""
仓库类:【信息保存在本地磁盘:程序刚启动时把列表先存储到文件中,之后使用再读取出来】
	商品列表
 	商品名称    	价格        剩余量
	Mac电脑	   	20000        100
	PthonBook 	30	     200
	草莓键盘        80           60
	Phone		7000	     70
"""
import pickle
import os
def single(cls):
       instance = {}
       def getInstance(*args,**kargs):
              if cls not in instance:
                     instance[cls] = cls(*args,**kargs)
              return instance[cls]
       return getInstance

@single
class Storage(object):
       def __init__(self):
              #程序刚启动时把列表先存储到文件中,之后使用再读取出来
              pass
       #加载商品
       def load_goods(self):
              if not os.path.exists("goodslist.txt"):
                     self.goodlist = []
                     names = ["Mac电脑","Python Book","草莓键盘","iPhone"]
                     prices = [20000,30,80,7000]
                     balances = [100,200,60,70]

                     for i in range(len(names)):
                            #已知根据的商品信息创建一个商品对象出来
                            goods = Goods(names[i],prices[i],balances[i])
                            #将创建好的商品对象添加到商品列表中
                            self.goodslist.append(goods)
                            self.save_goods()
              else:
                     self.custom_load()
#将数据持久化到本地磁盘
def save_goods(self):
    with open("goodslist.txt","wb") as f:
        pickle.dump(self.goodslist,f)

#获取文件中的商品列表
def get_goods(self):
    if os.path.exists("goodslist.txt"):
        self.custom_load()

def custom_load(self):
    with open("goodslist.txt", "rb") as f:
        # 反序列化对象【将文件中对象读取出来】
        # 注意:时刻保证程序中的商品列表和文件中商品列表的一致性
        self.goodslist = pickle.load(f)
import random
class Operation(object):
       #当程序启动起来之后,加载本地用户文件
       def __init__(self):
              self.load_all_user()
              print(self.userlist)
       #加载所有用户
       def load_all_user(self):
              if os.path.exists("user.txt"):
                     #反序列化
                     with open("user.txt","rb") as f:
                            self.userlist = pickle.load(f)
              else:
                     #定义一个字典
                     self.userliat = {}
       #保存用户信息
       def save_user(self):
              #序列化
              with open("user.txt","wb") as f:
                     pickle.dump(self.userlist,f)
       #随机产生一个用户信息
       def get_uid(self):
              #注意:用户id是唯一的,一定不能重复
              while True:
                     uid = str(random.choice(range(10000,100000)))
                     if uid not in self.userlist:
                            return uid
       #用户注册
       def user_register(self):
              uid = self.get_uid()         #获取id
              sc = ShoppingCar()        #购物车对象
              name = input("请输入用户名:")
              psw = input("请输入密码:")
              user = User(name=name,uid=uid,psw=psw,shopping_car=sc)    #创建一个用户
              print(user.uid)
              self.userlist[uid] = user      #将用户添加到用户字典中
              self.save_user()          #同步到本地文件中
       #用户登录
       def user_login(self):
           uid = input("请输入用户id;")
           if uid not in self.userlist:
               print("请先注册")
               return

           #在uid存在的情况下,通过id获取用户的登录状态
           #首先通过uid获取用户
           user = self.userlist[uid]
           if user.islogin:
               return user

           #用户是未登录状态
           while True:
               psw = input("请输入登录密码:")
               if psw == user.psw:
                   user.islogin = True
                   return user

               else:
                   print("请输入正确的密码:")
       #向购物车中添加商品
       def add_goods(self):
           #在添加商品之前,校验用户是否登录成功
           user = self.user_login()
           if user == None:
               print("请先进行登录:")
               return

           #说明用户已经登录
           print("""
           0.Mac电脑
           1.Python Book
           2.草莓键盘
           3.iPhone
           """)
           #引导用户进行选择商品
           index = int(input("请输入商品编号:"))
           #获取仓库
           storage = Storage()
           #print(storage.__dir__())
           #从商品列表中获取商品对象
           goods = storage.goodslist[index]
           #引导用户输入需要购买的商品的数量
           num = int(input("请输入需要购买的商品数量:"))
           if num < 0 :
               print("输入有误")
           else:
               while num > goods.balance:
                   num = int(input("商品剩余量为:%d 请重新输入需要购买的商品数量:"%(goods.balance)))
               else:
                   #重新实例化商品对象
                   user_goods = Goods(goods.name,goods.price,num)
                   #添加到购物车中
                   user.shopping_car.good_list[user_goods] = num
                   #仓库中商品的剩余量发生变化
                   goods.balance -= num

                   #数据发生变化,同步数据到本地文件
                   #更新用户信息
                   self.save_user()
                   #更新商品信息
                   storage.save_goods()

       #删除购物车中的商品
       def del_goods(self):
           user = self.user_login()
           if user == None:
               print("请先登录")
               return

           #说明登录成功
           g_name = input("请输入要删除的商品名称:")
           #定义一个变量,获取该商品对象
           goods = None
           #定义一个变量,用于标记该商品是否存在
           flag = False   #默认不存在

           #遍历用户的购物车的商品列表
           #商品列表是一个字典,key为商品对象,value为商品数量
           for key  in user.shopping_car.good_list:
               if key.name == g_name:
                   goods = key
                   flag = True

           if not flag:
               print("商品不存在")
               return

           #操作仓库
           #在仓库中获取该商品
           storage = Storage()
           index = 0
           for i in range(len(storage.goodslist)):
               if storage.goodslist[i].name == g_name:
                   index = i

           #根据商品的位置获取商品对象
           storage_goods = storage.goodslist[index]

           #引导用户输入需要减少的商品数量
           num = int(input("请输入要减少的商品的数量:"))
           if num >= goods.balance:
               #将该用户对应的商品删除
               user.shopping_car.good_list.pop(goods)
               #仓库中需要加上
               storage_goods.balance += goods.balance

           else:
               goods.balance -= num
               #购物车中的商品的数量更改
               user.shopping_car.good_list[goods] = goods.balance
               # 仓库中需要加上
               storage_goods.balance += num

           #同步数据到本地文件
           self.save_user()
           storage.save_goods()
                   
       #结算购物车
       def give_money(self):
           user = self.user_login()
           if user == None:
               print("请先登录")
               return

           #获取购物车中的所有的商品
           goods_dict  = user.shopping_car.good_list

           #计算所有商品的总价格
           total = 0
           for key,value in goods_dict.items():
               total += value * key.price

           print("总计为:%d" %(total))

           #清空购物车
           goods_dict.clear()

           #保存用户信息
           self.save_user()
              
       #退出
       def exit(self):
           user = self.user_login()
           if user != None:
               user.islogin = False
               # 保存用户信息
               self.save_user()

 

  • 4
    点赞
  • 24
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值