young -> simple
三级菜单超简单，每层都是小循环
小可爱，不是if就是for，真可爱
def menu(message):
print('按q返回上一层')
print('按e退出')
ec = 'q' # 返回上一级
ex = 'e'
for i in message: # 打印一级菜单
print(i)
while True: # 进入一级菜单选择
choice1 = input('请输入1>>>：')
if choice1 in message: # 判断是否在字典中
for i1 in message[choice1]:
print(i1) # 打印值
while True:
choice2 = input('请输入2>>>：') # 进入二级菜单选择
if choice2 in message[choice1]:
for i2 in message[choice1][choice2]:
print(i2)
while True:
choice3 = input('请输入3>>>：') # 进入三级菜单选择
if choice3 in message[choice1][choice2]:
for i3 in message[choice1][choice2][choice3]:
print(i3)
elif choice3 == ec: # 返回判断
for i2 in message[choice1]:
print(i2) # 打印上一级菜单
break
elif choice3 == ex: # 退出判断
exit('退出中……ing')
else:
print('输入错误，请重新输入，么么哒')
elif choice2 == ec: # 返回判断，并打印上一级菜单
for i1 in message:
print(i1)
break
elif choice2 == ex: # 退出判断
exit('退出中……ing')
else:
print('输入错误，请重新输入，么么哒')
elif choice1 == ec: # 返回判断
print('已经最顶级菜单，完全退出请输入 e ')
continue
elif choice1 == ex: # 退出判断
s
else:
print('输入错误，请重新输入，么么哒')
if __name__ == '__main__':
message = {'湖南':
{'衡阳': {'珠珠': '大大学院'},
'湘潭': {'晖晖': '啦啦'}
},
'北京':
{'朝阳':
{'晖晖': '啦啦'}
}
}
menu(message)
plus -> 经历社会毒打
想函数编程未实现，现在看不懂系列，try...except...？什么鬼？
def menu_to(message):
'''打印菜单'''
try:
message.endswith('end')
except:
for i in message:
print(i)
else:
print(message.replace('end', ''))
def get_message_key(message_info):
'''获得每层字典的单边值'''
try:
keys = []
for i in message_info:
message_info[i]
keys.append(i)
return keys
except:
return message_info + 'end'
def menu_go(message_info):
'''进入主菜单'''
while True:
try:
judgment(message_info)
except Exception as e:
print(e)
def judgment(message_info):
'''循环菜单'''
keys = get_message_key(message_info)
while True:
menu_to(keys)
choice = input('请输入>>>:')
if choice == ec:
print('暂时未实现')
return judgment(message_info)
elif choice == ex:
exit('退出程序')
if type(keys) == type('str') and keys.endswith('end'):
print('菜单到底了')
continue
else:
if choice in keys:
message_info = message_info[choice]
return judgment(message_info)
else:
print('输入错误,请重新输入')
if __name__ == '__main__':
message = {'湖南':
{'衡阳': {'珠珠': '大大学院'},
'湘潭': {'晖晖': '啦啦'}
},
'北京':
{'朝阳':
{'晖晖': '啦啦'}
}
}
ec = 'q' # 返回上一级
ex = 'e' # 退出程序
menu_go(message)
核心思路
1. 创建三个状态变量，一个保存当前菜单状态，一个保存当前菜单路径，一个保存初始状态
2. 进入菜单，检查输入的菜单是否存在，不存在则重新输入，再检查是否能进入下一层，不能进入菜单，状态不更新
3. 进入菜单，存在和进入下一层检查通过，添加菜单到路径，进入下一层，更新当前菜单状态到下一层菜单状态
4. 返回上一层，则从菜单路径删除尾部，从初始状态按路径查找，然后更新当前菜单状态
__author__ = 'beimenchuixue'
__blog__ = 'http://www.cnblogs.com/2bjiujiu/'
class Menu(object):
"""三级菜单类
核心思路
1. 创建三个状态变量，一个保存当前菜单状态，一个保存当前菜单路径，一个保存初始状态
2. 进入菜单，检查输入的菜单是否存在，不存在则重新输入，再检查是否能进入下一层，不能进入菜单，状态不更新
3. 进入菜单，存在和进入下一层检查通过，添加菜单到路径，进入下一层，更新当前菜单状态到下一层菜单状态
4. 返回上一层，则从菜单路径删除尾部，从初始状态按路径查找，然后更新当前菜单状态
"""
def __init__(self, msg):
# __current_menu 是个当前临时菜单状态, msg保存最初状态
self.__current_menu = self.msg = msg
# 菜单路径，因为菜单路径是唯一且互斥的
self.path = []
def user_input(self):
"""获取用户的输入"""
prompt = "{}请输入>>>:".format(len(self.path)+1)
menu = input(prompt).strip()
return menu
def run(self):
"""主菜单"""
# 打印提示
self.prompt()
while True:
# 打印当前菜单
menu_keys = self.__current_menu.keys()
self.output_prompt(menu_keys)
# 获取用户输入
menu = self.user_input()
if not menu:
continue
# 退出程序
if menu == "e":
self.exit_prompt()
break
# 返回上一级
elif menu == "q":
# 如果到最顶级，后面就没必要执行力
if len(self.path) == 0:
self.top_prompt()
continue
else:
# 菜单往上一级
self.out_menu()
else:
# 进入菜单
self.into_menu(menu)
# 进入菜单
pass
def _check_exit(self, menu):
"""检查菜单是否存在"""
keys = self.__current_menu.keys()
# 检查菜单是否存在
if menu in keys:
return True
def _check_next(self, menu):
"""查看是否有下一菜单"""
res = self.__current_menu.get(menu, None)
if type(res) is dict:
return True
def into_menu(self, menu):
"""获取路径，并修改路径"""
# 是否到最底层最底部了
is_exit, is_next = self._check_exit(menu), self._check_next(menu)
# 判断菜单是否不存在，不存在返回
if not is_exit:
self.not_exit_prompt()
return
# 判断是否菜单到底部, 到底部打印提示返回
if not is_next:
self.bottom_prompt()
return
# 把菜单添加到菜单路径
self.path.append(menu)
# 更改当前的菜单状态
self.__current_menu = self.__current_menu.get(menu)
def out_menu(self):
"""回退菜单"""
# 回退一个路径
self.path.pop()
# 更新当前菜单
self.update_menu()
pass
def update_menu(self):
"""更新当前菜单"""
# 如果有路径，通过路径更新当前菜单状态，没有路径说明到顶级菜单了
if self.path:
for item in self.path:
temp_menu = self.msg.get(item)
self.__current_menu = temp_menu
else:
self.__current_menu = self.msg
def prompt(self):
"""打印菜单提示"""
menu_template = "按q返回上一层
" + "按e退出
"
print(menu_template, end="")
pass
def output_prompt(self, menu_keys):
"""打印菜单"""
print("menu".center(30, "."))
for item in menu_keys:
print(item)
def exit_prompt(self):
"""答应退出提示"""
print('退出中……ing')
print(''.center(30, "-"))
pass
def top_prompt(self):
"""打印到顶层提示"""
print('已经最顶级菜单 ')
print(''.center(30, "-"))
pass
def bottom_prompt(self):
"""打印到顶层提示"""
print('已经最底层级菜单 ')
print(''.center(30, "-"))
pass
def not_exit_prompt(self):
"""选择不存在提示"""
print("选择不存在，重新输入")
print(''.center(30, "-"))
pass
if __name__ == "__main__":
message = {'湖南':
{'衡阳': {'珠珠': '大大学院'},
'湘潭': {'晖晖': '啦啦'}
},
'北京':
{'朝阳':
{'晖晖': '啦啦'}
}
}
menu = Menu(message)
menu.run()
pro -> 假装坚强 |^_^|
核心思路 -> 利用备忘录设计模式实现三级菜单
1. 创建两个变量，一个是保存各个层级菜单状态，一个是保存当前状态指向索引
2. 进入菜单，检查输入的菜单是否存在，不存在则重新输入，再检查是否能进入下一层，不能进入菜单，状态不更新
3. 进入菜单，存在和进入下一层检查通过, 状态索引自增1，当前状态加入备忘录
4. 返回上一层，状态索引减一
__author__ = 'beimenchuixue'
__blog__ = 'http://www.cnblogs.com/2bjiujiu/'
class Menu(object):
"""三级菜单类
核心思路 -> 利用备忘录模式实现三级菜单
1. 创建两个变量，一个是保存各个层级菜单状态，一个是保存当前状态指向索引
"""
def __init__(self, msg):
# 初始索引状态
self.__index = 0
# 备忘录(memo)状态
self.__memo = {self.__index: msg}
def user_input(self):
"""获取用户的输入"""
prompt = "{}请输入>>>:".format(self.__index + 1)
menu = input(prompt).strip()
return menu
def run(self):
"""主菜单"""
# 打印提示
self.prompt()
while True:
# 打印当前菜单
menu_keys = self.__memo.get(self.__index).keys()
self.output_prompt(menu_keys)
# 获取用户输入
menu = self.user_input()
if not menu:
continue
# 退出程序
if menu == "e":
self.exit_prompt()
break
# 返回上一级
elif menu == "q":
# 如果到最顶级，后面就没必要执行力
if self.__index == 0:
self.top_prompt()
continue
else:
# 菜单往上一级
self.out_menu()
else:
# 进入菜单
self.into_menu(menu)
# 进入菜单
pass
def __current_status(self):
return self.__memo.get(self.__index)
def _check_exit(self, menu):
"""检查菜单是否存在"""
keys = self.__current_status().keys()
# 检查菜单是否存在
if menu in keys:
return True
def _check_next(self, menu):
"""查看是否有下一菜单"""
res = self.__current_status().get(menu, None)
if type(res) is dict:
return True
def into_menu(self, menu):
"""获取路径，并修改路径"""
# 是否到最底层最底部了
is_exit, is_next = self._check_exit(menu), self._check_next(menu)
# 判断菜单是否不存在，不存在返回
if not is_exit:
self.not_exit_prompt()
return
# 判断是否菜单到底部, 到底部打印提示返回
if not is_next:
self.bottom_prompt()
return
# 索引加1
self.__index += 1
# 查询备忘录中是否有该状态
current_status = self.__current_status()
# 如果备忘录中没有则新增一个状态添加到备忘录中
if current_status is None:
# 下一级菜单从上一级菜单中获取
self.__memo[self.__index] = self.__memo[self.__index-1].get(menu)
def out_menu(self):
"""回退菜单"""
# 状态索引减一
if self.__index == 0:
return
self.__memo.pop(self.__index)
self.__index -= 1
def prompt(self):
"""打印菜单提示"""
menu_template = "按q返回上一层
" + "按e退出
"
print(menu_template)
pass
def output_prompt(self, menu_keys):
"""打印菜单"""
print("menu".center(30, "."))
for item in menu_keys:
print(item)
def exit_prompt(self):
"""答应退出提示"""
print('退出中……ing')
print(''.center(30, "-"))
pass
def top_prompt(self):
"""打印到顶层提示"""
print('已经最顶级菜单 ')
print(''.center(30, "-"))
pass
def bottom_prompt(self):
"""打印到顶层提示"""
print('已经最底层级菜单 ')
print(''.center(30, "-"))
pass
def not_exit_prompt(self):
"""选择不存在提示"""
print("选择不存在，重新输入")
print(''.center(30, "-"))
pass
if __name__ == "__main__":
message = {'湖南':
{'衡阳': {'珠珠': '大大学院'},
'湘潭': {'晖晖': '啦啦'}
},
'北京':
{'朝阳':
{'晖晖': '啦啦'}
}
}
menu = Menu(message)
menu.run()
走向人生巅峰，迎娶那啥啥啥