用python编写ATM+购物车(改进)

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 # Author:James Tao
 4 
 5 import os
 6 import sys
 7 import pickle
 8 
 9 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
10 
11 #调用程序
12 core_DIR = BASE_DIR + ‘\\‘ + ‘core‘
13 sys.path.append(core_DIR)# 添加环境变量
14 
15 
16 
17 while True:
18     menu=input(‘‘‘
19 请输入对应序号选择功能：
20 1.注册
21 2.查账单
22 3.支付
23 4.还款
24 5.提款
25 6.冻结
26 输入其它退出
27     ‘‘‘)
28 
29     if menu==‘1‘:
30 
31         #注册
32         from atmfunction import register
33         register()
34 
35     elif menu==‘2‘:
36         from atmfunction import check
37 
38         check()
39 
40 
41     elif menu==‘3‘:
42 
43         r_money = open(BASE_DIR + ‘\\‘ + ‘docs‘ + ‘\\‘ + ‘money‘ + ‘.txt‘, ‘rb‘)
44         list_money = pickle.load(r_money)
45         r_money.close()
46 
47         money=list_money[0]
48         print(‘您需要支付的金额为：‘,money)
49 
50         from atmfunction import pay
51         pay(money)
52 
53         exit()
54 
55     elif menu==‘4‘:
56 
57         repaymoney=int(input(‘请输入您要还款的金额：‘))
58 
59         from atmfunction import repay
60 
61         repay(repaymoney)
62 
63     elif menu==‘5‘:
64 
65         drawmoney=int(input(‘请输入提款金额：‘))
66 
67         from atmfunction import draw
68 
69         draw(drawmoney)
70 
71     elif menu==‘6‘:
72 
73         from atmfunction import freeze
74 
75         freeze()
76 
77 
78     else:
79         exit()

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 # Author:James Tao
 4 import os
 5 import sys
 6 
 7 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 8 
 9 def useraccess(name,passwd):
10 
11     atmuser = name
12     atmpasswd = passwd
13 
14     # 判断账户是否被冻结
15     if os.path.exists(BASE_DIR + ‘\\‘ + ‘docs‘ + ‘\\‘ + ‘atmfreezeuser‘ + ‘.txt‘):
16 
17         # 读取冻结账户文件内账户
18         r_freezeuser = open(BASE_DIR + ‘\\‘ + ‘docs‘ + ‘\\‘ + ‘atmfreezeuser‘ + ‘.txt‘, ‘rb‘)
19         freezeuser = pickle.load(r_freezeuser)
20         r_freezeuser.close()
21 
22         if atmuser in freezeuser:
23             # 如果账户被冻结直接退出函数
24             print(‘该账户已被冻结‘)
25             return False
26 
27     # 验证用户是否存在
28     if os.path.exists(BASE_DIR + ‘\\‘ + ‘docs‘ + ‘\\‘ + atmuser + ‘atmpasswd‘ + ‘.txt‘):
29         # 读出用户信息，登陆密码
30         r_atmuser_passwd = open(BASE_DIR + ‘\\‘ + ‘docs‘ + ‘\\‘ + atmuser + ‘atmpasswd‘ + ‘.txt‘, ‘rb‘)
31         read_atmuser_passwd = pickle.load(r_atmuser_passwd)
32         r_atmuser_passwd.close()
33 
34         # 判断输入的账号是否存在密码是否正确
35         if atmuser in read_atmuser_passwd and atmpasswd == read_atmuser_passwd[atmuser]:
36             return True
37         else:
38             print(‘密码错误！‘)
39             return False
40     else:
41         print(‘账户不存在！‘)
42         return False

  1 #!/usr/bin/env python
  2 # -*- coding:utf-8 -*-
  3 # Author:James Tao
  4 
  5 import os
  6 import sys
  7 import pickle
  8 
  9 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 10 
 11 #将登陆验证地址加入系统环境变量
 12 core_DIR=BASE_DIR+‘\\‘+‘core‘
 13 sys.path.append(core_DIR)
 14 
 15 #注册装饰器
 16 def register_wrapper(func):
 17     def wrapper(*args, **kwargs):
 18 
 19         atmuser = input(‘请输入用户名(由字母数字下划线组成)：‘)
 20         atmpasswd = input(‘请输入密码(由字母数字下划线组成)：‘)
 21 
 22         # 将用户密码存入字典
 23         atm_passwd = {}
 24         atm_passwd[atmuser] = atmpasswd
 25 
 26         # 将用户密码字典写入文件
 27         w_atm_passwd = open(BASE_DIR + ‘\\‘ + ‘docs‘ + ‘\\‘ + atmuser + ‘atmpasswd‘ + ‘.txt‘, ‘wb‘)
 28         pickle.dump(atm_passwd, w_atm_passwd)
 29         w_atm_passwd.close()
 30 
 31         # 将用户信息存入字典
 32         atmuser_info = {}
 33         atmuser_info[‘balance‘] = 50000
 34 
 35         print(‘‘‘用户{_atmuser}恭喜您注册成功，您的信用卡账户余额为{_balance}元。
 36                     ‘‘‘.format(_atmuser=atmuser, _balance=atmuser_info[‘balance‘]))
 37 
 38         # 将用户信息字典写入文件
 39         w_atmuser_info = open(BASE_DIR + ‘\\‘ + ‘docs‘ + ‘\\‘ + atmuser + ‘atminfo‘ + ‘.txt‘, ‘wb‘)
 40         pickle.dump(atmuser_info, w_atmuser_info)
 41         w_atmuser_info.close()
 42 
 43     return wrapper
 44 
 45 @register_wrapper
 46 def register():
 47     pass
 48 
 49 
 50 #登陆装饰器
 51 def check_wrapper(func):
 52     def wrapper(*args,**kwargs):
 53 
 54         atmuser = input(‘请输入用户名：‘)
 55         atmpasswd = input(‘请输入密码：‘)
 56 
 57         # 账户冻结和密码验证
 58         from atmuseraccess import useraccess
 59         login = useraccess(atmuser,atmpasswd)
 60 
 61         # 判断账户是否验证成功
 62         if login:
 63             # 读出用户信息，显示账户余额
 64             r_atmuser_info = open(BASE_DIR + ‘\\‘ + ‘docs‘ + ‘\\‘ + atmuser + ‘atminfo‘ + ‘.txt‘, ‘rb‘)
 65             read_atmuser_info = pickle.load(r_atmuser_info)
 66             r_atmuser_info.close()
 67 
 68             need_repay=50000-read_atmuser_info[‘balance‘]
 69 
 70             # 显示账户余额
 71             print(‘‘‘
 72 -----用户{_atmuser}登陆成功！您的账户信息如下-----\n
 73 可用余额:{_balance}元\n
 74 需还款金额:{_needrepay}元
 75                 ‘‘‘.format(_atmuser=atmuser, _balance=read_atmuser_info[‘balance‘],_needrepay=need_repay))
 76 
 77 
 78     return wrapper
 79 
 80 @check_wrapper
 81 def check():
 82     pass
 83 
 84 #支付
 85 def pay_wrapper(func):
 86     def wrapper(*args,**kwargs):
 87 
 88         print(‘您好！请登录ATM！‘)
 89         atmuser = input(‘请输入用户名：‘)
 90         atmpasswd = input(‘请输入密码：‘)
 91 
 92         # 账户冻结和密码验证
 93         from atmuseraccess import useraccess
 94         login = useraccess(atmuser,atmpasswd)
 95 
 96         #验证成功
 97         if login:
 98             # 读出用户信息，显示账户余额
 99             r_atmuser_info = open(BASE_DIR + ‘\\‘ + ‘docs‘ + ‘\\‘ + atmuser + ‘atminfo‘ + ‘.txt‘, ‘rb‘)
100             read_atmuser_info = pickle.load(r_atmuser_info)
101             r_atmuser_info.close()
102 
103             # 显示账户余额
104             print(‘‘‘用户{_atmuser}登陆成功，您的账户余额为{_balance}元。
105             ‘‘‘.format(_atmuser=atmuser, _balance=read_atmuser_info[‘balance‘]))
106 
107             paymoney = args[0]
108             print(‘您需要付款的金额为：%s元‘ % paymoney)
109             if paymoney <= read_atmuser_info[‘balance‘]:
110 
111                 pay_or_out = input(‘确定付款请输入Y：‘)
112                 if pay_or_out==‘Y‘:
113 
114                     #计算余额
115                     balance=read_atmuser_info[‘balance‘]-paymoney
116 
117                     # 将用户信息存入字典
118                     atmuser_info = {}
119                     atmuser_info[‘balance‘] = balance
120 
121                     #存入文件
122                     w_atmuser_info = open(BASE_DIR + ‘\\‘ + ‘docs‘ + ‘\\‘ + atmuser + ‘atminfo‘ + ‘.txt‘, ‘wb‘)
123                     pickle.dump(atmuser_info, w_atmuser_info)
124                     w_atmuser_info.close()
125 
126                     #支付成功更改支付成功中间文件
127                     pay_accomplished=[‘accomplished‘]
128                     w_pay_accomplished=open(BASE_DIR + ‘\\‘ + ‘docs‘ + ‘\\‘ + ‘pay_accomplish‘ + ‘.txt‘, ‘wb‘)
129                     pickle.dump(pay_accomplished, w_pay_accomplished)
130                     w_pay_accomplished.close()
131 
132                 else:
133                     print(‘验证失败！‘)
134 
135             else:
136                 print(‘支付失败！原因：余额不足！‘)
137     return wrapper
138 
139 @pay_wrapper
140 def pay():
141     pass
142 
143 #还款
144 def repay_wrapper(func):
145     def wrapper(*args,**kwargs):
146 
147         print(‘您好！请登录ATM！‘)
148         atmuser = input(‘请输入用户名：‘)
149         atmpasswd = input(‘请输入密码：‘)
150 
151         # 账户冻结和密码验证
152         from atmuseraccess import useraccess
153         login = useraccess(atmuser,atmpasswd)
154 
155         #验证成功
156         if login:
157 
158             # 读出用户信息，显示账户余额
159             r_atmuser_info = open(BASE_DIR + ‘\\‘ + ‘docs‘ + ‘\\‘ + atmuser + ‘atminfo‘ + ‘.txt‘, ‘rb‘)
160             read_atmuser_info = pickle.load(r_atmuser_info)
161             r_atmuser_info.close()
162 
163             # 显示账户余额和需还款金额
164             need_repaymoney=50000-read_atmuser_info[‘balance‘]
165             print(‘‘‘
166 -----用户{_atmuser}登陆成功，您的账户信息如下-----
167 可用余额:{_balance}元\n
168 需还款金额:{_needrepaymoney}元
169                     ‘‘‘.format(_atmuser=atmuser, _balance=read_atmuser_info[‘balance‘],_needrepaymoney=need_repaymoney))
170 
171 
172             repaymoney = args[0]
173             print(‘您将要还款的金额为：%s元‘ % repaymoney)
174             if repaymoney <= need_repaymoney:
175 
176                 repay_or_out = input(‘确定还款请输入Y：‘)
177                 if repay_or_out == ‘Y‘:
178 
179                     # 计算余额
180                     balance = read_atmuser_info[‘balance‘] + repaymoney
181 
182                     # 将用户信息存入字典
183                     atmuser_info = {}
184                     atmuser_info[‘balance‘] = balance
185 
186                     # 存入文件
187                     w_atmuser_info = open(BASE_DIR + ‘\\‘ + ‘docs‘ + ‘\\‘ + atmuser + ‘atminfo‘ + ‘.txt‘, ‘wb‘)
188                     pickle.dump(atmuser_info, w_atmuser_info)
189                     w_atmuser_info.close()
190 
191                     print(‘还款成功！‘)
192 
193                 else:
194                     print(‘验证失败！‘)
195 
196             else:
197                 print(‘还款失败！原因：超出需还款金额！‘)
198 
199 
200 
201 
202     return wrapper
203 
204 @repay_wrapper
205 def repay():
206     pass
207 
208 #提款
209 def draw_wrapper(func):
210     def wrapper(*args,**kwargs):
211 
212         print(‘您好！请登录ATM！‘)
213         atmuser = input(‘请输入用户名：‘)
214         atmpasswd = input(‘请输入密码：‘)
215 
216         # 账户冻结和密码验证
217         from atmuseraccess import useraccess
218         login = useraccess(atmuser,atmpasswd)
219 
220         #验证成功
221         if login:
222 
223             # 读出用户信息，显示账户余额
224             r_atmuser_info = open(BASE_DIR + ‘\\‘ + ‘docs‘ + ‘\\‘ + atmuser + ‘atminfo‘ + ‘.txt‘, ‘rb‘)
225             read_atmuser_info = pickle.load(r_atmuser_info)
226             r_atmuser_info.close()
227 
228             # 显示账户可提款金额
229             can_drawmoney = read_atmuser_info[‘balance‘]/2.00
230             print(‘‘‘
231 -----用户{_atmuser}登陆成功，您的账户信息如下-----
232 可用余额：{_balance}元\n
233 可提款金额：{_candrawmoney}元
234                      ‘‘‘.format(_atmuser=atmuser, _balance=read_atmuser_info[‘balance‘],_candrawmoney=can_drawmoney))
235 
236             drawmoney = args[0]
237             print(‘您将要提款的金额为：%s元‘ % drawmoney)
238             if drawmoney <= can_drawmoney:
239 
240                 draw_or_out = input(‘确定提款请输入Y：‘)
241                 if draw_or_out == ‘Y‘:
242 
243                     # 计算余额
244                     balance = read_atmuser_info[‘balance‘] - drawmoney
245 
246                     # 将用户信息存入字典
247                     atmuser_info = {}
248                     atmuser_info[‘balance‘] = balance
249 
250                     # 存入文件
251                     w_atmuser_info = open(BASE_DIR + ‘\\‘ + ‘docs‘ + ‘\\‘ + atmuser + ‘atminfo‘ + ‘.txt‘, ‘wb‘)
252                     pickle.dump(atmuser_info, w_atmuser_info)
253                     w_atmuser_info.close()
254 
255                     print(‘提款成功！‘)
256 
257                 else:
258                     print(‘验证失败！‘)
259 
260             else:
261                 print(‘提款失败！原因：超出可提款金额！‘)
262 
263     return wrapper
264 
265 @draw_wrapper
266 def draw():
267     pass
268 
269 #冻结账户
270 def freeze_wrapper(func):
271     def wrapper(*args,**kwargs):
272 
273         print(‘您好！请登录ATM！‘)
274         atmuser = input(‘请输入用户名：‘)
275         atmpasswd = input(‘请输入密码：‘)
276 
277         # 账户冻结和密码验证
278         from atmuseraccess import useraccess
279         login = useraccess(atmuser,atmpasswd)
280 
281         #验证成功
282         if login:
283             # 读出用户信息，显示账户余额
284             r_atmuser_info = open(BASE_DIR + ‘\\‘ + ‘docs‘ + ‘\\‘ + atmuser + ‘atminfo‘ + ‘.txt‘, ‘rb‘)
285             read_atmuser_info = pickle.load(r_atmuser_info)
286             r_atmuser_info.close()
287 
288             print(‘‘‘用户{_atmuser}登陆成功，您的账户可用余额为{_balance}元。
289                 ‘‘‘.format(_atmuser=atmuser, _balance=read_atmuser_info[‘balance‘]))
290 
291             freeze_or_not=input(‘是否确认冻结账户？输入Y确认‘)
292             if freeze_or_not==‘Y‘:
293 
294                 # 将用户名写入文件，每次登陆读取该文件确认是否被冻结
295 
296                 #先判断冻结账户文件是否存在
297                 if os.path.exists(BASE_DIR + ‘\\‘ + ‘docs‘ + ‘\\‘ +  ‘atmfreezeuser‘ + ‘.txt‘):
298 
299                     #读取冻结账户文件内账户
300                     r_freezeuser = open(BASE_DIR + ‘\\‘ + ‘docs‘ + ‘\\‘ + ‘atmfreezeuser‘ + ‘.txt‘, ‘rb‘)
301                     freezeuser=pickle.load(r_freezeuser)
302                     r_freezeuser.close()
303 
304                     freezeuser_list=freezeuser.append(atmuser)
305 
306                     #将用户写入冻结账户文件
307                     w_freezeuser = open(BASE_DIR + ‘\\‘ + ‘docs‘ + ‘\\‘ + ‘atmfreezeuser‘ + ‘.txt‘, ‘wb‘)
308                     pickle.dump(freezeuser_list,w_freezeuser)
309                     w_freezeuser.close()
310 
311                 else:
312                     freezeuser_list=[atmuser]
313 
314                     # 将用户写入冻结账户文件
315                     w_freezeuser = open(BASE_DIR + ‘\\‘ + ‘docs‘ + ‘\\‘ + ‘atmfreezeuser‘ + ‘.txt‘, ‘wb‘)
316                     pickle.dump(freezeuser_list, w_freezeuser)
317                     w_freezeuser.close()
318 
319                 print(‘冻结成功！可联系银行工作人员解冻！‘)
320 
321             else:
322                 print(‘验证失败！您的账户未被冻结！‘)
323 
324     return wrapper
325 
326 @freeze_wrapper
327 def freeze():
328     pass

  1 #!/usr/bin/env python
  2 # -*- coding:utf-8 -*-
  3 # Author:James Tao
  4 
  5 #登陆
  6 import os
  7 import sys
  8 import pickle
  9 
 10 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 11 
 12 #添加商品
 13 shoppinggoods=[
 14     [‘iphone‘,5800],
 15     [‘Mac‘,12000],
 16     [‘Book‘,50],
 17     [‘Bike‘,800],
 18     [‘Coffee‘,30],
 19 ]
 20 
 21 w_seller_shoppinggoods = open(BASE_DIR+‘\\‘+‘docs‘+‘\\‘+‘shoppinggoods.txt‘, ‘wb‘)
 22 pickle.dump(shoppinggoods, w_seller_shoppinggoods)
 23 w_seller_shoppinggoods.close()
 24 
 25 new_or_existuser = input(‘‘‘
 26 请输入序号选择功能：
 27 1.注册
 28 2.登陆
 29 输入其它退出
 30 ‘‘‘)
 31 
 32 # --------------------------------新用户注册输入薪水---------------------------------
 33 if new_or_existuser == ‘1‘:
 34     buyername = input(‘请输入用户名(由字母数字下划线组成)：‘)
 35     buyerpasswd = input(‘请输入密码(由字母数字下划线组成)：‘)
 36 
 37     # 将用户密码存入字典
 38     user_passwd = {}
 39     user_passwd[buyername] = buyerpasswd
 40 
 41     # 将用户密码字典写入文件
 42     w_user_passwd = open(BASE_DIR+‘\\‘+‘docs‘+‘\\‘+buyername + ‘passwd‘ + ‘.txt‘, ‘wb‘)
 43     pickle.dump(user_passwd, w_user_passwd)
 44     w_user_passwd.close()
 45 
 46     # 将用户信息存入字典
 47     user_info = {}
 48     user_info[buyername] = {‘boughtgoods‘: []}
 49 
 50     # 将用户信息字典写入文件
 51     w_user_info = open(BASE_DIR+‘\\‘+‘docs‘+‘\\‘+buyername + ‘info‘ + ‘.txt‘, ‘wb‘)
 52     pickle.dump(user_info, w_user_info)
 53     w_user_info.close()
 54 
 55     # 将用户信息暂时导入到temp_user_info里
 56     temp_user_info = user_info
 57 
 58 
 59 
 60 # ------------------------------旧用户登陆并导入用户信息-------------------------------
 61 elif new_or_existuser == ‘2‘:
 62 
 63     while True:
 64         buyername = input(‘请输入用户名：‘)
 65         buyerpasswd = input(‘请输入密码：‘)
 66 
 67         # 读出用户信息，登陆密码
 68         r_user_passwd = open(BASE_DIR+‘\\‘+‘docs‘+‘\\‘+buyername + ‘passwd‘ + ‘.txt‘, ‘rb‘)
 69         read_user_passwd = pickle.load(r_user_passwd)
 70         r_user_passwd.close()
 71 
 72         # 判断输入的账号是否存在密码是否正确
 73         if buyername in read_user_passwd and buyerpasswd == read_user_passwd[buyername]:
 74 
 75             #判断用户是否购买过商品
 76 
 77             # 读出用户信息，已购买商品
 78             r_user_info = open(BASE_DIR+‘\\‘+‘docs‘+‘\\‘+buyername + ‘info‘ + ‘.txt‘, ‘rb‘)
 79             read_user_info = pickle.load(r_user_info)
 80             r_user_info.close()
 81 
 82             if read_user_info[buyername][‘boughtgoods‘]:
 83                 # 打印用户信息，余额、已购买商品
 84                 print(‘用户%s您好‘ % buyername)
 85                 print(‘------您已够买以下商品------‘)
 86                 for i in read_user_info[buyername][‘boughtgoods‘]:
 87                     print(i)
 88 
 89                 # 将用户信息暂时导入到temp_user_info里
 90                 temp_user_info = read_user_info
 91                 break
 92             else:
 93                 print(‘您还未购买任何商品‘)
 94                 temp_user_info={}
 95                 temp_user_info[buyername] = {‘boughtgoods‘: []}
 96                 break
 97 
 98         else:
 99             print(‘用户名不存在或密码错误，请重新登录‘)
100 
101 else:
102     exit()
103 
104 # 用户注册或登陆之后已经有了用户信息，包括用户名、薪水或余额、已购买商品存在temp_user_info字典里
105 
106 # 从文件中读出商品信息
107 r_shoppinggoods = open(BASE_DIR+‘\\‘+‘docs‘+‘\\‘+‘shoppinggoods.txt‘, ‘rb‘)
108 read_shoppinggoods = pickle.load(r_shoppinggoods)
109 r_shoppinggoods.close()
110 
111 dict_of_bought = {}
112 
113 # 从字典temp_user_info读出用户信息，包括用户名、薪水或余额、已购买商品(以购买商品用数列存储)
114 list_of_bought = temp_user_info[buyername][‘boughtgoods‘]  # 总购买商品用数列存储
115 new_list_of_bought = []#此次购买商品用数列存储
116 money=0
117 
118 # ---------------------------------开始购买流程-------------------------------------
119 while True:
120 
121     # 输出商品及其编号
122     print(‘--------支持购买的商品-------‘)
123     for index, item in enumerate(read_shoppinggoods):  # enumerate取出下标
124         print(index, item)
125         # print(read_shoppinggoods.index(item),item)
126     choice_of_user = input(‘选择购买商品编号\输入q退出:‘)
127 
128     #判断输入是否合法
129     if choice_of_user.isdigit():
130         choice_of_user = int(choice_of_user)
131 
132         # 判断编号是否有对应商品
133         if 0 <= choice_of_user < len(read_shoppinggoods):
134 
135             # 加入购物清单
136             list_of_bought.append(read_shoppinggoods[choice_of_user][0])#总购买商品清单
137             new_list_of_bought.append(read_shoppinggoods[choice_of_user][0])#此次购买商品清单
138 
139             # 计算余额`
140             money += read_shoppinggoods[choice_of_user][1]
141 
142             print(‘‘‘添加{_boughtgood}到您的购物车，该商品价格为{_price}元。
143                 ‘‘‘.format(_boughtgood=read_shoppinggoods[choice_of_user][0], _price=read_shoppinggoods[choice_of_user][1]))
144 
145         else:
146             print(‘商品不存在‘)
147 
148     elif choice_of_user == ‘q‘:
149 
150         # 统计购买的商品及数量
151         category_of_bought = set(new_list_of_bought)
152         for item in category_of_bought:
153             dict_of_bought[item] = list_of_bought.count(item)
154         print(‘您购买的商品及数量分别为‘, dict_of_bought)
155 
156         print(‘您已消费%s元。‘ % money)
157 
158         #判断new_list_of_bought内是否有商品
159         if new_list_of_bought:
160             #开始付款
161             pay_trueorfalse=True
162             payment = input(‘是否付款？(输入p付款\输入其他退出):‘)
163 
164 
165             while pay_trueorfalse:
166 
167                 if payment==‘p‘:
168 
169                     #调用atm.py程序
170                     bin_DIR = BASE_DIR + ‘\\‘ + ‘bin‘
171                     sys.path.append(bin_DIR)# 添加环境变量
172                     from atmfunction import pay
173                     pay(money)
174 
175                     # 判断支付是否成功
176                     #读取中间文件
177                     r_pay_accomplished = open(BASE_DIR + ‘\\‘ + ‘docs‘ + ‘\\‘ + ‘pay_accomplish‘ + ‘.txt‘, ‘rb‘)
178                     pay_accomplished=pickle.load(r_pay_accomplished)
179                     r_pay_accomplished.close()
180 
181 
182                     #若成功
183                     if pay_accomplished[0]==‘accomplished‘:
184 
185                         print(‘支付成功！‘)
186 
187                         #将用户余额和购买商品更新存入字典
188                         temp_user_info[buyername] = {‘boughtgoods‘: list_of_bought}
189 
190                         #将购买商品更新写入文件
191                         w_user_userinfo = open(BASE_DIR+‘\\‘+‘docs‘+‘\\‘+buyername + ‘info‘ + ‘.txt‘, ‘wb‘)
192                         pickle.dump(temp_user_info, w_user_userinfo)
193                         w_user_userinfo.close()
194 
195                         #更改中间文件用于下次验证
196                         pay_accomplished = [‘un_accomplished‘]
197                         w_pay_accomplished = open(BASE_DIR + ‘\\‘ + ‘docs‘ + ‘\\‘ + ‘pay_accomplish‘ + ‘.txt‘, ‘wb‘)
198                         pickle.dump(pay_accomplished,w_pay_accomplished)
199                         w_pay_accomplished.close()
200 
201                         exit()
202 
203                     else:
204                         payment = input(‘支付失败！(输入P重新付款\输入其他退出):‘)
205 
206                 else:
207                     print(‘验证失败!已退出支付！‘)
208                     exit()
209         else:
210             exit()
211 
212     else:
213         print(‘输入不合法‘)