Day02：我的Python学习之路

1、初识模块

Python的强大之处在于他有非常丰富和强大的标准库和第三方库，现在简单的学习2个常见的标准库——sys和os。

（1）系统的标准库sys

1 # Author:GCL
2 
3 # 系统的标准库sys
4 import sys
5 
6 # 打印环境变量
7 print(sys.path)
8 # 打印相对路径
9 print(sys.argv)

标准库sys

['F:\\Python\\code\\Day02', 'F:\\Python\\code\\Day02', 'E:\\PythonAnZhuang\\python36.zip', 'E:\\PythonAnZhuang\\DLLs', 'E:\\PythonAnZhuang\\lib', 'E:\\PythonAnZhuang', 'E:\\PythonAnZhuang\\lib\\site-packages']
['F:/Python/code/Day02/MySys_Os.py']

输出

（2）系统的标准库os

 1 # Author:GCL
 2 
 3 # 系统的标准库os
 4 import os
 5 
 6 # 执行系统命令，不保存结果，返回执行的状态，成功返回0
 7 statue=os.system("dir")
 8 print(statue)
 9 # 得到返回的结果
10 ret=os.popen("dir").read()
11 print(ret)
12 # 新建文件夹的命令如下
13 #os.mkdir("newDir")

标准库os

 ������ F �еľ��� ѧϰ
 �������� 0000-0C4A

 F:\Python\code\Day02 ��Ŀ¼

2018/05/05  17:04              .
2018/05/05  17:04              ..
2018/05/05  20:22              .idea
2018/05/04  17:14               181 BytesAndStr.py
2018/05/05  11:45               772 ListCopy.py
2018/05/05  11:22             1,884 MyList.py
2018/05/04  01:38               443 MySys_Os.py
2018/05/05  17:04             1,561 ShoppingCart.py
               5 ���ļ�          4,841 �ֽ�
               3 ��Ŀ¼ 30,338,977,792 �����ֽ�
0
 驱动器 F 中的卷是 学习
 卷的序列号是 0000-0C4A

 F:\Python\code\Day02 的目录

2018/05/05  17:04              .
2018/05/05  17:04              ..
2018/05/05  20:22              .idea
2018/05/04  17:14               181 BytesAndStr.py
2018/05/05  11:45               772 ListCopy.py
2018/05/05  11:22             1,884 MyList.py
2018/05/04  01:38               443 MySys_Os.py
2018/05/05  17:04             1,561 ShoppingCart.py
               5 个文件          4,841 字节
               3 个目录 30,338,977,792 可用字节

输出

 

2、pyc文件是什么

经常说Python是一门解释性语言，其实不够准确，想要弄清楚pyc文件到底是什么，就必须清楚Python的运行过程。
Python的运行过程其实类似于Java，先编译后解释，即：Java首先是通过编译器编译成字节码文件，然后在运行时通过解释器解释成机器文件。所以说Python应该是一门先编译后解释的语言。
在说Python的运行过程之前，我们先来说两个概念，PyCodeObject和pyc文件。我们在硬盘上看到的pyc文件自然不必多说，而其实PyCodeObject则是Python编译器真正编译出的结果。
当python程序运行时，编译的结果则是保存在位于内存中的PyCodeObject中，当Python程序运行结束时，Python解释器则将PyCodeObject写回到pyc文件中。当python程序第二次运行时，首先程序会在硬盘中寻找pyc文件，如果找到，则直接载入，否则就重复上面的过程。所以pyc文件其实是PyCodeObject的一种持久化保存方式。

 

3、Python3的数据类型bytes

在Python3中，文本总是Unicode，由str类型表示，二进制数据则由bytes类型表示。Python3不会以任意隐式的方式混用str和bytes，所以两者的区分特别清晰。
但是，字符串可以编码成字节包，而字节包可以解码成字符串。

1 # Author:GCL
2 
3 nameStr="我是Chinese"
4 # 编码
5 nameBytes=nameStr.encode('utf-8')
6 print(nameBytes)
7 # 解码
8 nameStr=nameBytes.decode('utf-8')
9 print(nameStr)

编码与解码

b'\xe6\x88\x91\xe6\x98\xafChinese'
我是Chinese

输出

 

4、列表

列表是我们以后最常用的数据类型之一，通过列表可以对数据实现最方便的存储、修改等操作。

（1）定义列表与访问单个元素

 1 # Author:GCL
 2 
 3 print("========定义列表与访问单个元素========")
 4 # 定义列表
 5 names=["Jack","Tom","Mary","Alex"]
 6 print(names)
 7 # 通过下标访问列表中的元素，下标从0开始计数
 8 print(names[0],names[1],names[2],names[3])
 9 # 倒着取的下标
10 print(names[-4],names[-3],names[-2],names[-1])

定义列表与访问单个元素

========定义列表与访问单个元素========
['Jack', 'Tom', 'Mary', 'Alex']
Jack Tom Mary Alex
Jack Tom Mary Alex

输出

（2）切片——取多个元素

 1 print("========切片========")
 2 # 切片——取多个元素
 3 # 取下标1至下标3之间的数字，包括1，不包括3
 4 print(names[1:3])
 5 # 与上句等价
 6 print(names[1:-1])
 7 # 当从头开始取的时候，下标0可以忽略
 8 print(names[:2])
 9 # 与上句等价
10 print(names[0:2])
11 # 如果想取到最后一个元素，应该像如下这么写
12 print(names[2:])
13 # 间隔着取元素
14 print(names[0:-1:2])
15 print(names[:-1:3])
16 print(names[::2])

切片——取多个元素

========切片========
['Tom', 'Mary']
['Tom', 'Mary']
['Jack', 'Tom']
['Jack', 'Tom']
['Mary', 'Alex']
['Jack', 'Mary']
['Jack']
['Jack', 'Mary']

输出

（3）追加

1 print("========追加========")
2 names.append("追加新成员0")
3 print(names)

追加

========追加========
['Jack', 'Tom', 'Mary', 'Alex', '追加新成员0']

输出

（4）插入

1 print("========插入========")
2 names.insert(1,"插入新成员0")
3 print(names)

插入

========插入========
['Jack', '插入新成员0', 'Tom', 'Mary', 'Alex', '追加新成员0']

输出

（5）修改

1 print("========修改========")
2 names[2]="Tom_Mod"
3 print(names)

修改

========修改========
['Jack', '插入新成员0', 'Tom_Mod', 'Mary', 'Alex', '追加新成员0']

输出

（6）删除

 1 print("========删除========")
 2 del names[1]
 3 print(names)
 4 # 删除指定元素
 5 names.remove("Tom_Mod")
 6 print(names)
 7 # 删除列表的一个元素，默认是最后一个
 8 names.pop()
 9 print(names)
10 # names.pop(1)
11 names.pop(-2)
12 print(names)

删除

========删除========
['Jack', 'Tom_Mod', 'Mary', 'Alex', '追加新成员0']
['Jack', 'Mary', 'Alex', '追加新成员0']
['Jack', 'Mary', 'Alex']
['Jack', 'Alex']

输出

（7）扩展

1 print("========扩展========")
2 ex=[1,2,3,2]
3 names.extend(ex)
4 del ex
5 print(names)

扩展

========扩展========
['Jack', 'Alex', 1, 2, 3, 2]

输出

（8）统计

1 print("========统计========")
2 # 统计列表中元素为2的个数
3 num=names.count(2)
4 print(num)

统计

========统计========
2

输出

（9）排序与翻转

 1 print("========排序与翻转========")
 2 # Python3中不同数据类型不能放在一起排序
 3 names[2]="1"
 4 names[3]="2"
 5 names[-2]="3"
 6 names[-1]="2"
 7 print(names)
 8 # 按照ASCII码的顺序排列
 9 names.sort()
10 print(names)
11 # 翻转
12 names.reverse()
13 print(names)

排序与翻转

========排序与翻转========
['Jack', 'Alex', '1', '2', '3', '2']
['1', '2', '2', '3', 'Alex', 'Jack']
['Jack', 'Alex', '3', '2', '2', '1']

输出

（10）获取下标

1 print("========获取下标========")
2 # 只返回找到的第一个下标
3 index=names.index("2")
4 print(index)

获取下标

========获取下标========
3

输出

（11）清空列表

1 print("========清空列表========")
2 names.clear()
3 print(names)

清空列表

========清空列表========
[]

输出

（12）拷贝

①.第一种浅拷贝

 1 # Author:GCL
 2 
 3 names1=["Jack","Tom","Mary",["1","2"],"Alex"]
 4 # 浅拷贝
 5 # names2=names1.copy()
 6 # 等价于上句
 7 # names2=names1[:]
 8 # 等价于上句
 9 names2=list(names1)
10 print(names1)
11 print(names2)
12 names1[1]="Tom_Mod"
13 names1[3][0]="One"
14 print(names1)
15 print(names2)

源码

['Jack', 'Tom', 'Mary', ['1', '2'], 'Alex']
['Jack', 'Tom', 'Mary', ['1', '2'], 'Alex']
['Jack', 'Tom_Mod', 'Mary', ['One', '2'], 'Alex']
['Jack', 'Tom', 'Mary', ['One', '2'], 'Alex']

结果

②.第二种浅拷贝

 1 # Author:GCL
 2 
 3 import copy
 4 names3=["Jack","Tom","Mary",["1","2"],"Alex"]
 5 # 浅拷贝
 6 names4=copy.copy(names3)
 7 print(names3)
 8 print(names4)
 9 names3[1]="Tom_Mod"
10 names3[3][0]="One"
11 print(names3)
12 print(names4)

源码

['Jack', 'Tom', 'Mary', ['1', '2'], 'Alex']
['Jack', 'Tom', 'Mary', ['1', '2'], 'Alex']
['Jack', 'Tom_Mod', 'Mary', ['One', '2'], 'Alex']
['Jack', 'Tom', 'Mary', ['One', '2'], 'Alex']

输出

③.深拷贝

 1 # Author:GCL
 2 
 3 import copy
 4 # 深拷贝
 5 names5=["Jack","Tom","Mary",["1","2"],"Alex"]
 6 names6=copy.deepcopy(names5)
 7 print(names5)
 8 print(names6)
 9 names5[1]="Tom_Mod"
10 names5[3][0]="One"
11 print(names5)
12 print(names6)

源码

['Jack', 'Tom', 'Mary', ['1', '2'], 'Alex']
['Jack', 'Tom', 'Mary', ['1', '2'], 'Alex']
['Jack', 'Tom_Mod', 'Mary', ['One', '2'], 'Alex']
['Jack', 'Tom', 'Mary', ['1', '2'], 'Alex']

输出

 

5、元组

元组其实跟列表差不多，也是存一组数，只不过它一旦创建，便不能再修改，所以又叫只读列表。

 

6、购物车小程序

需求：

（1）启动程序后，让用户输入工资，然后打印商品列表；

（2）允许用户根据商品编号购买商品；

（3）用户选择商品后，检测余额是否够，够就直接扣款，不够就提醒； 

（4）可随时退出，退出时，打印已购买商品和余额。

 1 # Author:GCL
 2 
 3 # 商品列表
 4 product_list=[("苹果",12),("香蕉",20),("西瓜",15),("橘子",10)]
 5 # 购物列表，存放用户购买的商品
 6 shopping_list=[]
 7 # 工资
 8 salary=input("请输入您的工资：")
 9 # 工资是否为数字
10 if salary.isdigit():
11     salary=int(salary)
12     while True:
13         print("==========商品列表==========")
14         # index保存索引，item保存具体的值
15         for index,item in enumerate(product_list):
16             print(index,item)
17         user_choice=input("请选择需要购买的商品的编号：")
18         if user_choice.isdigit():
19             user_choice=int(user_choice)
20             # len(product_list)表示的是列表的元素个数
21             if user_choiceand user_choice>=0:
22                 tmp_item=product_list[user_choice]
23                 if tmp_item[1]<=salary:
24                     shopping_list.append(tmp_item)
25                     salary-=tmp_item[1]
26                     print("商品：%s添加成功，还剩余额：\033[31;1m%d\033[0m"%(tmp_item,salary))
27                 else:
28                     print("\033[41;1m您的余额不够，只剩下：%d\033[0m"%(salary))
29             else:
30                 print("您所输入的编号：%d不存在！"%(user_choice))
31         elif user_choice=="q":
32             print("正常退出！")
33             print("您所购买的商品如下：")
34             for index,item in enumerate(shopping_list):
35                 print(index,item)
36             print("您的余额为：\033[31;1m%d\033[0m"%(salary))
37             exit()
38         else:
39             print("您的选择非法，无法识别！")
40 else:
41     print("您输入的工资有误！")

源码

请输入您的工资：50
==========商品列表==========
0 ('苹果', 12)
1 ('香蕉', 20)
2 ('西瓜', 15)
3 ('橘子', 10)
请选择需要购买的商品的编号：1
商品：('香蕉', 20)添加成功，还剩余额：30
==========商品列表==========
0 ('苹果', 12)
1 ('香蕉', 20)
2 ('西瓜', 15)
3 ('橘子', 10)
请选择需要购买的商品的编号：2
商品：('西瓜', 15)添加成功，还剩余额：15
==========商品列表==========
0 ('苹果', 12)
1 ('香蕉', 20)
2 ('西瓜', 15)
3 ('橘子', 10)
请选择需要购买的商品的编号：1
您的余额不够，只剩下：15
==========商品列表==========
0 ('苹果', 12)
1 ('香蕉', 20)
2 ('西瓜', 15)
3 ('橘子', 10)
请选择需要购买的商品的编号：q
正常退出！
您所购买的商品如下：
0 ('香蕉', 20)
1 ('西瓜', 15)
您的余额为：15

输出

 

7、字符串操作

关于对字符串的一系列操作，都在下面的源码中进行了详细的说明：

  1 # Author:GCL
  2 
  3 # 首字母大写，后续字母全部变为小写
  4 print("toM gooD".capitalize())
  5 
  6 # 统计给定字符串出现的次数
  7 print("abc fdh aha".count("a"))
  8 
  9 # 将字符串填充到15位，用*号前后填充，如果指定的位数小于字符串的长度，将没有效果
 10 print("1234567".center(15,"*"))
 11 
 12 # 对字符串进行编码，得到对应的字节包
 13 print("我爱中国".encode("utf-8"))
 14 
 15 # 判断字符串是否以gcl结尾
 16 print("Qggh hjgcl".endswith("gcl"))
 17 
 18 # 将Tab键的距离扩展到16
 19 print("I love\tYou".expandtabs(16))
 20 
 21 # 格式化字符串
 22 print("My name is {name},I am {year}".format(name="gcl",year=22))
 23 print("My name is {name},I am {year}".format_map({"name":"gcl","year":22}))
 24 
 25 # 在字符串中查找name，找到的话返回首次找到的索引，否则返回-1
 26 print("My name is {name},I am {year}".find("name"))
 27 
 28 # 在字符串中查找name，找到的话返回首次找到的索引，否则报错
 29 print("My name is {name},I am {year}".index("name"))
 30 
 31 # 判断字符串是否为整数
 32 print("11".isdigit())
 33 
 34 # 判断字符串是否只由数字和字母组成
 35 print("ak15".isalnum())
 36 
 37 # 判断字符串是否只由字母组成
 38 print("aaA".isalpha())
 39 
 40 # 判断字符串是否为十进制
 41 print("12".isdecimal())
 42 
 43 # 判读字符串是否为一个合法的标识符
 44 print("jk2_".isidentifier())
 45 
 46 # 判读字符串中字母是否全为小写
 47 print("abc 36".islower())
 48 
 49 # 判断字符串是否只由数字组成
 50 print("2361".isnumeric())
 51 
 52 # 判断字符串是否可以打印
 53 print("MyNameIs".isprintable())
 54 
 55 # 判断字符串是否为空格
 56 print(" ".isspace())
 57 
 58 # 判断字符串是否为标题
 59 print("My Name is".istitle())
 60 print("My Name Is".istitle())
 61 
 62 # 判读字符串中字母是否全为大写
 63 print("AS11".isupper())
 64 
 65 # join的示例用法
 66 print("+".join(["1","2","3"]))
 67 print("->".join(["a","b","c"]))
 68 
 69 # 从左到右（左对齐），不够的位数用*来填充
 70 print("12345".ljust(10,"*"))
 71 
 72 # 从右到左（右对齐），不够的位数用*来填充
 73 print("12345".rjust(10,"*"))
 74 
 75 # 转换成小写
 76 print("KLHasgUK".lower())
 77 
 78 # 转换成大写
 79 print("KLHasgUK".upper())
 80 
 81 # 去除左边的空格或换行
 82 print(" \nabc".lstrip())
 83 
 84 # 去除右边的空格或换行
 85 print("abc\n".rstrip())
 86 
 87 # 去除两端的空格或换行
 88 print(" \nabc\n".strip())
 89 
 90 # maketrans用法示例
 91 p=str.maketrans("abcde","12345")
 92 print("hajbkcldqe".translate(p))
 93 
 94 # 从左到右拆分字符串
 95 print("My name is {name},I am {year}".partition(" "))
 96 
 97 # 替换指定的字符串
 98 print("gcl love li".replace("l","L",2))
 99 
100 # 从右到左首次找到的索引
101 print("gcl love li".rfind("l"))
102 
103 # 从右到左拆分字符串
104 print("My name is {name},I am {year}".rpartition(" "))
105 
106 # 分割字符串
107 print("1+2+3+4".split("+"))
108 
109 # 大小写互换
110 print("aBcDeFgHi".swapcase())
111 
112 # 转换成标题
113 print("i love you".title())
114 
115 # 填充字符串
116 print("123abc".zfill(10))

源码

其对应的输出如下：

Tom good
3
****1234567****
b'\xe6\x88\x91\xe7\x88\xb1\xe4\xb8\xad\xe5\x9b\xbd'
True
I love          You
My name is gcl,I am 22
My name is gcl,I am 22
3
3
True
True
True
True
True
True
True
True
True
False
True
True
1+2+3
a->b->c
12345*****
*****12345
klhasguk
KLHASGUK
abc
abc
abc
h1j2k3l4q5
('My', ' ', 'name is {name},I am {year}')
gcL Love li
9
('My name is {name},I am', ' ', '{year}')
['1', '2', '3', '4']
AbCdEfGhI
I Love You
0000123abc

输出

 

8、字典操作

（1）字典是一种----->key:value 的数据类型，其语法如下：

1 info={
2     "stu001":"gcl","stu002":"lmy","stu003":"xx"
3 }
4 print(info)

定义

{'stu001': 'gcl', 'stu002': 'lmy', 'stu003': 'xx'}

输出

（2）字典的特性：

①.字典是无序的；

②.字典的key值必须是唯一的。

（3）字典的常见操作

①.增加

1 # 增加
2 info["stu004"]="yxm"
3 info["stu005"]="tl"
4 print(info)

增加

{'stu001': 'gcl', 'stu002': 'lmy', 'stu003': 'xx', 'stu004': 'yxm', 'stu005': 'tl'}

输出

②.修改

1 # 修改
2 info["stu001"]="gcl2.0"
3 print(info)

修改

{'stu001': 'gcl2.0', 'stu002': 'lmy', 'stu003': 'xx', 'stu004': 'yxm', 'stu005': 'tl'}

输出

③.删除

1 # 删除
2 # 指定删除
3 info.pop("stu004")
4 print(info)
5 del info["stu005"]
6 print(info)
7 # 随机删除
8 info.popitem()
9 print(info)

删除

{'stu001': 'gcl2.0', 'stu002': 'lmy', 'stu003': 'xx', 'stu005': 'tl'}
{'stu001': 'gcl2.0', 'stu002': 'lmy', 'stu003': 'xx'}
{'stu001': 'gcl2.0', 'stu002': 'lmy'}

输出

④.查找

1 # 查找
2 # 如果Key值不存在就会报错
3 print(info["stu001"])
4 # 最好的方法是get，如果不存在会返回None
5 print(info.get("stu002"))
6 print(info.get("stu003"))
7 # 判断Key值是否存在
8 print(("stu001" in info))

查找

gcl2.0
lmy
None
True

输出

⑤.Keys值与values值

1 # Keys值
2 print(info.keys())
3 
4 # values值
5 print(info.values())

Keys值与values值

dict_keys(['stu001', 'stu002'])
dict_values(['gcl2.0', 'lmy'])

输出

⑥.setdefault、update、items

 1 # setdefault
 2 info.setdefault("stu003","xx")
 3 print(info)
 4 info.setdefault("stu001","gcl")
 5 print(info)
 6 
 7 # update
 8 ex={11:22,33:44,"stu001":"gcl"}
 9 info.update(ex)
10 print(info)
11 
12 # items
13 print(info.items())

setdefault、update、items

{'stu001': 'gcl2.0', 'stu002': 'lmy', 'stu003': 'xx'}
{'stu001': 'gcl2.0', 'stu002': 'lmy', 'stu003': 'xx'}
{'stu001': 'gcl', 'stu002': 'lmy', 'stu003': 'xx', 11: 22, 33: 44}
dict_items([('stu001', 'gcl'), ('stu002', 'lmy'), ('stu003', 'xx'), (11, 22), (33, 44)])

输出

⑦.循环打印

1 # 循环打印字典
2 # 比较常用
3 for key in info:
4     print(key,info[key])
5 #会先把dict转成list,数据量大时莫用
6 for k,v in info.items():
7     print(k,v)

循环打印字典

stu001 gcl
stu002 lmy
stu003 xx
11 22
33 44
stu001 gcl
stu002 lmy
stu003 xx
11 22
33 44

输出

 

9、程序：三级菜单

要求：

（1）可返回上一级；

（2）可随时退出程序。

  1 # Author:GCL
  2 
  3 # 整体的字典数据
  4 data={
  5     "A1":{
  6         "A11":{
  7             "A111":["1","2"],
  8             "A112":["3","4"]
  9         },
 10         "A12":{
 11             "A121":["5","6"],
 12             "A122":["7","8"]
 13         },
 14         "A13":{
 15             "A131":["9","10"],
 16             "A132":["11","12"]
 17         }
 18     },
 19     "A2":{
 20         "A21":{
 21             "A211":["13","14"],
 22             "A212":["15","16"]
 23         },
 24         "A22":{
 25             "A221":["17","18"],
 26             "A222":["19","20"]
 27         },
 28         "A23":{
 29             "A231":["21","22"],
 30             "A232":["23","24"]
 31         }
 32     },
 33     "A3":{
 34         "A31":{
 35             "A311": ["25", "26"],
 36             "A312": ["27", "28"]
 37         },
 38         "A32":{
 39             "A321": ["29", "30"],
 40             "A322": ["31", "32"]
 41         },
 42         "A33":{
 43             "A331": ["33", "34"],
 44             "A332": ["35", "36"]
 45         }
 46     },
 47     "A4":{
 48         "A41":{
 49             "A411": ["37", "38"],
 50             "A412": ["39", "40"]
 51         },
 52         "A42":{
 53             "A421": ["41", "42"],
 54             "A422": ["43", "44"]
 55         },
 56         "A43":{
 57             "A431": ["45", "46"],
 58             "A432": ["47", "48"]
 59         }
 60     }
 61 }
 62 
 63 # 退出的标志位，默认为真
 64 exit_flag=True
 65 while exit_flag:
 66     # 打印第一级的keys值
 67     for k in data:
 68         print(k)
 69     choice1=input("您的选择（第一级）：")
 70     if (choice1 in data):
 71         while exit_flag:
 72             # 打印第二级的keys值
 73             for k in data[choice1]:
 74                 print(k)
 75             choice2=input("您的选择（第二级）：")
 76             if (choice2 in data[choice1]):
 77                 while exit_flag:
 78                     # 打印第三级的keys值
 79                     for k in data[choice1][choice2]:
 80                         print(k)
 81                     choice3=input("您的选择（第三级）：")
 82                     if (choice3 in data[choice1][choice2]):
 83                         print(data[choice1][choice2][choice3])
 84                     elif choice3=="b":
 85                         break
 86                     elif choice3=="q":
 87                         exit_flag=False
 88                     else:
 89                         print("您的选择有误，无法识别！")
 90             elif choice2=="b":
 91                 break;
 92             elif choice2=="q":
 93                 exit_flag=False
 94             else:
 95                 print("您的选择有误，无法识别！")
 96     elif choice1=="b":
 97         print("已经是第一级了，无法返回上一级！")
 98     elif choice1=="q":
 99         exit_flag=False
100     else:
101         print("您的选择有误，无法识别！")

源码

A1
A2
A3
A4
您的选择（第一级）：A2
A21
A22
A23
您的选择（第二级）：A21
A211
A212
您的选择（第三级）：A212
['15', '16']
A211
A212
您的选择（第三级）：A211
['13', '14']
A211
A212
您的选择（第三级）：B
您的选择有误，无法识别！
A211
A212
您的选择（第三级）：b
A21
A22
A23
您的选择（第二级）：b
A1
A2
A3
A4
您的选择（第一级）：b
已经是第一级了，无法返回上一级！
A1
A2
A3
A4
您的选择（第一级）：A4
A41
A42
A43
您的选择（第二级）：q

Process finished with exit code 0

输出

 

后记：欢迎各路大神批评与指正！

2018.5.6

转载于:https://www.cnblogs.com/gcl0909031172/p/8996949.html