用python编写ATM+购物车程序

购物车程序要求:

1.允许用户根据商品编号购买商品。

2.用户选择商品后,检测余额是否充足,够就直接扣款,不够就提醒。

3.可随时推出,退出时打印以购买商品,购买商品数量及余额。

ATM程序要求:

1.管理账户,添加账户保存到文件。

2.还款、查余额、提款、冻结账户。

3.从购物车收到付款要求时付款。

程序目录结构:

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 while True:
12     menu=input('''
13 请选择功能:
14 1.注册输入注册
15 2.登陆输入登陆
16 3.支付输入支付
17 4.还款输入还款
18 5.提款输入提款
19 6.冻结账户输入冻结
20 输入其它退出
21     ''')
22 
23     if menu=='注册':
24 
25         #注册
26         from atmfunction import register
27         register()
28 
29     elif menu=='登陆':
30         from atmfunction import login
31 
32         login()
33 
34 
35     elif menu=='支付':
36 
37         r_money = open(BASE_DIR + '\\' + 'docs' + '\\' + 'money' + '.txt', 'rb')
38         list_money = pickle.load(r_money)
39         r_money.close()
40 
41         money=list_money[0]
42         print('您需要支付的金额为:',money)
43 
44         from atmfunction import pay
45         pay(money)
46 
47         exit()
48 
49     elif menu=='还款':
50 
51         repaymoney=int(input('请输入您要还款的金额:'))
52 
53         from atmfunction import repay
54 
55         repay(repaymoney)
56 
57     elif menu=='提款':
58 
59         drawmoney=int(input('请输入提款金额:'))
60 
61         from atmfunction import draw
62 
63         draw(drawmoney)
64 
65     elif menu=='冻结':
66 
67         from atmfunction import freeze
68 
69         freeze()
70 
71 
72     else:
73         exit()

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 #注册装饰器
 13 def register_wrapper(func):
 14     def wrapper(*args, **kwargs):
 15 
 16         atmuser = input('请输入用户名(由字母数字下划线组成):')
 17         atmpasswd = input('请输入密码(由字母数字下划线组成):')
 18 
 19         # 将用户密码存入字典
 20         atm_passwd = {}
 21         atm_passwd[atmuser] = atmpasswd
 22 
 23         # 将用户密码字典写入文件
 24         w_atm_passwd = open(BASE_DIR + '\\' + 'docs' + '\\' + atmuser + 'atmpasswd' + '.txt', 'wb')
 25         pickle.dump(atm_passwd, w_atm_passwd)
 26         w_atm_passwd.close()
 27 
 28         # 将用户信息存入字典
 29         atmuser_info = {}
 30         atmuser_info['balance'] = 50000
 31 
 32         print('''用户{_atmuser}恭喜您注册成功,您的信用卡账户余额为{_balance}。
 33                     '''.format(_atmuser=atmuser, _balance=atmuser_info['balance']))
 34 
 35         # 将用户信息字典写入文件
 36         w_atmuser_info = open(BASE_DIR + '\\' + 'docs' + '\\' + atmuser + 'atminfo' + '.txt', 'wb')
 37         pickle.dump(atmuser_info, w_atmuser_info)
 38         w_atmuser_info.close()
 39 
 40     return wrapper
 41 
 42 @register_wrapper
 43 def register():
 44     pass
 45 
 46 
 47 #登陆装饰器
 48 def login_wrapper(func):
 49     def wrapper(*args,**kwargs):
 50 
 51         atmuser = input('请输入用户名:')
 52         atmpasswd = input('请输入密码:')
 53 
 54         #判断账户是否被冻结
 55         if os.path.exists(BASE_DIR + '\\' + 'docs' + '\\' + 'atmfreezeuser' + '.txt'):
 56 
 57             # 读取冻结账户文件内账户
 58             r_freezeuser = open(BASE_DIR + '\\' + 'docs' + '\\' + 'atmfreezeuser' + '.txt', 'rb')
 59             freezeuser = pickle.load(r_freezeuser)
 60             r_freezeuser.close()
 61 
 62             if atmuser in freezeuser:
 63                 print('该账户已被冻结')
 64                 return
 65 
 66 
 67         # 读出用户信息,登陆密码
 68         r_atmuser_passwd = open(BASE_DIR + '\\' + 'docs' + '\\' + atmuser + 'atmpasswd' + '.txt', 'rb')
 69         read_atmuser_passwd = pickle.load(r_atmuser_passwd)
 70         r_atmuser_passwd.close()
 71 
 72         # 判断输入的账号是否存在密码是否正确
 73         if atmuser in read_atmuser_passwd and atmpasswd == read_atmuser_passwd[atmuser]:
 74             # 读出用户信息,显示账户余额
 75             r_atmuser_info = open(BASE_DIR + '\\' + 'docs' + '\\' + atmuser + 'atminfo' + '.txt', 'rb')
 76             read_atmuser_info = pickle.load(r_atmuser_info)
 77             r_atmuser_info.close()
 78 
 79             # 显示账户余额
 80             print('''用户{_atmuser}登陆成功,您的账户余额为{_balance}。
 81                 '''.format(_atmuser=atmuser, _balance=read_atmuser_info['balance']))
 82 
 83 
 84     return wrapper
 85 
 86 @login_wrapper
 87 def login():
 88     pass
 89 
 90 #支付
 91 def pay_wrapper(func):
 92     def wrapper(*args,**kwargs):
 93 
 94         print('您好请先登录atm!')
 95         atmuser = input('请输入用户名:')
 96         atmpasswd = input('请输入密码:')
 97 
 98         # 判断账户是否被冻结
 99         if os.path.exists(BASE_DIR + '\\' + 'docs' + '\\' + 'atmfreezeuser' + '.txt'):
100 
101             # 读取冻结账户文件内账户
102             r_freezeuser = open(BASE_DIR + '\\' + 'docs' + '\\' + 'atmfreezeuser' + '.txt', 'rb')
103             freezeuser = pickle.load(r_freezeuser)
104             r_freezeuser.close()
105 
106             if atmuser in freezeuser:
107                 print('该账户已被冻结')
108                 return
109 
110 
111 
112         #验证用户是否存在
113         if os.path.exists(BASE_DIR + '\\' + 'docs' + '\\' + atmuser + 'atmpasswd' + '.txt'):
114 
115 
116             # 读出用户信息,登陆密码
117             r_atmuser_passwd = open(BASE_DIR + '\\' + 'docs' + '\\' + atmuser + 'atmpasswd' + '.txt', 'rb')
118             read_atmuser_passwd = pickle.load(r_atmuser_passwd)
119             r_atmuser_passwd.close()
120 
121             # 判断输入的账号是否存在密码是否正确
122             if atmuser in read_atmuser_passwd and atmpasswd == read_atmuser_passwd[atmuser]:
123                 # 读出用户信息,显示账户余额
124                 r_atmuser_info = open(BASE_DIR + '\\' + 'docs' + '\\' + atmuser + 'atminfo' + '.txt', 'rb')
125                 read_atmuser_info = pickle.load(r_atmuser_info)
126                 r_atmuser_info.close()
127 
128                 # 显示账户余额
129                 print('''用户{_atmuser}登陆成功,您的账户余额为{_balance}。
130                 '''.format(_atmuser=atmuser, _balance=read_atmuser_info['balance']))
131 
132                 paymoney = args[0]
133                 print('您需要付款的金额为:', paymoney)
134                 if paymoney <= read_atmuser_info['balance']:
135 
136                     pay_or_out = input('确定付款请输入Y:')
137                     if pay_or_out=='Y':
138 
139                         #计算余额
140                         balance=read_atmuser_info['balance']-paymoney
141 
142                         # 将用户信息存入字典
143                         atmuser_info = {}
144                         atmuser_info['balance'] = balance
145 
146                         #存入文件
147                         w_atmuser_info = open(BASE_DIR + '\\' + 'docs' + '\\' + atmuser + 'atminfo' + '.txt', 'wb')
148                         pickle.dump(atmuser_info, w_atmuser_info)
149                         w_atmuser_info.close()
150 
151                         #支付成功更改支付成功中间文件
152                         pay_accomplished=['accomplished']
153                         w_pay_accomplished=open(BASE_DIR + '\\' + 'docs' + '\\' + 'pay_accomplish' + '.txt', 'wb')
154                         pickle.dump(pay_accomplished, w_pay_accomplished)
155                         w_pay_accomplished.close()
156 
157                     else:
158                         print('验证失败')
159 
160                 else:
161                     print('余额不足')
162 
163             else:
164                 print('密码错误')
165 
166         else:
167             print('用户不存在')
168 
169     return wrapper
170 
171 @pay_wrapper
172 def pay():
173     pass
174 
175 #还款
176 
177 def repay_wrapper(func):
178     def wrapper(*args,**kwargs):
179         print('您好请先登录atm!')
180         atmuser = input('请输入用户名:')
181         atmpasswd = input('请输入密码:')
182 
183         # 判断账户是否被冻结
184         if os.path.exists(BASE_DIR + '\\' + 'docs' + '\\' + 'atmfreezeuser' + '.txt'):
185 
186             # 读取冻结账户文件内账户
187             r_freezeuser = open(BASE_DIR + '\\' + 'docs' + '\\' + 'atmfreezeuser' + '.txt', 'rb')
188             freezeuser = pickle.load(r_freezeuser)
189             r_freezeuser.close()
190 
191             if atmuser in freezeuser:
192                 print('该账户已被冻结')
193                 return
194 
195         # 验证用户是否存在
196         if os.path.exists(BASE_DIR + '\\' + 'docs' + '\\' + atmuser + 'atmpasswd' + '.txt'):
197 
198             # 读出用户信息,登陆密码
199             r_atmuser_passwd = open(BASE_DIR + '\\' + 'docs' + '\\' + atmuser + 'atmpasswd' + '.txt', 'rb')
200             read_atmuser_passwd = pickle.load(r_atmuser_passwd)
201             r_atmuser_passwd.close()
202 
203             # 判断输入的账号是否存在密码是否正确
204             if atmuser in read_atmuser_passwd and atmpasswd == read_atmuser_passwd[atmuser]:
205 
206                 # 读出用户信息,显示账户余额
207                 r_atmuser_info = open(BASE_DIR + '\\' + 'docs' + '\\' + atmuser + 'atminfo' + '.txt', 'rb')
208                 read_atmuser_info = pickle.load(r_atmuser_info)
209                 r_atmuser_info.close()
210 
211                 # 显示账户余额和需还款金额
212                 need_repaymoney=50000-read_atmuser_info['balance']
213                 print('''用户{_atmuser}登陆成功,您的账户可用余额为{_balance},需还款金额为{_needrepaymoney}。
214                         '''.format(_atmuser=atmuser, _balance=read_atmuser_info['balance'],_needrepaymoney=need_repaymoney))
215 
216 
217                 repaymoney = args[0]
218                 print('您将要还款的金额为:', repaymoney)
219                 if repaymoney <= need_repaymoney:
220 
221                     repay_or_out = input('确定还款请输入Y:')
222                     if repay_or_out == 'Y':
223 
224                         # 计算余额
225                         balance = read_atmuser_info['balance'] + repaymoney
226 
227                         # 将用户信息存入字典
228                         atmuser_info = {}
229                         atmuser_info['balance'] = balance
230 
231                         # 存入文件
232                         w_atmuser_info = open(BASE_DIR + '\\' + 'docs' + '\\' + atmuser + 'atminfo' + '.txt', 'wb')
233                         pickle.dump(atmuser_info, w_atmuser_info)
234                         w_atmuser_info.close()
235 
236                         print('还款成功!')
237 
238                     else:
239                         print('验证失败')
240 
241                 else:
242                     print('超出需还款金额')
243 
244             else:
245                 print('密码错误')
246 
247         else:
248             print('用户不存在')
249 
250 
251 
252 
253     return wrapper
254 
255 @repay_wrapper
256 def repay():
257     pass
258 
259 #提款
260 def draw_wrapper(func):
261     def wrapper(*args,**kwargs):
262         print('您好请先登录atm!')
263         atmuser = input('请输入用户名:')
264         atmpasswd = input('请输入密码:')
265 
266         # 判断账户是否被冻结
267         if os.path.exists(BASE_DIR + '\\' + 'docs' + '\\' + 'atmfreezeuser' + '.txt'):
268 
269             # 读取冻结账户文件内账户
270             r_freezeuser = open(BASE_DIR + '\\' + 'docs' + '\\' + 'atmfreezeuser' + '.txt', 'rb')
271             freezeuser = pickle.load(r_freezeuser)
272             r_freezeuser.close()
273 
274             if atmuser in freezeuser:
275                 print('该账户已被冻结')
276                 return
277 
278         # 验证用户是否存在
279         if os.path.exists(BASE_DIR + '\\' + 'docs' + '\\' + atmuser + 'atmpasswd' + '.txt'):
280 
281             # 读出用户信息,登陆密码
282             r_atmuser_passwd = open(BASE_DIR + '\\' + 'docs' + '\\' + atmuser + 'atmpasswd' + '.txt', 'rb')
283             read_atmuser_passwd = pickle.load(r_atmuser_passwd)
284             r_atmuser_passwd.close()
285 
286             # 判断输入的账号是否存在密码是否正确
287             if atmuser in read_atmuser_passwd and atmpasswd == read_atmuser_passwd[atmuser]:
288 
289                 # 读出用户信息,显示账户余额
290                 r_atmuser_info = open(BASE_DIR + '\\' + 'docs' + '\\' + atmuser + 'atminfo' + '.txt', 'rb')
291                 read_atmuser_info = pickle.load(r_atmuser_info)
292                 r_atmuser_info.close()
293 
294                 # 显示账户可提款金额
295                 can_drawmoney = read_atmuser_info['balance']/2.00
296                 print('''用户{_atmuser}登陆成功,您的账户可用余额为{_balance},可提款金额为{_candrawmoney}。
297                          '''.format(_atmuser=atmuser, _balance=read_atmuser_info['balance'],_candrawmoney=can_drawmoney))
298 
299                 drawmoney = args[0]
300                 print('您将要提款的金额为:', drawmoney)
301                 if drawmoney <= can_drawmoney:
302 
303                     draw_or_out = input('确定提款请输入Y:')
304                     if draw_or_out == 'Y':
305 
306                         # 计算余额
307                         balance = read_atmuser_info['balance'] - drawmoney
308 
309                         # 将用户信息存入字典
310                         atmuser_info = {}
311                         atmuser_info['balance'] = balance
312 
313                         # 存入文件
314                         w_atmuser_info = open(BASE_DIR + '\\' + 'docs' + '\\' + atmuser + 'atminfo' + '.txt', 'wb')
315                         pickle.dump(atmuser_info, w_atmuser_info)
316                         w_atmuser_info.close()
317 
318                         print('提款成功!')
319 
320                     else:
321                         print('验证失败')
322 
323                 else:
324                     print('超出可提款金额')
325 
326             else:
327                 print('密码错误')
328 
329         else:
330             print('用户不存在')
331 
332 
333     return wrapper
334 
335 @draw_wrapper
336 def draw():
337     pass
338 
339 #冻结账户
340 def freeze_wrapper(func):
341     def wrapper(*args,**kwargs):
342         print('您好请先登录atm!')
343         atmuser = input('请输入用户名:')
344         atmpasswd = input('请输入密码:')
345 
346         # 验证用户是否存在
347         if os.path.exists(BASE_DIR + '\\' + 'docs' + '\\' + atmuser + 'atmpasswd' + '.txt'):
348 
349             # 读出用户信息,登陆密码
350             r_atmuser_passwd = open(BASE_DIR + '\\' + 'docs' + '\\' + atmuser + 'atmpasswd' + '.txt', 'rb')
351             read_atmuser_passwd = pickle.load(r_atmuser_passwd)
352             r_atmuser_passwd.close()
353 
354             # 判断输入的账号是否存在密码是否正确
355             if atmuser in read_atmuser_passwd and atmpasswd == read_atmuser_passwd[atmuser]:
356                 # 读出用户信息,显示账户余额
357                 r_atmuser_info = open(BASE_DIR + '\\' + 'docs' + '\\' + atmuser + 'atminfo' + '.txt', 'rb')
358                 read_atmuser_info = pickle.load(r_atmuser_info)
359                 r_atmuser_info.close()
360 
361                 print('''用户{_atmuser}登陆成功,您的账户可用余额为{_balance}。
362                     '''.format(_atmuser=atmuser, _balance=read_atmuser_info['balance']))
363 
364                 freeze_or_not=input('是否确认冻结账户?输入Y确认')
365                 if freeze_or_not=='Y':
366 
367                     # 将用户名写入文件,每次登陆读取该文件确认是否被冻结
368 
369                     #先判断冻结账户文件是否存在
370                     if os.path.exists(BASE_DIR + '\\' + 'docs' + '\\' +  'atmfreezeuser' + '.txt'):
371 
372                         #读取冻结账户文件内账户
373                         r_freezeuser = open(BASE_DIR + '\\' + 'docs' + '\\' + 'atmfreezeuser' + '.txt', 'rb')
374                         freezeuser=pickle.load(r_freezeuser)
375                         r_freezeuser.close()
376 
377                         freezeuser_list=freezeuser.append(atmuser)
378 
379                         #将用户写入冻结账户文件
380                         w_freezeuser = open(BASE_DIR + '\\' + 'docs' + '\\' + 'atmfreezeuser' + '.txt', 'wb')
381                         pickle.dump(freezeuser_list,w_freezeuser)
382                         w_freezeuser.close()
383 
384                     else:
385                         freezeuser_list=[atmuser]
386 
387                         # 将用户写入冻结账户文件
388                         w_freezeuser = open(BASE_DIR + '\\' + 'docs' + '\\' + 'atmfreezeuser' + '.txt', 'wb')
389                         pickle.dump(freezeuser_list, w_freezeuser)
390                         w_freezeuser.close()
391 
392                     print('冻结成功!可联系银行工作人员解冻!')
393 
394     return wrapper
395 
396 @freeze_wrapper
397 def freeze():
398     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('注册or登陆(注册输入’注册‘\登陆输入’登陆‘):')
 26 
 27 # --------------------------------新用户注册输入薪水---------------------------------
 28 if new_or_existuser == '注册':
 29     buyername = input('请输入用户名(由字母数字下划线组成):')
 30     buyerpasswd = input('请输入密码(由字母数字下划线组成):')
 31 
 32     # 将用户密码存入字典
 33     user_passwd = {}
 34     user_passwd[buyername] = buyerpasswd
 35 
 36     # 将用户密码字典写入文件
 37     w_user_passwd = open(BASE_DIR+'\\'+'docs'+'\\'+buyername + 'passwd' + '.txt', 'wb')
 38     pickle.dump(user_passwd, w_user_passwd)
 39     w_user_passwd.close()
 40 
 41     # 将用户信息存入字典
 42     user_info = {}
 43     user_info[buyername] = {'boughtgoods': []}
 44 
 45     # 将用户信息字典写入文件
 46     w_user_info = open(BASE_DIR+'\\'+'docs'+'\\'+buyername + 'info' + '.txt', 'wb')
 47     pickle.dump(user_info, w_user_info)
 48     w_user_info.close()
 49 
 50     # 将用户信息暂时导入到temp_user_info里
 51     temp_user_info = user_info
 52 
 53 
 54 
 55 # ------------------------------旧用户登陆并导入用户信息-------------------------------
 56 elif new_or_existuser == '登陆':
 57 
 58     while True:
 59         buyername = input('请输入用户名:')
 60         buyerpasswd = input('请输入密码:')
 61 
 62         # 读出用户信息,登陆密码
 63         r_user_passwd = open(BASE_DIR+'\\'+'docs'+'\\'+buyername + 'passwd' + '.txt', 'rb')
 64         read_user_passwd = pickle.load(r_user_passwd)
 65         r_user_passwd.close()
 66 
 67         # 判断输入的账号是否存在密码是否正确
 68         if buyername in read_user_passwd and buyerpasswd == read_user_passwd[buyername]:
 69 
 70             #判断用户是否购买过商品
 71 
 72             # 读出用户信息,已购买商品
 73             r_user_info = open(BASE_DIR+'\\'+'docs'+'\\'+buyername + 'info' + '.txt', 'rb')
 74             read_user_info = pickle.load(r_user_info)
 75             r_user_info.close()
 76 
 77             if read_user_info[buyername]['boughtgoods']:
 78                 # 打印用户信息,余额、已购买商品
 79                 print('用户%s您好' % buyername)
 80                 print('------您已够买以下商品------')
 81                 for i in read_user_info[buyername]['boughtgoods']:
 82                     print(i)
 83 
 84                 # 将用户信息暂时导入到temp_user_info里
 85                 temp_user_info = read_user_info
 86                 break
 87             else:
 88                 print('您还未购买任何商品')
 89                 temp_user_info={}
 90                 temp_user_info[buyername] = {'boughtgoods': []}
 91                 break
 92 
 93         else:
 94             print('用户名不存在或密码错误,请重新登录')
 95 
 96 # 用户注册或登陆之后已经有了用户信息,包括用户名、薪水或余额、已购买商品存在temp_user_info字典里
 97 
 98 # 从文件中读出商品信息
 99 r_shoppinggoods = open(BASE_DIR+'\\'+'docs'+'\\'+'shoppinggoods.txt', 'rb')
100 read_shoppinggoods = pickle.load(r_shoppinggoods)
101 r_shoppinggoods.close()
102 
103 dict_of_bought = {}
104 
105 # 从字典temp_user_info读出用户信息,包括用户名、薪水或余额、已购买商品(以购买商品用数列存储)
106 list_of_bought = temp_user_info[buyername]['boughtgoods']  # 总购买商品用数列存储
107 new_list_of_bought = []#此次购买商品用数列存储
108 money=0
109 
110 # ---------------------------------开始购买流程-------------------------------------
111 while True:
112 
113     # 输出商品及其编号
114     print('--------支持购买的商品-------')
115     for index, item in enumerate(read_shoppinggoods):  # enumerate取出下标
116         print(index, item)
117         # print(read_shoppinggoods.index(item),item)
118     choice_of_user = input('选择购买商品编号\输入q退出:')
119 
120     #判断输入是否合法
121     if choice_of_user.isdigit():
122         choice_of_user = int(choice_of_user)
123 
124         # 判断编号是否有对应商品
125         if 0 <= choice_of_user < len(read_shoppinggoods):
126 
127             # 加入购物清单
128             list_of_bought.append(read_shoppinggoods[choice_of_user][0])#总购买商品清单
129             new_list_of_bought.append(read_shoppinggoods[choice_of_user][0])#此次购买商品清单
130 
131             # 计算余额`
132             money += read_shoppinggoods[choice_of_user][1]
133 
134             print('''添加{_boughtgood}到您的购物车,该商品价格为{_price}元。
135                 '''.format(_boughtgood=read_shoppinggoods[choice_of_user][0], _price=read_shoppinggoods[choice_of_user][1]))
136 
137         else:
138             print('商品不存在')
139 
140     elif choice_of_user == 'q':
141 
142         # 统计购买的商品及数量
143         category_of_bought = set(new_list_of_bought)
144         for item in category_of_bought:
145             dict_of_bought[item] = list_of_bought.count(item)
146         print('您购买的商品及数量分别为', dict_of_bought)
147 
148         print('您已消费%s元。' % money)
149 
150         #判断new_list_of_bought内是否有商品
151         if new_list_of_bought:
152             #开始付款
153             pay_trueorfalse=True
154             payment = input('是否付款?(输入p付款\输入其他退出):')
155 
156 
157             while pay_trueorfalse:
158 
159                 if payment=='p':
160 
161                     #调用atm.py程序
162                     bin_DIR = BASE_DIR + '\\' + 'bin'
163                     sys.path.append(bin_DIR)# 添加环境变量
164                     from atmfunction import pay
165                     pay(money)
166 
167                     # 判断支付是否成功
168                     #读取中间文件
169                     r_pay_accomplished = open(BASE_DIR + '\\' + 'docs' + '\\' + 'pay_accomplish' + '.txt', 'rb')
170                     pay_accomplished=pickle.load(r_pay_accomplished)
171                     r_pay_accomplished.close()
172 
173 
174                     #若成功
175                     if pay_accomplished[0]=='accomplished':
176 
177                         print('支付成功!')
178 
179                         #将用户余额和购买商品更新存入字典
180                         temp_user_info[buyername] = {'boughtgoods': list_of_bought}
181 
182                         #将购买商品更新写入文件
183                         w_user_userinfo = open(BASE_DIR+'\\'+'docs'+'\\'+buyername + 'info' + '.txt', 'wb')
184                         pickle.dump(temp_user_info, w_user_userinfo)
185                         w_user_userinfo.close()
186 
187                         #更改中间文件用于下次验证
188                         pay_accomplished = ['un_accomplished']
189                         w_pay_accomplished = open(BASE_DIR + '\\' + 'docs' + '\\' + 'pay_accomplish' + '.txt', 'wb')
190                         pickle.dump(pay_accomplished,w_pay_accomplished)
191                         w_pay_accomplished.close()
192 
193                         exit()
194 
195                     else:
196                         payment = input('支付失败!(输入P重新付款\输入其他退出):')
197 
198                 else:
199                     print('验证失败!已退出支付!')
200                     exit()
201         else:
202             exit()
203 
204     else:
205         print('输入不合法')

转载于:https://www.cnblogs.com/BIT-taozhen/p/9851951.html

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值