三级菜单打怪升级，young -> plus -> pro

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返回上一层\n" + "按e退出\n"
        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(len(self.path) + 1)
        menu = input(prompt).strip()
        return menu

    def run(self):
        """主菜单"""
        # 打印提示
        self.prompt()

        while True:
            # 打印当前菜单
            menu_keys = self.__current_menu.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

        # 当前状态
        current_status = self.__current_status()
        # 把菜单添加到菜单路径
        self.__index += 1
        # 把当前状态加进备忘录
        self.__memo[self.__index] = current_status

    def out_menu(self):
        """回退菜单"""
        # 状态索引减一
        self.__index -= 1

    def prompt(self):
        """打印菜单提示"""
        menu_template = "按q返回上一层\n" + "按e退出\n"
        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()

　走向人生巅峰，迎娶那啥啥啥