欢迎大家来我的博客园：https://www.cnblogs.com/xiaomingdexiaoshubao/articles/9249773.html

模块初识

os

import oscmd_res = os.system("dir")
cmd_res = os.popen("dir")
cmd_res = os.popen("dir").read()
os.mkdir = ("new_dir")print(cmd_res)

cmd_res = os.system(“dir”)

这句话调用os中的system文件功能，然后在该级目录下调用了dir这个命令行，命令执行后会显示该级目录下的所有文件，但是打印出来的是乱码格式的，于是我们换一个执行方式

2018/07/01  12:40    <DIR>          .
2018/07/01  12:40    <DIR>          ..
2018/07/01  12:40               174 Module.py1 ���ļ�            174 �ֽ�2 ��Ŀ¼ 37,861,814,272 �����ֽ�

cmd_res = os.popen(“dir”)

<os._wrap_close object at 0x0000022AD9950AC8>

换成这句话会打印一个莫名其妙的地址

cmd_res = os.popen(“dir”).read()

于是我们用read()把这个地址的值读取出来，发现是dir的执行内容，乱码格式也解决了

2018/07/01  12:41    <DIR>          .
2018/07/01  12:41    <DIR>          ..
2018/07/01  12:41               174 Module.py1 个文件            174 字节2 个目录 37,861,814,272 可用字节

总结：
os.system()只会执行，但是不会保存执行后的结果
os.popen(）执行后，不会立即显示结果，而是存在相应的内存地址中，我们使用read()读取，就可以显示出来了

sys

import sys
print(sys.path)

'D:\\md\\Day2\\blog\\day2'
'D:\\md\\Day2'
'D:\\md\\Day2\\venv\\Scripts\\python36.zip'
'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36\\DLLs'
'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36\\lib'
'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36', 'D:\\md\\Day2\\venv'
'D:\\md\\Day2\\venv\\lib\\site-packages'
'D:\\md\\Day2\\venv\\lib\\site-packages\\setuptools-39.1.0-py3.6.egg'
'D:\\md\\Day2\\venv\\lib\\site-packages\\pip-10.0.1-py3.6.egg'
'C:\\Program Files\\JetBrains\\PyCharm 2018.1.4\\helpers\\pycharm_matplotlib_backend'

调用相应的模块后，会根据上面的目录去找文件然后调用，如果不存在，会显示module不存在,python的三方库一般是在site-packages,标准库在上级lib目录下

'D:\\md\\Day2\\venv\\lib\\site-packages'

如何引用自己写的库，或者别人写的库呢

（1）如果你需要引用自己写的三方文件放在site-packages里面就可以了
（2）加入python的path路径，环境变量中就可以直接引用了

python中bytes/str

在python3中最重要的新特性就是对文本和二进制数据作了更清晰的区分。文本总是Unicode，由str类型表示，二进制数据则是由bytes表示。不会以任意隐式的方式混用str和bytes，

bytes和string的转换

转换场景：网络数据包的传递，在Python3中所有数据的传递都是以二进制形式传递的，所以需要把str类型转为bytes，用到encode和decode

msg = '小明的学习小书包'print(msg.encode(encoding='utf-8'))
print(msg.encode(encoding='utf-8').decode(encoding='utf-8'))

b'\xe5\xb0\x8f\xe6\x98\x8e\xe7\x9a\x84\xe5\xad\xa6\xe4\xb9\xa0\xe5\xb0\x8f\xe4\xb9\xa6\xe5\x8c\x85'
小明的学习小书包

列表

和c语言中的数组很像，能够存储字符串，数据，字符数据，在Python里面通常称列表为list

形式

names = ["小明","小红","小花","小荣","小涛","小李"]
print(names)

操作

列表元素访问

为什么计算机都是从0开始呢：因为计算机都是二进制的数据，二进制中就是从0开始的

names = ["小明","小红","小花","小荣","小涛","小李"]
print(names[0])  #names[1] names[2] names[3] names[4] names[5]
print(names[-1]) #names[-2] names[-3] names[-4] names[-5] names[-6]

第一种形式就是从左往右一次访问
第二种形式就是从右往从左访问，为什么不是从0开始呢，0已经被正向访问占用了，只好从-1开始了

小明
小李

切片

names = ["小明","小红","小花","小荣","小涛","小李"]
print(names[0:1]) #names[1:3] names[2:5] names[1:4]
print(names[-3:-1])
print(names[-1:-3])
print(names[3:])
print(names[:3])

[0:1]的意思就是访问下表从0到1的元素，但是不包括1，很像数学集合中的左闭右开 0<= x <1自然这里就是访问第0个元素到第0个元素，就是小明
[-3:-1][-1:-3] 按理说从倒数第三个的位置输入到倒数第二个的位置（左闭右开嘛），然后从倒数第一个的位置输入到倒数第二个的位置，为什么第二种形式[-1:-3]输出不了呢，我想这里是因为虽然说是可以反顺序输出，但是实际上，访问顺序还是从左往右的，类似数学集合，数的集合不可能同时大于-1而又小于-3
[3:] 这种形式就是从第三个元素访问直到这个列表的结尾，在这里是包括尾巴的，就像x大于等于3
[:3] 这种形式就是x小于等于3罗，从头开始到第二个位置

['小明']
['小荣', '小涛']
[]
['小荣', '小涛', '小李']
['小明', '小红', '小花']

增删改查

我们先来看看一个列表到底有多少种方法，我们可以新建一个列表，然后用列表名点一下就知道了,然后我们会逐一使用一下这些方法

copy(self)                      #：分为浅拷贝和深拷贝
extend(self,iterable)           #：扩充，可以连接两个列表
sort(self,key,reverse)          #：按列表中的元素进行排序，默认是先数字后特殊字符，然后是字母
index(self,object,start,stop)   #：index，返回某个元素的下标
pop(self,index)                 #：有两种用法：（1）pop的参数为空值的时候，就是删除掉列表的最后一个元素，依次弹出一个（2）pop的参数还可以为下标，这样就可以像弹出哪个就弹出哪个
remove(self,object)             #：remove掉某个元素，参数填元素值
insert(self,index,object)       #：插入某个元素，第一个参数填插入的列表的下标，第二个参数填你需要插入的元素
append(self,object)             #：增加一个元素，自然参数只有一个，就是元素值
clear(self)                     #：清空整个列表
count(self,object)              #：计算列表中某一元素的个数，主要计算具有重复值的元素
reverse(self)                   #：反转整个列表

下面的代码都是小明测试函数功能时用到过的，你们可以注释其他功能而去测试其中一个功能：

names = ["小明","小红","小花","小荣","小涛","小李"]names.append("小锤")
names.insert(1,"小狼")
names[2] = "小改改"                # ps：此处为改的内容，其中[]里面不能直接写元素的值，只能写下标
names.remove("小改改")
del names[2]
names.pop()
names.pop(1)
print(names)
print(names.index("小明"))
print(names[names.index("小明")])
print(names.count("小明"))
names.clear()
names.reverse()
print(names)
names.sort()
print(names)
names2 = [1,2,3,4,6,7]
names.extend(names2)
print(names)

有个方法是copy方法，比较特殊，也比较重要，我们会单独拿出来做分析：

import copynames = ["小明","小红","小花",["小明的书包","xiaomingdekoudai"],"小荣","小涛","小李"]names2 = names.copy()
print(names)
print(names2)
names[2] = "xiaohua"
names[3][0] = "xiaomingdeshubao"
print(names)
print(names2)

其中names[3][0]是列表的嵌套，然后呢[3][0]就是访问第三个元素的地址中的第0个元素，嵌套列表就是在一个列表中嵌入了另一个列表的地址，然后这个地址是以列表的形式表现出来的

['小明', '小红', '小花', ['小明的书包', 'xiaomingdekoudai'], '小荣', '小涛', '小李']
['小明', '小红', '小花', ['小明的书包', 'xiaomingdekoudai'], '小荣', '小涛', '小李']
['小明', '小红', 'xiaohua', ['xiaomingdeshubao', 'xiaomingdekoudai'], '小荣', '小涛', '小李']
['小明', '小红', '小花', ['xiaomingdeshubao', 'xiaomingdekoudai'], '小荣', '小涛', '小李']

该例子中，我们通过分别改变names列表的非嵌套列表元素和嵌套列表元素，运行后，出现了很有意思的结果。
我们分析一下：第一次，我们的names2成功拷贝了names中的元素，表现为

['小明', '小红', '小花', ['小明的书包', 'xiaomingdekoudai'], '小荣', '小涛', '小李']

然后我们改变了names中的元素，按理说names2中的元素应该是应该和上面的结果是一样的，不会改变

['小明', '小红', '小花', ['xiaomingdeshubao', 'xiaomingdekoudai'], '小荣', '小涛', '小李']

但是names2出了点问题，不是嵌套列表中的元素”小花”还是之前的结果，并没有因为names的改变而改变，当然是这样子的，但是嵌套列表中的元素却按照names的改变而改变了，从中文变为了英文，到底是怎么回事呢？
上面已经暗示过了，列表在嵌套的时候，其实是嵌套了一个列表指针，就是把嵌套的这个列表的地址作为元素存储在了names中，那么当然names2在拷贝的时候，也会拷贝这个内存地址，那么这种拷贝我们称之为浅拷贝，就是仅仅只拷贝的地址
自然有浅就有深，那么深拷贝就是下面这个样子：我们需要导入一个模块copy

import copynames = ["小明","小红","小花",["小明的书包","xiaomingdekoudai"],"小荣","小涛","小李"]#names2 = copy.copy()
names2 = copy.deepcopy(names)
print(names)
print(names2)
names[2] = "xiaohua"
names[3][0] = "xiaomingdeshubao"
print(names)
print(names2)

['小明', '小红', '小花', ['小明的书包', 'xiaomingdekoudai'], '小荣', '小涛', '小李']
['小明', '小红', '小花', ['小明的书包', 'xiaomingdekoudai'], '小荣', '小涛', '小李']
['小明', '小红', 'xiaohua', ['xiaomingdeshubao', 'xiaomingdekoudai'], '小荣', '小涛', '小李']
['小明', '小红', '小花', ['小明的书包', 'xiaomingdekoudai'], '小荣', '小涛', '小李']

这时候我们就发现打印结果已经变了，通过深拷贝，就是你names中的嵌套列表变了，我也不会发生改变，因为我不仅仅拷贝了你的内存地址，而是拷贝了你内存地址中的值，并且开辟了另外一块内存空间去保存值。

关于列表，还有一点零碎的小知识：

names = ["小明","小红","小花",["小明的书包","xiaomingdekoudai"],"小荣","小涛","小李"]for i in names:print(i)
for i,t in enumerate(names):print(i+1,t)

小明
小红
小花
['小明的书包', 'xiaomingdekoudai']
小荣
小涛
小李
1 小明
2 小红
3 小花
4 ['小明的书包', 'xiaomingdekoudai']
5 小荣
6 小涛
7 小李

第一种方式自然就是循环打印出了列表的值
第二种方式，介绍一下enumerate这个方法

enumerate

这是Python的内置函数，在字典有迭代的意思，在Python中多用于需要同时打印索引和内容的值

对于列表中，我需要同时打印索引下标和列表元素
```
for i,t in enumerate(names):print(i+1,t)  
```
上一个，我用了i+1来控制索引的起点值不为0，但是其实可以用第二个参数来控制索引的起点值
```
for i,t in enumerate(names,1):print(i+1,t) 
```

我们甚至可以用这个来统计文件有多少行

count = 0
for index, line in enumerate(open(filepath,'r'))： count += 1

一个购物车的练习程序

__Author__ = "kncc"product_list = [('Iphone',5800),                                        #:(╯°口°)╯(┴—┴('Mac Pro',9800),                                       #:(>_>)('Bike',800),                                           #:ε=ε=(ノ≧∇≦)ノ('Watch',10600),                                        #:(⌒▽⌒)('Coffee',31),                                          #:("▔□▔)/('Kncc bag',120)                                        #:("▔□▔)/               ...........
]
shopping = []salary = input("Input your salary:  ")if salary.isdigit():                                        #:在这里判断输入的是不是数字salary = int(salary)                                    #:类型强转，isdigit并没有转换，只是判断while True:                                             #:进入循环for index,item in enumerate(product_list,1):        #:当然这里是打印小可爱啦(〜￣△￣)〜print(index,item)                                       buy_id = input("Please input the number you want to buy:")  #:获取你想买的商品(^・ω・^ )if buy_id.isdigit():                                        #:同样判断你有没有输入不可爱的字符(非数字)buy_id = int(buy_id)                            #:同样转换为可爱的字符(数字)if buy_id <= len(product_list) and buy_id > 0:  #:判断你有没有捣乱，输入大于商标的商品b_item =  product_list[buy_id-1]            #:把你的商品取出来，用一个b_item做标识，方便下面的操作if b_item[1] <= salary:                     #:判断你的软妹币够不够shopping.append(b_item[0])              #:够了，当然要马上装进小书包啦salary -= b_item[1]                     #:你的软妹币也要减少。。。真难过("▔□▔)/print("Added %s into shopping cart,your current balance is \033[31;1m%s\033[0m"%(b_item[0],salary))                                               #:当然要用可爱的颜色打印软妹币啦(╬ﾟдﾟ)▄︻┻┳═一else:print("\033[41;1mYour money is not enough!You only have [%s]\033[0m"%salary)elif buy_id > len(product_list):print("人家没有那么多商品!")else:print("invalid option")elif buy_id == 'q':print("exit ...")print("----------shopping lit --------------")for p in shopping:                               #:输出一下你的可爱小书包（￣へ￣）print(p)print("Your cunrrent balance:",salary)           #:快看一下你口袋里的软妹币吧_(:3」∠)_exit()else:print("invalid option,You only input the number of thess things")
else:print("invalid option,You only input number!")

Input your salary:  10000
1 ('Iphone', 5800)
2 ('Mac Pro', 9800)
3 ('Bike', 800)
4 ('Watch', 10600)
5 ('Coffee', 31)
6 ('Kncc bag', 120)
Please input the number you want to buy:2
Added Mac Pro into shopping cart,your current balance is 200
1 ('Iphone', 5800)
2 ('Mac Pro', 9800)
3 ('Bike', 800)
4 ('Watch', 10600)
5 ('Coffee', 31)
6 ('Kncc bag', 120)
Please input the number you want to buy:6
Added Alex Python into shopping cart,your current balance is 80
1 ('Iphone', 5800)
2 ('Mac Pro', 9800)
3 ('Bike', 800)
4 ('Watch', 10600)
5 ('Coffee', 31)
6 ('Kncc bag', 120)
Please input the number you want to buy:5
Added Coffee into shopping cart,your current balance is 49
1 ('Iphone', 5800)
2 ('Mac Pro', 9800)
3 ('Bike', 800)
4 ('Watch', 10600)
5 ('Coffee', 31)
6 ('Kncc bag', 120)
Please input the number you want to buy:5
Added Coffee into shopping cart,your current balance is 18
1 ('Iphone', 5800)
2 ('Mac Pro', 9800)
3 ('Bike', 800)
4 ('Watch', 10600)
5 ('Coffee', 31)
6 ('Kncc bag', 120)
Please input the number you want to buy:5
Your money is not enough!You only have [18]
1 ('Iphone', 5800)
2 ('Mac Pro', 9800)
3 ('Bike', 800)
4 ('Watch', 10600)
5 ('Coffee', 31)
6 ('Kncc bag', 120)
Please input the number you want to buy:q
exit ...
----------shopping lit --------------
Mac Pro
Kncc bag
Coffee
Coffee
Your cunrrent balance: 18

字符串

name = "my \tname is {name} and i am {year} old"print(name.capitalize())              #capitalizi 首字母大写
print(name.count("a"))
print(name.center(50,"-"))
print(name.endswith("old"))
print(name.expandtabs(tabsize=30))    #\t 扩张成30
print(name[name.find("name"):])       #字符串可以切片
print(name[name.find("name"):])
print(name.format(name="xiaoming",year = 18))
print(name.format_map({'name':'xiaoming','year':18}))

字符串的基本操作：
比较重点的就是字符串是可切片的
查看对应的行，可以查看执行结果

name[name.find("name"):]   #先找到name所在的位置，然后根据name的位置切片，自然就是从name开始切到最后，这里只能找到最左边的name，我们当然可以用后面的一些函数来达到我们想要找的这个字符是后几个

My  name is {name} and i am {year} old
5
------my    name is {name} and i am {year} old------
True
my                            name is {name} and i am {year} old
name is {name} and i am {year} old
name is {name} and i am {year} old
my  name is xiaoming and i am 18 old
my  name is xiaoming and i am 18 old

print('ab23'.isalnum())
print('abA'.isalpha())
print("1A".isdecimal())             #decimal 小数 如果只有小数就返回true
print("1A".isdigit())               #digit   数字 如果只有数字就返回true
print("a 1A".isidentifier())        #identifier 标识符 判断是不是个合法的表示符，中文可以，空格也可以
print("My Name Is ".istitle())     #判断是不是标题，即是否首字母大写
print("My Name Is ".isupper())     #是否全是大写print('+'.join(['1','2','3','4'])) #给每个列表元素之间加字符串
print(name.ljust(50,"*"))           # 保证我这句话长50，不够的话用*填充
print(name.rjust(50,"-"))           # 保证我这句话长50，不够的话用*填充
print("Xiaoming".lower())          # 大写转小写
print("Xiaoming".upper())          # 小写转大写
print("---")
print("\nXiaoming".lstrip())           # 去掉左边的符号
print("Xiaoming\n".rstrip())           # 去掉右边的符号
print("\nXiaoming\n".strip())          # 去掉两边的符号
print("---")p = str.maketrans("abcdef","123456")            #替换字符表
print("xiaoming".translate(p))print("xiao ming".replace('a','1',1))           #替换
print("xiao ming".rfind("i"))                   #从左往右，找到找到最右边的下标
print("xiao ming".split("i"))                   #将字符串按照空格拆分成列表,脚本中命令可拆分命令
print("xiao\nming".splitlines())                #按照换行符
print("xiAo Ming".swapcase())                   #交换大小写
print("xiao ming".title())                      #首字符大写
print("xiao ming".zfill(20))                    #十六进制左侧填充

True
True
False
False
False
True
False
1+2+3+4
my  name is {name} and i am {year} old************
------------my  name is {name} and i am {year} old
xiaoming
XIAOMING
---
Alex
Alex
Alex
---
xi1oming
xi1o ming
6
['x', 'ao m', 'ng']
['xiao', 'ming']
XIaO mING
Xiao Ming
00000000000xiao ming

字典

字典类似我们学习用的查阅的字典是一样的，利用一个拼音（键）去找到我们需要找的字（键值）就是一种key-value的数据类型，也可以通过笔划和字母来比较，来查找相应的详细内容就是key-value，这也叫键值对
字典的特性：
无序
key必须是唯一的，在定义的时候就说明了这一点
常用语法：用上次做的一个购物车程序来用字典做一个数据结构

product_list = [('Iphone',5800),('Mac Pro',9800),('Bike',800),('Watch',10600),('Coffee',31),('Alex Python',120)
]product_list = {'Ipone':['金色','宽屏',5800],'Mac Pro':['金色',9800],'Bike':['山地',800],'Watch':['Iphone',10600],'Coffee':['猫寺',31],'Xiao ming':['book',120]
}#查询
print(product_list["Ipone"])        # 确定字典中有这个值
print(product_list.get("Ipone"))    # 安全
print('Ipone' in product_list)      # 判断值是否在字典中，打印true or false#改
product_list["Ipone"][0] = '银色'
product_list["Computer"] = ["Alice",32000]#删
print(product_list)
del product_list["Ipone"]
print(product_list)
product_list.pop("Xiao ming")
product_list.popitem()               # 随机删除
print(product_list)

['金色', '宽屏', 5800]
['金色', '宽屏', 5800]
True
{'Ipone': ['银色', '宽屏', 5800], 'Mac Pro': ['金色', 9800], 'Bike': ['山地', 800], 'Watch': ['Iphone', 10600], 'Coffee': ['猫寺', 31], 'Xiao ming': ['book', 120], 'Computer': ['Alice', 32000]}
{'Mac Pro': ['金色', 9800], 'Bike': ['山地', 800], 'Watch': ['Iphone', 10600], 'Coffee': ['猫寺', 31], 'Xiao ming': ['book', 120], 'Computer': ['Alice', 32000]}
{'Mac Pro': ['金色', 9800], 'Bike': ['山地', 800], 'Watch': ['Iphone', 10600], 'Coffee': ['猫寺', 31]}

product_list = {"手机":{"华为":["金色","256G","7800"],"小米":["银色","128G","5600"],"vivo":["白色","128G",1200]},"电脑":{"联想":["I7","1000G","5000"],"苹果":["I5","1000G","14000"],"戴尔":["I7","1000G","7000"]}
}# setdefault
print(product_list)
product_list["手机"]["华为"][0] = "黑色"
product_list.setdefault("桌子",{"联想":["黑色","青铜木","2800"]})        # 找得到就返回，不修改，找不到就创建一个新的Key值
print(product_list)
# update
b = {1:{'a':['a'],'b':['b']},"手机": {"替身": ["黑色", "256G", "7800"],"小米": ["黑色", "128G", "5600"],"vivo": ["黑色", "128G", 1200]}
}
product_list.update(b)                  #key相同就改变values，不同就添加
print(product_list)
print(product_list.items())               # 字典转列表
#fromkeys                                 # 用给点的元素生成字典
c = dict.fromkeys([1,2,3],[1,{"name":"alex"},444])
print(c)
c[1][1]['name'] = 'jack chen'
print(c)
# 循环字典
for i in product_list:print(i,product_list[i])

{'手机': {'华为': ['金色', '256G', '7800'], '小米': ['银色', '128G', '5600'], 'vivo': ['白色', '128G', 1200]}, '电脑': {'联想': ['I7', '1000G', '5000'], '苹果': ['I5', '1000G', '14000'], '戴尔': ['I7', '1000G', '7000']}}{'手机': {'华为': ['黑色', '256G', '7800'], '小米': ['银色', '128G', '5600'], 'vivo': ['白色', '128G', 1200]}, '电脑': {'联想': ['I7', '1000G', '5000'], '苹果': ['I5', '1000G', '14000'], '戴尔': ['I7', '1000G', '7000']}, '桌子': {'联想': ['黑色', '青铜木', '2800']}}{'手机': {'替身': ['黑色', '256G', '7800'], '小米': ['黑色', '128G', '5600'], 'vivo': ['黑色', '128G', 1200]}, '电脑': {'联想': ['I7', '1000G', '5000'], '苹果': ['I5', '1000G', '14000'], '戴尔': ['I7', '1000G', '7000']}, '桌子': {'联想': ['黑色', '青铜木', '2800']}, 1: {'a': ['a'], 'b': ['b']}}dict_items([('手机', {'替身': ['黑色', '256G', '7800'], '小米': ['黑色', '128G', '5600'], 'vivo': ['黑色', '128G', 1200]}), ('电脑', {'联想': ['I7', '1000G', '5000'], '苹果': ['I5', '1000G', '14000'], '戴尔': ['I7', '1000G', '7000']}), ('桌子', {'联想': ['黑色', '青铜木', '2800']}), (1, {'a': ['a'], 'b': ['b']})]){1: [1, {'name': 'alex'}, 444], 2: [1, {'name': 'alex'}, 444], 3: [1, {'name': 'alex'}, 444]}{1: [1, {'name': 'jack chen'}, 444], 2: [1, {'name': 'jack chen'}, 444], 3: [1, {'name': 'jack chen'}, 444]}手机 {'替身': ['黑色', '256G', '7800'], '小米': ['黑色', '128G', '5600'], 'vivo': ['黑色', '128G', 1200]}电脑 {'联想': ['I7', '1000G', '5000'], '苹果': ['I5', '1000G', '14000'], '戴尔': ['I7', '1000G', '7000']}桌子 {'联想': ['黑色', '青铜木', '2800']}1 {'a': ['a'], 'b': ['b']}

小项目 —–>三级菜单

逻辑和前面的一样，就是死循环然后退出与不退出的问题
可玩性可以设计的好玩一点

__Author__ = "kncc"anime = {'bilibili':{'七月头霸权':{'overload第三季':['七月制霸','七月制霸'],'刃牙':['七月制霸','七月制霸']},'七月底霸权':{'进击的巨人':['不多说了','不多说了'],'Planet With':['机甲良心番','机甲良心番']}},'爱奇艺':{'七月头霸权':{'高分少女':['漫画高分番','漫画高分番'],'杀戮天使':['10000','10000']},'七月底霸权':{'ISLAND':['最喜欢神社妹子','最喜欢神社妹子'],'春原庄的管理人':['手动滑稽','手动滑稽']},'优酷':{'七月头霸权': {'天狼': ['也是个不用说的番','也是个不用说的番'],'千绪的通学路': ['搞笑番,还挺好玩的','搞笑番,还挺好玩的']},'七月底霸权':{'异世界魔王与召唤少女的奴隶魔术': ['很h','很h'],'Free！ 第三季':['好像只有男主,耿美番？','好像只有男主,耿美番？']}}}
}while True:for i in anime:print(i)choice = input("选择进入1>>:")if choice in anime:while True:for i2 in anime[choice]:print("\t",i2)choice2 = input("选择进入2>>:")if choice2 in anime[choice]:while True:for i3 in anime[choice][choice2]:print("\t\t",i3)choice3 = input('选择进入3>>:')if choice3 in anime[choice][choice2]:for i4 in anime[choice][choice2][choice3]:print("\t\t\t",i4)choice4 = input("退出or返回: b or q>>:")if choice4 == 'b':passif choice4 == 'q':exit()if choice3 == 'b':breakif choice3 == 'q':exit()if choice2 == 'b':breakif choice2 == 'q':exit()if choice == 'q':exit()

bilibili
爱奇艺
选择进入1>>:bilibili七月头霸权七月底霸权
选择进入2>>:七月头霸权overload第三季刃牙
选择进入3>>:刃牙七月制霸七月制霸
退出or返回: b or q>>:boverload第三季刃牙
选择进入3>>:b七月头霸权七月底霸权
选择进入2>>:b
bilibili
爱奇艺
选择进入1>>:q

这一次就是所有的内容了，下一次我们会停止一下Python的更深入学习，会开始学习Python的一些socket网络编程库，然后开始写一些脚本，进行Poc的编写

———— 人生苦短，我用Python，荆轲刺秦王

Python学习笔记第二次之列表、字典、集合、数据结构应用之多级菜单相关推荐

Python学习第七课-元组字典集合
Python学习第七课-元组&字典&集合一.元组 1.1元组简介 1.2元组的拆包 1.3字符串拆包 1.4列表的拆包 1.5拆包练习二.字典的简介 2.1介绍 2.2操作三.字 ...
Python学习笔记19：列表 III
Python学习笔记19:列表 III 其实这篇笔记标题应该是列表扩展,从列表开始,将涵盖Python中的序列容器. 关于列表的基础知识,可以看我的前两篇文章: Python学习笔记1:列表. Pyt ...
python学习笔记（六）字典
python学习笔记(六)字典 1.字典初见 python中的字典实际上就是一系列的"键-值"对(key-value),它们之间时无序的,每一个键都必须有与之对应的值,这个值可以是 ...
Python学习笔记第二十九天(N维数组（ndarray）)
Python学习笔记第二十九天 N维数组(ndarray) 构建阵列索引阵列 ndarray的内部内存布局阵列属性内存布局数据类型其他属性阵列接口 ctypes外部功能接口 Array方法 ...
Python学习笔记D3（列表与元组）
Python学习笔记D3(列表与元组) 列表定义语法 number=[1,2,3,4,5] print(number,type(number)) #[1,2,3,4,5] <class'list ...
python基础一 -------如何在列表字典集合中根据条件筛选数据
如何在列表字典集合中根据条件筛选数据一:列表先随机生成一个列表,过滤掉负数 1,普通for循环迭代判断 2,filter()函数判断,filter(函数,list|tuple|string) 1 ...
Python学习笔记——字符串、列表、元组、字典
字符串介绍想一想: 当打来浏览器登录某些网站的时候,需要输入密码,浏览器把密码传送到服务器后,服务器会对密码进行验证,其验证过程是把之前保存的密码与本次传递过去的密码进行对比,如果相等,那么就认为密 ...
Python 学习笔记（2）字典默认值和集合的操作
一.设置字典默认值 #字典的 get方法可以根据获取 value = some_dict.get(key, default_value) 例子如下: b_dict={"a":1,& ...
python学习笔记（四）字典(dict)
创建 dict 方法 1: 创建一个空的 dict,这个空 dict,可以在以后向里面加东西用. >>> mydict = {} >>> mydict {} 不要小 ...

Python学习笔记第二次之列表、字典、集合、数据结构应用之多级菜单