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    <DIR>          .
2018/05/05  17:04    <DIR>          ..
2018/05/05  20:22    <DIR>          .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    <DIR>          .
2018/05/05  17:04    <DIR>          ..
2018/05/05  20:22    <DIR>          .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_choice<len(product_list) and 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

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值