流程控制
'''
1.
用if分支完成猜数字游戏
-- 先通过键盘输入一个数字算作出题
-- 在键盘输入答案
-- 正确：猜对 | 误差3以内：接近了 | 误差外小值：太小 | 误差外大值：太大
'''
quest = int(input("输入一个数字完成出题："))
answer = int(input('输入你的答案：'))
error = quest - answer
if quest == answer:
print('猜对')
elif -3 < error < 3:
print('接近了')
elif error > 3:
print('太大了')
elif error < 3:
print('太小了')
'''
2.
添加循环，让第1题可以循环完成多次猜字游戏
-- 一次循环完成一次出题和猜题
-- 当出题输入Q或q时结束游戏
'''
while True:
#要求出题输入q退出，所以出题的这个变量值quest必须是字符串
quest = input("输入一个数字完成出题,输入q|Q退出：")
end = ['q', 'Q']
if quest in end:
break
# 出题的变量之前已经定义了字符串，接下来要做的都是算数运算，所以不管是出题输入的值还是答案都要转换成数字
quest=int(quest)
answer = int(input('输入你的答案：'))
error = quest - answer
if quest == answer:
print('猜对')
break
elif -3 < error < 3:
print('接近了')
elif error > 3:
print('太大了')
elif error < 3:
print('太小了')
'''
3.
在第二题基础上，完成一次出题可以最多进行三次猜题
-- 一次出题，进入猜题，猜对进入下一次出题
-- 猜错进入下一次猜题，最多错三次，三次全错自动进入下一次出题
'''
while True:
quest = input("输入一个数字完成出题,输入q|Q退出：")
end = ['q', 'Q']
if quest in end:
break
# 先定义一个计数器，目的是为了统计输入错误的次数，当计数器为3，则结束循环，进行上一层循环继续出题
count = 1
while count <= 3:
quest = int(quest)
answer = int(input('输入你的答案：'))
error = answer - quest
if error == 0:
print('猜对')
break
elif -3 < error < 3:
print('接近了')
elif error > 3:
print('太大了')
elif error < 3:
print('太小了')
count += 1
#如果循环结束，表示count已经大于3，提供用户返回信息
else:
print()
print('你已输错3次，请重新输入')
列表的操作
'''
1.循环输入10条信息，如果输入的是自然数，就存放到名为nums的列表中，如果不是，就存放到名为strs列表中
-- nums中存放的数据都是int类型
-- strs中存放的都是字符串类型
-- 最终打印两个列表以及个列表的中元素的个数
'''
(方法一)
nums = []
strs = []
count = 1
while count <= 10:
res = input('请输入正整数或者字符串 ')
if res.isdigit() == True:
nums.append(int(res))
else:
strs.append(res)
count += 1
print('nums变量中存放的元素有%s个，%s' % (len(nums), nums))
print('strs变量量中存放的元素有%s个，%s' % (len(strs), strs))
（方法二）
for i in range(10):
info = input('请输入10条信息 ')
if info.isdigit():
nums.append(int(info))
else:
strs.append(info )
print(nums)
print(strs)
'''
2.完成用list存放注册用户信息的功能：可以循环来完成注册，先输入账号，再输入密码，密码需要二次确认，两次密码一致才能往下进行注册，
如果不一致返回重新注册输入
-- 账号输入Q或q，退出整个程序
-- 账号成功，进行两次密码验证，验证失败直接进入下一次注册
-- 账号必须全部是英文字母3个长度及以上，密码必须是英文或数字3个长度及以上
-- 两次密码验证成功，就注册信息存放到列表中
-- 假设注册成功了Owen，123 | Zero，000两个信息，最终形成的注册结果为
[['Owen', '123'], ['Zero', '000']]
'''
list_1 = [] # 先定义一个人空列表，空列表一定要写在while循环外面，如果写在while循环里面，则每次赋值回到while循环，则都会被重新赋值成空列表
while True:
user = input('请输入账号，输入q/Q退出程序 ')
if user == 'q' or user == 'Q':
break
if not user.isalpha() and len(user) >= 3: # 将满足条件的筛选出来并取反，那么接下来的条件都是成立的
print('注册不成功，请重新输入用户名')
while True:
pwd = input('请输入密码 ')
if pwd:
re_pwd = input('请再次输入密码 ')
if pwd == re_pwd:
info = [user, pwd]
list_1.append(info)
print('注册成功')
break
else:
print('两次密码输入不一致，请重新输入密码 ')
continue
print(list_1)
字典的操作
'''
1.将几个指定字符串形成目标字符串
指定字符串：'I' | 'am' | 'you are a good boy' | '!'
目标字符串：'I am a good boy!'
'''
first = 'I'
second = 'am'
third = 'you are a good boy'
fourth = '!'
third = third[8:]
print('%s %s %s%s' % (first, second, third,fourth))
'''
2.写出你可以想到的所有按要求格式输出列表的解决方案
指定列表：[1, 2, 3, 4, 5]
输出结果：[5, 4, 3, 2, 1]
'''
list1 = [1, 2, 3, 4, 5]
# # (一)
print(sorted(list1, reverse=True))
# # （二）
print(list(reversed(list1)))
# # （三）
print(list1[::-1])
# # reverse方法和sort方法需要先执行再输出
#
# # （四）
list1.reverse()
print(list1)
# （五）
list1.sort(reverse=True)
print(list1)
'''
3.遍历删除包含 Bi词汇(脏话) 的目标
指定列表：['Owen', 'BobSB', 'SBen', 'ZeroS', 'OSBO']
输出结果：['Owen', 'ZeroS']
'''
#方法1: 匹配符合条件的，添加到新的列表（推荐）
list1 = ['Owen', 'BobSB', 'SBen', 'ZeroS', 'OSBO']
list2 = []
source=['Owen', 'BobSB', 'SBen', 'ZeroS', 'OSBO']
res=[]
for i in source:
if 'SB' not in i:
res.append(i)
print(res)
#反向遍历列表，不符合条件的，删除
for i in source[::-1]:
if 'SB' in i:
source.remove(i)
print(source)
'''
4.求得指定元组中是字符串数据的总个数
指定元组：(1, 2, '3', '4', 5, '6', 7, 8, 9)
求的结果：3
'''
#方法1
ls = (1, 2, '3', '4', 5, '6', 7, 8, 9)
list1 = []
for i in ls:
if isinstance(i, str):
list1.append(i)
print(len(list1))
#方法2
ls = (1, 2, '3', '4', 5, '6', 7, 8, 9)
list1 = []
count = 0 #符合条件的自加1，起到计数的作用
for i in ls:
if isinstance(i, str):
list1.append(i)
count += 1
print('字符串个数为%s' % count)
'''
5.求得指定元组中 str数据的个数 与 int数据的个数，存储到字典存放
指定元组：(1, 2, '3', '4', 5, '6', 7, 8, 9)
求的结果：{'str': 3, 'int': 6}
'''
# 方法1
tuple_refer=(1, 2, '3', '4', 5, '6', 7, 8, 9)
dic={}
inter=[]
string=[]
for i in tuple_refer:
if isinstance(i,int):
inter.append(i)
else:
string.append(i)
num_int=len(inter)
num_str=len(string)
dic['str']=num_str
dic['int']=num_int
print(dic)
#方法2
#定义计数器
count_str = 0
count_int = 0
#将元组转换为列表
tuple_refer = (1, 2, '3', '4', 5, '6', 7, 8, 9)
tuple_list = list(tuple_refer)
#判断字符串或者数字，如果判断到，就用各自的计数器自增1
for i in tuple_list:
if isinstance(i, str):
count_str += 1
else:
count_int += 1
print(dict({'str': count_str, 'int': count_int}))
#方法3
tuple_refer = (1, 2, '3', '4', 5, '6', 7, 8, 9)
#使用fromkeys方法为空字典定义key，默认值都设置为0
res = {}.fromkeys(['str', 'int'], 0)
#判断如果是字符串，就在'str'这个key的值加1
for i in tuple_refer:
if isinstance(i, str):
res['str'] += 1
else:
res['int'] += 1
print(res)
'''
6.列表数据的去重
指定列表：[3, 1, 2, 2, 1, 5, 9, 7]
求的结果：[3, 1, 2, 5, 9, 7]
'''
#方法1
list1=[3, 1, 2, 2, 1, 5, 9, 7]
print(list(set(list1)))
#方法2
-----> 定义一个新列表，然后遍历list1，将list1中的值取出来，判断是否包含在新列表list1_new中，如果不包含，就执行插入操作
list1=[3, 1, 2, 2, 1, 5, 9, 7]
list1_new=[]
for i in list1:
if i not in list1_new:
list1_new.append(i)
print(list1_new)
#方法3
list1 = [3, 1, 2, 2, 1, 5, 9, 7]
dic = {}.fromkeys(list1, 0)
dic_keys = dic.keys()
res=list(dic_keys)
print(res)
'''
7.回答字典能不能按索引取值？能不能切片？能去求长度？能否字典与字典拼接？成员运算判断的是key还是value
'''
# 字典不能按索引取值和切片
#字典可以求长度
#字典不可以进行拼接
dic = {'name': 'bob', 'age': 18}
dic3 = {'name2': 'bobbb', 'sex': 'male'}
res=dic.copy()
res.update(dic3)
print(res)
print(len(res))
#成员运算判断key
print('name' in res)
print('name2' in res)
print('age' in res)
print('sex' in res)
'''
8.修改所有以 Bi词汇(脏话) 开头或结尾的字符串，将 Bi词汇 替换为**
指定列表：['Owen', 'BobSB', 'SBen', 'ZeroS', 'OSBO']
运行结果：['Owen', 'Bob**', '**en', 'ZeroS', 'OSBO']
'''
source = ['Owen', 'BobSB', 'SBen', 'ZeroS', 'OSBO']
for v in source:
if v.startswith('SB') or v.endswith('SB'):
index = source.index(v)
source[index] = source[index].replace('SB', '**') #修改source列表里切片里的一个字符串，列表无法用replace
print(source)
函数练习
'''
1）具有进货功能1，销售车辆功能2，展示所有库存功能3，展示销售总业绩功能4
2）用户输入0退出系统，输入提供的功能编号，完成对应的功能，否则重新输入，eg：2就进入销售撤功能
3）车辆信息具有持久化(文件永久)存储功能，车辆有奔驰|宝马|奥迪三款
文件信息：
total.txt: 就是记录了总销售额
car.txt:
宝马 120000 9
奔驰 150000 7
奥迪 100000 8
4）进货功能：选择进货的车型与数量，完成进货
5）销车功能：选择售出的车，有库存售出，更新销售总业绩，没有则进入进货功能
6）展示库存：显示所有车与库存两条信息即可
7）总业绩：显示总业绩金额即可
'''
# 读car.txt
'''
{
'宝马': [120000, 9]
}
{
'宝马': {'price': 120000, 'num': 9}
}
'''
def read_car():
dic = {}
with open('car.txt', 'r', encoding='utf-8') as f:
for n_p in f:
name, price, num = n_p.strip('\n').split(' ')
dic[name] = [int(price), int(num)]
return dic
def write_car(dic):
with open('car.txt', 'w', encoding='utf-8') as f:
for k, v in dic.items():
info = "%s %s %s\n" % (k, v[0], v[1])
f.write(info)
def choose_car():
while True:
car = input('请选择车型 ')
if car in ['宝马', '奔驰', '奥迪']:
return car
def choose_num():
while True:
num = input('请输入数量 ')
if num.isdigit() and int(num) > 0:
return int(num)
def read_total():
with open('total.txt', 'r', encoding='utf-8') as f:
return int(f.read())
def write_total(total):
with open('total.txt', 'w', encoding='utf-8') as f:
f.write(str(total))
# 业绩
# 1.可读可写total.txt
def grade(add_total=0):
if add_total > 0:
total = read_total() + add_total
write_total(total)
else:
print(read_total())
# 库存
def hub():
print('库存功能')
# 1.读car.txt
car_dic = read_car()
# 2.显示
for k, v in car_dic.items():
print(k + ' ' + str(v[1]))
# 售车
def sell():
print('售车功能')
# 1.读car.txt
car_dic = read_car()
# 2.选择车型
car = choose_car()
# 3.选择数量
num = choose_num()
# 4. 判断数量：进货 | 卖货
car_dic[car][1] -= num
write_car(car_dic)
# 5.判断数量：进货 | 卖货
if car_dic[car][1] < num:
print('存活不足')
stock()
# 6.操作业绩
add_total = car_dic[car][0] * num
grade(add_total)
print('售车成功')
# 进货
def stock():
print('进货功能')
# 1.读car.txt
car_dic = read_car()
# 2.选择车型
car = choose_car()
# 3.选择数量
num = choose_num()
car_dic[car][1] += num
# 4.写入car.txt
write_car(car_dic)
# 映射规则
method_map = {
'1': stock,
'2': sell,
'3': hub,
'4': grade
}
# 程序入口
def sys_start():
while True:
cmd = input('''请输入：
1.进货 | 2.售车 | 3.库存 | 4.业绩 | 0.退出
>>>: ''')
if cmd == '0':
break
if cmd in method_map:
method_map[cmd]()
else:
print('指令错误，重来')
sys_start()
需求：
1.用户信息由user.info文件存放，内容格式：abc|123|0,qwe|123|1000
2.实现 登录，注册，注销，购物，充值，退出系统 六个功能
3.注册可以完成用户的注册，注册时要提供账号密码，初始财产余额为0
1）注册先输入账号，要对账号做 输入的是否为空、输入的账号是否已经存在两种判断，都通过进入输入密码，否则重新输入
2）输入密码，要对密码长度最短为3位的限制，长度3位或以上代表合法，可以完成注册
3）注册是将账号密码写入文件，财产余额初始为0，
第一次写入格式：账号|密码|余额
再次写入格式：,账号|密码|余额
4.用户登录状态需要保存，在程序运行的py文件最上方定义一个user字典，字典为空代表未登录，为{'usr': 账号, 'ps': 密码, 'money': 余额}代表登录，记录的就是当前登录的用户
5.完成用户登录
1）解析user.info文件，将用户信息存放到users_dic字典中，格式见下，解析的过程可以定义为方法，
{
'abc': {'ps': '123', 'money': 0},
'qwe': {'ps': '000', 'money': 1000}
}
2）判断用户是否登录了，如果登录了就提示不需要重复登录，未登录就可以往下走，完成登录
3）先输入账号，账号为空、不存在都会验证失败，继续输入，3次失败后就可以进入注册功能，验证通过进行玩下
4）再输入密码，密码必须超过3位，3次登录失败退出登录，成功的记录登录的用户信息到user字典，表示已登录
6.用户注销，就是清楚登录状态，将存放登录用户信息的user字典制空user={}
7.用购物功能完成购物，
1）必须在登录状态，未登录时，进入登录页面，已登录则可以购物
2）预定义一些商品与价格，每一次完成购物后，提示用户是否继续进行购物
3）如果余额不足则进入充值功能
8.充值功能
1）必须在登录状态才可以操作
2）充值后的金额数据要同步到user.info文件，user字段和user_dic字典中
9.退出系统，将退出系统，但注册的用户和余额都保存在文件中
```python
#!/usr/bin/env python
user = {}
# 登陆认证装饰器: 确认用户是否登陆
def check_login(func):
def inner(*args, **kwargs):
if not user:
login()
return func(*args, **kwargs) # 返回原函数的返回值
return inner # 返回原函数的函数名
'''1. 用户信息由user.info文件存放，内容格式：abc|123|0,qwe|123|1000
账号|密码|余额,账号|密码|余额'''
# 读文件
def _read_file():
dic = {}
with open('user.info2', 'r', encoding='utf-8') as f:
a = f.read()
if a: # 判断能够读出文件内容，写入字典；否则不操作，最后应该输出还是空字典
for i in a.split(','):
res = i.split('|')
dic[res[0]] = {'ps': res[1], 'money': int(res[2])}
# dic={'abc': {'ps': '123', 'money': 0}, 'qwe': {'ps': '123', 'money': 1000}}
return dic
# 写文件
def _write_file(dic):
info = ''
for x, y in dic.items(): # x=abc,y={'ps': '123', 'money': 0}
u = x
v = y['ps']
w = y['money']
info += '%s|%s|%s,' % (u, v, w)
info = info.rstrip(',')
with open('user.info2', 'w', encoding='utf-8') as f:
f.write(info)
# 注册
'''
3.注册可以完成用户的注册，注册时要提供账号密码，初始财产余额为0
1）注册先输入账号，要对账号做 输入的是否为空、输入的账号是否已经存在两种判断，
都通过进入输入密码，否则重新输入
2）输入密码，要对密码长度最短为3位的限制，长度3位或以上代表合法，可以完成注册
3）注册是将账号密码写入文件，财产余额初始为0，
第一次写入格式：账号|密码|余额
再次写入格式：,账号|密码|余额
'''
# 账号和密码写入2个while循环，因为账号或者密码输错都返回各自的循环，
# 如果写在一个while循环，那么密码输错，就会重新再输入账号了
def register():
dic = _read_file()
while True:
usr = input('输入账号 ').strip()
if usr in dic: # 账号在字典里不通过
print('账号已存在')
continue
if not usr: # 账号为空不通过
print('账号不能为空')
continue
break
while True:
pwd = input('输入密码 ').strip()
if len(pwd) < 3: # 需求2 输入密码，要对密码长度最短为3位的限制，长度3位或以上代表合法，可以完成注册
print('密码长度必须满3位，重新输入密码')
continue # 如果密码不合法，就返回继续输入密码
else:
dic[usr] = {'ps': pwd, 'money': 0}
_write_file(dic)
print('注册成功')
break
# 登录
'''
4.用户登录状态需要保存，在程序运行的py文件最上方定义一个user字典，字典为空代表未登录，为{'usr': 账号, 'ps': 密码, 'money': 余额}代表登录，记录的就是当前登录的用户
5.完成用户登录
1）解析user.info文件，将用户信息存放到users_dic字典中，格式见下，解析的过程可以定义为方法，
{
'abc': {'ps': '123', 'money': 0},
'qwe': {'ps': '000', 'money': 1000}
}
2）判断用户是否登录了，如果登录了就提示不需要重复登录，未登录就可以往下走，完成登录
3）先输入账号，账号为空、不存在都会验证失败，继续输入，3次失败后就可以进入注册功能，验证通过进行玩下
4）再输入密码，密码必须超过3位，3次登录失败退出登录，成功的记录登录的用户信息到user字典，表示已登录
'''
def login():
print('登陆功能')
global user
# 1. 登陆状态的判断
if user:
print('用户%s已登陆' % user['usr'])
return
# 2. 获取用户信息
user_dic = _read_file()
# 3. 用户验证，三次错误取注册
count = 1
while True:
if count > 3:
register()
return
usr = input('输入账号 ').strip()
if not usr:
print('账号不能为空')
count += 1
continue
if usr not in user_dic:
print('账号不存在')
count += 1
continue
break
# 4. 密码验证
tag = 1
while True:
if tag > 3:
print('已输错3次，请重新登陆')
return
pwd = input('输入密码 ').strip()
if not pwd:
print('密码不能为空')
tag += 1
continue
if len(pwd) < 3:
print('密码不能少于3位')
tag += 1
continue
if pwd != user_dic[usr]['ps']:
print('密码错误')
tag += 1
continue
break
# 5. 完成登陆，更新登陆状态
money = user_dic[usr]['money']
user = {'usr': usr, 'ps': pwd, 'money': money}
print('登陆成功')
# 注销
def logout():
print('注销功能')
global user
if not user:
print('未登陆，无需注销')
return
print('正在注销用户%s >>>>' % user['usr'])
user = {}
print('注销成功')
# 购物
'''
7.用购物功能完成购物，
1）必须在登录状态，未登录时，进入登录页面，已登录则可以购物
2）预定义一些商品与价格，每一次完成购物后，提示用户是否继续进行购物
3）如果余额不足则进入充值功能
'''
@check_login
def shopping():
goods_map = {
'男朋友': 100,
'女朋友': 100,
'ipad': 1000
}
print('购物功能')
for k, v in goods_map.items():
print(k, v, end=' ')
goods = input('请输入购物商品名 ')
if goods not in goods_map:
print('没有该商品')
return
while goods_map[goods] > money:
choose = int(input('余额不足，是否进行充值 0|1'))
if not choose:
print('返回主页面')
return
print('将进入充值页面')
top_up()
user['money'] -= goods_map[goods]
user_dic = _read_file()
goods_map = {
'男朋友': 100,
'女朋友': 100,
'ipad': 1000
}
usr = user['usr']
user_dic[usr]['money'] -= goods_map[goods]
_write_file(user_dic)
print('购物成功')
if int(input('是否继续购物0|1:')):
shopping()
print('返回主页面')
# 充值
'''
8.充值功能
1）必须在登录状态才可以操作
2）充值后的金额数据要同步到user.info文件，user字段和user_dic字典中
'''
@check_login
def top_up():
print('充值功能')
money = int(input('充值的金额 '))
user['money'] += money
user_dic = _read_file()
usr = user['usr']
user_dic[usr]['money'] += money
_write_file(user_dic)
print('充值成功')
# 2.实现 登录，注册，注销，购物，充值，退出系统 六个功能
# 程序入口
method_map = {
'1': login,
'2': register,
'3': shopping,
'4': top_up,
'5': logout
}
def run():
while True:
cmd = input('''功能：
1:<登陆> 2:<注册> 3:<购物> 4:<充值> 5:<注销> 6:<退出>
>>>: ''')
if cmd == '6':
break
if cmd in method_map:
method_map[cmd]()
else:
print('指令错误')
continue
run()
（方法二）
user = {}
# 登陆装饰器
def check_login(func):
def inner(*args, **kwargs):
if not user:
print('未登陆')
login()
res = func(*args, **kwargs)
return res
return inner
# 读文件
def _read():
dic = {}
with open('user.info2', 'r', encoding='utf-8') as f:
a = f.read()
if not a:
return
b = a.split(',')
for i in b:
u = i.split('|')[0]
v = i.split('|')[1]
w = i.split('|')[2]
dic[u] = {'ps': v, 'money': int(w)}
return dic
# 写文件
def _write(dic):
if not dic:
return
info = ''
for u, v in dic.items():
x = v['ps']
y = v['money']
info += '%s|%s|%s,' % (u, x, y)
info = info.rstrip(',')
with open('user.info2', 'w', encoding='utf-8') as f:
f.write(info)
def register():
print('注册功能')
dic = _read()
while True:
usr = input('输入账号 ')
if not usr:
print('账号不能为空')
continue
elif usr in dic:
print('账号已存在')
continue
break
while True:
pwd = input('输入密码 ')
if not usr:
print('密码不能为空')
continue
elif len(pwd) < 3:
print('密码不合法')
continue
break
dic[usr] = {'ps': pwd, 'money': 0}
_write(dic)
print('账号%s注册成功' % usr)
def login():
user_dic = _read()
global user
# 如果user字典非空，则用户已登陆
if user:
print('用户%s已登陆' % user['usr'])
# 账号输错3次
count = 1
while True:
if count > 3:
print('账号输入次数过多，请注册')
register()
return
usr = input('输入登陆账号')
if not usr:
print('账号不能为空')
count += 1
continue
elif usr not in user_dic:
print('账号不存在')
count += 1
continue
break
# 密码输错3次
tag = 1
while True:
if tag > 3:
print('密码输入次数过多，请注册')
register()
return
pwd = input('输入登陆密码')
if not usr:
print('密码不能为空')
tag += 1
continue
elif len(pwd) < 3:
print('密码不合法')
tag += 1
continue
elif pwd != user_dic[usr]['ps']:
print('密码错误')
tag += 1
continue
break
user = {'usr': usr, 'ps': pwd, 'money': user_dic[usr]['money']}
print('用户%s登陆成功' % usr)
def logout():
global user
if not user:
print('没有用户登陆，无需注销')
return
res = user['usr']
user = {}
print('%s注销成功' % res)
@check_login
def topup():
print('充值功能')
global user
money = int(input('充多少 '))
user['money'] += money # 更新登陆信息user字典里money的信息
user_dic = _read() # 读取所有用户并保存成一个字典
user_dic[user['usr']]['money'] += money # 更新总字典
_write(user_dic) # 最后将总的字典写入文件
print('充值成功')
@check_login
def shop():
print('购物功能')
shop_list = {
'男朋友': 100,
'女朋友': 50,
'ipad': 1000
}
for u, v in shop_list.items():
print(u, v, end=' ')
print('')
choice = input('请选择商品 ')
if choice not in shop_list:
print('没有该商品，返回主页面')
return
money = shop_list[choice]
global user
user_dic = _read()
while money > user['money']:
confirm = int(input('余额不足，是否进行充值0|1'))
if not confirm:
print('返回主界面')
return
print('进入充值页面')
topup()
user['money'] -= money
user_dic[user['usr']]['money'] -= money
_write(user_dic)
print('购物成功')
choice2 = int(input('是否继续购物0|1'))
if choice2:
print('继续购物')
shop()
else:
print('返回主页面')
# 程序入口
map_list = {
'1': login,
'2': register,
'3': logout,
'4': shop,
'5': topup
}
def run():
while True:
choice = input('''请选择功能:
1:登陆|2:注册|3:注销|4:购物|5:充值|6:退出系统 ''')
if choice == '6':
break
if choice not in map_list:
print('指令错误')
continue
map_list[choice]()
run()
