python-day2

本次课程路径：https://www.cnblogs.com/alex3714/articles/5465198.html
本次课程路径：https://www.cnblogs.com/alex3714/articles/5717620.html
模块初始
模块分两种：模块也可叫做库
标准库：不需要安装直接导入即可使用的库
第三方库：必须要安装才可使用
标准库：
sys模块：导入模块名时不能和库名相同
import sys
print(sys.path) # python的环境变量，三方库都会装到site-packages，标准库在lib目录下
print(sys.argv) #调用执行脚本名字
print(sys.argv[2]) #调用脚本传参的第2个参数值
os模块：调用系统交互内容
import os
os.system("dir") # 调用win下的dir命令，乱码是因为win的字符编码与pycharm的utf-8不一致
import os
cmd_res = os.system("dir") #执行命令不保存结果
print("-->",cmd_res) #返回命令执行成功与否的代码0或非0
cmd_res = os.popen("dir") #执行命令保存结果
print("-->",cmd_res) #打印返回的是内存地址，必须加.read()才能输出执行结果
cmd_res = os.popen("dir").read() #执行命令并保持执行结果
输出结果：
C:\ProgramData\Anaconda3\python.exe C:/Users/Administrator/PycharmProjects/untitled/day2/os_mod.py
--> 驱动器 C 中的卷是 system
卷的序列号是 02DE-BFF0

C:\Users\Administrator\PycharmProjects\untitled\day2 的目录

2019/09/17 15:19 <DIR> .
2019/09/17 15:19 <DIR> ..
2019/09/17 15:19 162 os_mod.py
2019/09/17 15:04 131 sys_mod.py
2 个文件 293 字节
2 个目录 5,577,560,064 可用字节

Process finished with exit code 0

创建目录方法：
os.mkdir("new_dir")

第三方库：模块调用顺序，首先到当前目录下查找，然后到全局环境变量中查找
编写一个login.py脚本，内容如下：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:Donray
import getpass

_username = 'donray'
_password = '123'

user = input("请输入用户名：")
pwd = input("请输入密码：")
if user == _username and pwd == _password:
print("welcome user %s login"% user)
else:
print("Wrong username or password")
print(user,pwd)
把此login.py当作三方库调用
创建脚本login_mod.py加入下面一行
import login #直接执行就会调用上的脚本进行登录用户名和密码的输入

pyc是什么
3.5版本下
site-packages\_pycache_ 目录 下面有三方模块的*.pyc的文件
2.7版本下
就在site-packages当前目录下模块同级会有一个*.pyc的文件
编译型语言在程序执行之前，先会通过编译器对程序执行一个编译的过程，把程序转变成机器语言。运行时就不需要翻译，而直接执行就可以了。最典型的例子就是C语言

解释型语言就是没有这个编译的过程，而是在程序运行的时候，通过解释器对程序逐行做出解释，然后直接运行，最典型的例子是Ruby

而java首先是通过编译器编译成字节码文件，然后运行时通过解释器给解释成机器文件。所以我们说java是一种先编译后解释的语言。

python到底是什么？
其实python和java/C#一样，也是一门基于虚拟机的语言，我们先来从表面上简单了解一下python程序的运行过程吧。
当我们在命令行中输入python hello.py时，其实是激活了Python的“解释器”，告诉“解释器”：你要开始工作了。可是在“解释”之前，其实执行的第一项工作和Java一样，是编译。

熟悉Java的同学可以想一下我们在命令行中如何执行一个Java的程序：

javac hello.java

java hello
只是我们在用Eclipse之类的IDE时，将这两部给融合成了一部而已。其实Python也一样，当我们执行python hello.py时，他也一样执行了这么一个过程，所以我们应该这样来描述Python，Python是一门先编译后解释的语言。

简述Python的运行过程

在说这个问题之前，我们先来说两个概念，PyCodeObject和pyc文件。

我们在硬盘上看到的pyc自然不必多说，而其实PyCodeObject则是Python编译器真正编译成的结果。我们先简单知道就可以了，继续向下看。

当python程序运行时，编译的结果则是保存在位于内存中的PyCodeObject中，当Python程序运行结束时，Python解释器则将PyCodeObject写回到pyc文件中。

当python程序第二次运行时，首先程序会在硬盘中寻找pyc文件，如果找到，则直接载入，否则就重复上面的过程。

所以我们应该这样来定位PyCodeObject和pyc文件，我们说pyc文件其实是PyCodeObject的一种持久化保存方式。

调用库时，会对比源代码和pyc文件的更新时间，如果源代码时间较新便会重新编译一遍存入到pyc文件中。

python数据类型：type()查看数据类型
1、数字
2 是一个整数的例子。
长整数 不过是大一些的整数。
3.23和52.3E-4是浮点数的例子。E标记表示10的幂。在这里，52.3E-4表示52.3 * 10-4。
(-5+4j)和(2.3-4.6j)是复数的例子，其中-5,4为实数，j为虚数，数学中表示复数是什么？。

int（整型）

　　在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
　　在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807

long（长整型）python3以后没有long的长整型了，只有int整型
　　跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。
　　注意，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。

float（浮点型）
先扫盲 http://www.cnblogs.com/alex3714/articles/5895848.html
　　浮点数用来处理实数，即带有小数的数字。类似于C语言中的double类型，占8个字节（64位），其中52位表示底，11位表示指数，剩下的一位表示符号。

complex（复数）
　　复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。
注：Python中存在小数字池：-5 ～ 257

2、布尔值
　　真或假
　　1 或 0
3、字符串
"hello world"
万恶的字符串拼接：
　　python中的字符串在C语言中体现为是一个字符数组，每次创建字符串时候需要在内存中开辟一块连续的空，并且一旦需要修改字符串的话，就需要再次开辟空间，万恶的+号每出现一次就会在内从中重新开辟一块空间。
字符串格式化输出
name = "alex"
print "i am %s " % name

#输出: i am alex
PS: 字符串是 %s;整数 %d;浮点数%f

字符串常用功能：
移除空白
分割
长度
索引
切片
4、列表
创建列表：

name_list = ['alex', 'seven', 'eric']
或
name_list ＝ list(['alex', 'seven', 'eric'])
基本操作：

索引
切片
追加
删除
长度
切片
循环
包含
5、元组(不可变列表)
创建元组：

ages = (11, 22, 33, 44, 55)
或
ages = tuple((11, 22, 33, 44, 55))

6、字典（无序）
创建字典：

person = {"name": "mr.wu", 'age': 18}
或
person = dict({"name": "mr.wu", 'age': 18})
常用操作：

索引
新增
删除
键、值、键值对
循环
长度

数据运算：
edu.51cto.com/course/course_id-6039.html

跟alex学python之python开发基础-1

一、bytes数据类型
python3最重要的新特性大概要算对文本和二进制数据做了更为清晰的区分，文本总是unicode字符集，有str类型表示，二进制数据则有bytes类型表示。python3不会以任何隐式的方式混用str和bytes，正是这是的这两者的区别特别明显，你不能拼接字符串和字节包，也无法在字节包里搜索字符串（反之亦然），也不能将字符串传入参数为字节包的函数（反之亦然）；
我们不关心字符串在内部是如何被表示的，也不关心它用几个字节来表示每个字符。只有在将字符串编码成字节（如用于通信信道的传输）或将字节解码成字符串时，才考虑这些问题。
转换编码格式：
msg = "我爱北京天安门"
print(msg)
print(msg.encode(encoding="utf-8"))
print(msg.encode(encoding="utf-8").decode(encoding="utf-8"))

二、三元运算：
result = 值1 if 条件 else 值2
如果条件为真：result = 值1
如果条件为假：result = 值2

举例：
a,b,c, = 1,3,5
d = a if a >b else c

三、进制

二进制，01
八进制，01234567
十进制，0123456789
十六进制，0123456789ABCDEF 二进制到16进制转换 http://jingyan.baidu.com/album/47a29f24292608c0142399cb.html?picindex=1
计算机内存地址和为什么用16进制？
为什么用16进制
1、计算机硬件是0101二进制的，16进制刚好是2的倍数，更容易表达一个命令或者数据。十六进制更简短，因为换算的时候一位16进制数可以顶4位2进制数，也就是一个字节（8位进制可以用两个16进制表示）
2、最早规定ASCII字符集采用的就是8bit(后期扩展了,但是基础单位还是8bit)，8bit用2个16进制直接就能表达出来，不管阅读还是存储都比其他进制要方便
3、计算机中CPU运算也是遵照ASCII字符集，以16、32、64的这样的方式在发展，因此数据交换的时候16进制也显得更好
4、为了统一规范，CPU、内存、硬盘我们看到都是采用的16进制计算

16进制用在哪里
1、网络编程，数据交换的时候需要对字节进行解析都是一个byte一个byte的处理，1个byte可以用0xFF两个16进制来表达。通过网络抓包，可以看到数据是通过16进制传输的。
2、数据存储，存储到硬件中是0101的方式，存储到系统中的表达方式都是byte方式

3、一些常用值的定义，比如：我们经常用到的html中color表达，就是用的16进制方式，4个16进制位可以表达好几百万的颜色信息。

列表、元组操作：
变量存储内容一般为字符串和数字

列表相同于shell中的数组概念，是存储了多个项的变量
如：将学生名称设定了一组变量叫names，取值时按照顺序0为第一个名称取值即可
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:Donray
names = ["Zhangyang","Guyun","Xiangpeng","Xuliangchen"]
print(names[0],names[2])
结果输出：
C:\ProgramData\Anaconda3\python.exe C:/Users/Administrator/PycharmProjects/untitled/day2/names.py
Zhangyang Xiangpeng

Process finished with exit code 0
同时取出两个学生名称：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:Donray
names = ["Zhangyang","Guyun","Xiangpeng","Xuliangchen"]
print(names[1:3]) #切片，取其中一段数据
print(names[0:3])和print(names[:3]) # 效果一样 都是取前面三个值
输出结果：
['Guyun', 'Xiangpeng']
以上为从左到右进行取值，也可以反过来从右到左取值
print(names[-1])
输出结果：
Xuliangchen
从右倒左取中间两个值的写法
print(names[-3:-1])
输出结果：
['Guyun', 'Xiangpeng']
完全取出后面2个名称：
print(names[-2:])
输出结果：
['Xiangpeng', 'Xuliangchen']
变量列表中追加一个变量值：
names.append("LeiHaidong")
print(names[-3:])
输出结果：
['Xiangpeng', 'Xuliangchen', 'LeiHaidong'] #能看到追加进去一个LeiHaidong
任意位置追加：
names.insert(1,"ChenRonghua")
print(names[:3])
输出结果：
['Zhangyang', 'ChenRonghua', 'Guyun'] #能看到Guyun的位置被插入了ChenRonghua，Guyun顺移到后面的位置
替换任意位置的变量值：
names[2] = "XieDi" #直接写位置赋值即可
print(names)
输出结果：
['Zhangyang', 'ChenRonghua', 'XieDi', 'Xiangpeng', 'Xuliangchen', 'LeiHaidong']
# 'XieDi'把之前的 'Guyun'替换掉了
删除某个位置的变量值：三种方式
1、names.remove("ChenRonghua")
2、del names[1]
3、names.pop() # 删除了最后一个名称
#pop默认不输入下标的话会删除最后一个值，输入下标后会删除下标所在位置的值
通过某个变量值查找列表中所在位置：
print (names.index("XieDi")) #查找XieDi所在的位置
输出结果：
['Zhangyang', 'Guyun', 'Xiangpeng', 'Xuliangchen', 'XieDi']
4
输出位置并写出名称
print ( names[names.index("XieDi")])
输出结果：
4
XieDi
统计某个变量
print (names.count("ChenRonghua"))
输出结果：
2 #表示有两个ChenRonghua
清除列表信息：
names.clear()
print (names)
输出结果：
[]
列表顺序翻转：
names.reverse()
print (names)
输出结果：
['XieDi', 'Xuliangchen', 'Xiangpeng', 'ChenRonghua', 'Guyun', 'ChenRonghua', 'Zhangyang']
排序：
names.sort()
输出结果：按照字母顺序排序
['ChenRonghua', 'ChenRonghua', 'Guyun', 'Xiangpeng', 'XieDi', 'Xuliangchen', 'Zhangyang']
#按照ASCII码排序规则，特殊符号、数字、大写、小写
扩展列表：将两组列表合并
names2 = [1,2,3,4]
names.extend(names2)
print(names)
输出结果：
['ChenRonghua', 'ChenRonghua', 'Guyun', 'Xiangpeng', 'XieDi', 'Xuliangchen', 'Zhangyang', 1, 2, 3, 4]
复制列表：这里copy只是浅copy，如果names变量又做更改，copy后的变量不会改变。因为只是映射了同一内存地址，改names2，names会更改，改names不会改names2
name2 = names.copy()
print(names)
print(name2)
输出结果：
['Zhangyang', 'Guyun', 'ChenRonghua', 'Xiangpeng', 'Xuliangchen']
['Zhangyang', 'Guyun', 'ChenRonghua', 'Xiangpeng', 'Xuliangchen']
在列表里包含列表：
names = ["Zhangyang","Guyun","ChenRonghua","Xiangpeng",["donray","alex"],"Xuliangchen"]
names[4][1] = "jack"
输出结果：把alex换成了jack
['Zhangyang', 'Guyun', 'ChenRonghua', '向鹏', ['donray', 'jack'], 'Xuliangchen']
copy的使用：
import copy
person=['name',['saving',100]]
#三种浅copy实现方式如下：
p1=copy.copy(person)
p2=person[:]
p3=list(person)
使用场景：夫妻使用统一账户取钱,一方取走50元，另一方账户也会少50元
import copy
person=['name',['saving',100]]
p1=person[:]
p2=person[:]
p1[0]='alex'
p2[0]='fengjie'
p1[1][1]=50
print(p1)
print(p2)
结果输出：
['alex', ['saving', 50]]
['fengjie', ['saving', 50]]
使用深copy：
import copy #首先要调用copy模块
names2 = copy.deepcopy(names) #此方法是深copy，克隆了一份独立的内存空间存储names2
列表循环：
names = ["Zhangyang","Guyun","ChenRonghua","Xiangpeng",["donray","alex"],"Xuliangchen"]
for i in names:
print (i)
输出结果：
Zhangyang
Guyun
ChenRonghua
Xiangpeng
['donray', 'alex']
Xuliangchen
跳着切片：
names = ["Zhangyang","Guyun","ChenRonghua","Xiangpeng",["donray","alex"],"Xuliangchen"]
print (names[0:-1:2])
print (names[::2])
输出结果：一样，因为0和-1可以省略
['Zhangyang', 'ChenRonghua', ['donray', 'alex']]
['Zhangyang', 'ChenRonghua', ['donray', 'alex']]

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

语法：
names = ("alex","jack","eric")
它只有2个方法，一个是count,一个是index，完毕。
使用场景：适用于某些不会被改动的变量信息

购物车程序：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:Donray
product_list = [
('Iphone',5800),
('Mac Pro',9800),
('Bike',800),
('Watch',10600),
('Coffee',31),
('Alex Python',120),
]
shopping_list = []
salary = input("Input your salary:") #输入工资数目
if salary.isdigit(): #判断输入的工资是否是数字
salary = int(salary) #给数字声明整数类型
while True: #进入循环
for index,item in enumerate(product_list): #取出下标列在列表的序号位置
#print(product_list.index(item),item)
print(index,item)
user_choice = input("选择要买嘛？>>>:") #用户选择买什么东西
if user_choice.isdigit(): # 判断用户输入是否是数字类型
user_choice = int(user_choice) #给变量声明数字类型
if user_choice < len(product_list) and user_choice >=0: #避免输入序号范围要在产品列表范围内，并且大于等于0
p_item = product_list[user_choice] #通过下标取出商品
if p_item[1] <= salary: #买得起 #判断是否可以买得起
shopping_list.append(p_item) #将买的起的加入shopping_list中
salary -= p_item[1] #从工资中扣钱出去
print("Added %s into shopping cart,your current balance is \033[31;1m%s\033[0m" %(p_item,salary)) #打印出来余额
else:
print("\033[41;1m你的余额只剩[%s]啦，还买个毛线\033[0m" % salary) #买不起打印余额并提示买不起
else:
print("product code [%s] is not exist!" %user_choice) # 商品序号不存在提示
elif user_choice == 'q': # 指定输入q为退出
print ("----------shopping list-----------") #退出时打印已购商品列表和余额
for p in shopping_list: # 取出已购商品为变量p
print(p) #打印出来已购商品
print("Your current balance:",salary) #显示余额
exit() #退出
else:
print("invalid option") #输入错误提示键值错误

字符串操作

特性：不可修改
name.capitalize() 首字母大写
name.casefold() 大写全部变小写
name.center(50,"-") 输出 '---------------------Alex Li----------------------'
name.count('lex') 统计 lex出现次数
name.encode() 将字符串编码成bytes格式
name.endswith("Li") 判断字符串是否以 Li结尾
"Alex\tLi".expandtabs(10) 输出'Alex Li'， 将\t转换成多长的空格
name.find('A') 查找A,找到返回其索引， 找不到返回-1

format :
>>> msg = "my name is {}, and age is {}"
>>> msg.format("alex",22)
'my name is alex, and age is 22'
>>> msg = "my name is {1}, and age is {0}"
>>> msg.format("alex",22)
'my name is 22, and age is alex'
>>> msg = "my name is {name}, and age is {age}"
>>> msg.format(age=22,name="ale")
'my name is ale, and age is 22'
format_map
>>> msg.format_map({'name':'alex','age':22})
'my name is alex, and age is 22'

msg.index('a') 返回a所在字符串的索引
'9aA'.isalnum() True

'9'.isdigit() 是否整数
name.isnumeric
name.isprintable
name.isspace
name.istitle
name.isupper
"|".join(['alex','jack','rain'])
'alex|jack|rain'

maketrans
>>> intab = "aeiou" #This is the string having actual characters.
>>> outtab = "12345" #This is the string having corresponding mapping character
>>> trantab = str.maketrans(intab, outtab)
>>>
>>> str = "this is string example....wow!!!"
>>> str.translate(trantab)
'th3s 3s str3ng 2x1mpl2....w4w!!!'

msg.partition('is') 输出 ('my name ', 'is', ' {name}, and age is {age}')

>>> "alex li, chinese name is lijie".replace("li","LI",1)
'alex LI, chinese name is lijie'

msg.swapcase 大小写互换

>>> msg.zfill(40)
'00000my name is {name}, and age is {age}'

 

>>> n4.ljust(40,"-")
'Hello 2orld-----------------------------'
>>> n4.rjust(40,"-")
'-----------------------------Hello 2orld'

>>> b="ddefdsdff_哈哈"
>>> b.isidentifier() #检测一段字符串可否被当作标志符，即是否符合变量命名规则
True

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:Donray

name = "my \tname is donray"
name1 = "my \tname is {name} and i am {year} old"
print(name.capitalize()) #首字母大写
print(name.count("a")) #统计变量中有几个a
print(name.center(50,"-")) #打印50个字符，不够用-补全
print(name.endswith("ay")) #判断字符串是否以ay结尾
print(name.expandtabs(tabsize=20)) #把tab键转成多少个空格
print(name.find("name")) #查找到某字符串所在的位置
print(name[name.find("name"):9]) #切片后截取字段
print(name1.format(name='donray',year=23)) #变量中插入变量值
print(name1.format_map( {'name':'donray','year':13} )) #同上，用字典方式引用
print('ab24'.isalnum()) #阿拉伯数字加阿拉伯字符组合的字符
print('abA'.isalpha()) #纯英文字符
print('1A'.isdecimal()) #十进制
print('1'.isdigit()) #是否为整数
print('a1'.isidentifier()) #判断是不是一个合法的标识符，变量名是否合法
print('a1'.isnumeric()) #判断是否为纯数字
print('a1'.isspace()) #是否为空格
print('a1'.istitle()) #是否为title，每个字母大写则为title
print('My Name Is '.isprintable()) #类似tty设备终端无法打印，其余均为可打印设备
print('My Name Is '.isupper()) #是否均为大写
print( ','.join(['1','2','3','4']) ) #将列表组合成一个字符，前面为间隔符
print(name.ljust(50,'*')) #长度为50个字符，后面不够用*补齐
print(name.rjust(50,'*')) #长度为50个字符，前面不够用*补齐
print(name.lower()) #把大写变成小写
print(name.upper()) #吧小写变成大写
print(name.lstrip()) #从左边去除空格和回车
print(name.rstrip()) #从右边去除空格和回车
print(name.strip()) #两边都去掉空格和回车
p = str.maketrans("abcdef",'123456')
print("donray dong".translate(p)) #将donray dong字符按照上面的对应关系，替换为数字
#结果4onr1y 4ong，一般用作密码加密解密使用
print("donray".replace('d','D')) #替换的用法，将所有d换成D
print("donrayd".replace('d','D',1)) #替换的用法，只替换一个
print("donrayd".rfind('d')) #从左往右找出最后一个d的下标
print("donrayd".split('n')) #分隔字符串,按d分隔字符串
print("don\nrayd".splitlines()) #按照换行来分隔字符串
#print("donrayd".startswith()) #
print('donrayd'.swapcase()) #替换为大写
print('donrayd'.title()) #变成title，首字母大写
print('donrayd'.zfill(50)) #50长度不够用0填充

字典操作--常用操作

字典一种key - value 的数据类型，使用就像我们上学用的字典，通过笔划、字母来查对应页的详细内容。

语法:

info = {
'stu1101': "TengLan Wu",
'stu1102': "LongZe Luola",
'stu1103': "XiaoZe Maliya",
}

字典的特性：
dict是无序的
key必须是唯一的,so 天生去重

增加：
>>> info["stu1104"] = "苍井空"
>>> info
{'stu1102': 'LongZe Luola', 'stu1104': '苍井空', 'stu1103': 'XiaoZe Maliya', 'stu1101': 'TengLan Wu'}

修改：
>>> info['stu1101'] = "武藤兰"
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1101': '武藤兰'}

删除：
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1101': '武藤兰'}
>>> info.pop("stu1101") #标准删除姿势
'武藤兰'
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
>>> del info['stu1103'] #换个姿势删除
>>> info
{'stu1102': 'LongZe Luola'}
>>>
>>>
>>>
>>> info = {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'} #随机删除
>>> info.popitem()
('stu1102', 'LongZe Luola')
>>> info
{'stu1103': 'XiaoZe Maliya'}

查找：
>>> info = {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
>>>
>>> "stu1102" in info #标准用法
True
>>> info.get("stu1102") #获取
'LongZe Luola'
>>> info["stu1102"] #同上，但是看下面
'LongZe Luola'
>>> info["stu1105"] #如果一个key不存在，就报错，get不会，不存在只返回None
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'stu1105'

多级字典嵌套及操作：
av_catalog = {
"欧美":{
"www.youporn.com": ["很多免费的,世界最大的","质量一般"],
"www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],
"letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],
"x-art.com":["质量很高,真的很高","全部收费,屌比请绕过"]
},
"日韩":{
"tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"]
},
"大陆":{
"1024":["全部免费,真好,好人一生平安","服务器在国外,慢"]
}
}

av_catalog["大陆"]["1024"][1] += ",可以用爬虫爬下来"
print(av_catalog["大陆"]["1024"])
#ouput
['全部免费,真好,好人一生平安', '服务器在国外,慢,可以用爬虫爬下来']

其它姿势：
#values
>>> info.values() #打印出所有的值
dict_values(['LongZe Luola', 'XiaoZe Maliya'])

#keys
>>> info.keys() #打印出所有的key
dict_keys(['stu1102', 'stu1103'])

#setdefault #先到字典里找对应值，如果可以去到就打印出来，如果取不到就创建新值
>>> info.setdefault("stu1106","Alex")
'Alex'
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
>>> info.setdefault("stu1102","龙泽萝拉")
'LongZe Luola'
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}

#update #合并两个字典，交叉信息覆盖，没有的信息添加
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
>>> b = {1:2,3:4, "stu1102":"龙泽萝拉"}
>>> info.update(b)
>>> info
{'stu1102': '龙泽萝拉', 1: 2, 3: 4, 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}

#items #把字典转成列表
info.items()
dict_items([('stu1102', '龙泽萝拉'), (1, 2), (3, 4), ('stu1103', 'XiaoZe Maliya'), ('stu1106', 'Alex')])

#通过一个列表生成默认dict,有个没办法解释的坑，少用吧这个
>>> dict.fromkeys([1,2,3],'testd')
{1: 'testd', 2: 'testd', 3: 'testd'}

循环dict：
#方法1：更高效，推荐使用
for key in info:
print(key,info[key])

#方法2：由字典转成列表的过程，数据量大无法完成执行
for k,v in info.items(): #会先把dict转成list,数据里大时莫用
print(k,v)
###########################################################
程序练习：
程序: 三级菜单

要求:

打印省、市、县三级菜单
可返回上一级
可随时退出程序

复杂写法：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:Donray
data = {
'北京':{
'海淀':{
'五道口':{
'soho':{},
'网易':{},
'google':{}
},
'中关村':{
'爱奇艺':{},
'汽车之家':{},
'youku':{},
},
'上地':{
'百度':{},
},
},
'昌平':{
'沙河':{
'老男孩':{},
'北航':{},
},
'天通苑':{},
'回龙观':{},
},
'朝阳':{},
'东城':{},
},
'上海':{
'闵行':{
"人民广场":{
'炸鸡店':{}
}
},
'闸北':{
'火车战':{
'携程':{}
}
},
'浦东':{},
},
}
exit_flag = False

while not exit_flag:
for i in data:
print(i)

choice = input("选择进入1>>:")
if choice in data:
while not exit_flag:
for i2 in data[choice]:
print("\t",i2)
choice2 = input("选择进入2>>:")
if choice2 in data[choice]:
while not exit_flag:
for i3 in data[choice][choice2]:
print("\t\t", i3)
choice3 = input("选择进入3>>:")
if choice3 in data[choice][choice2]:
for i4 in data[choice][choice2][choice3]:
print("\t\t", i4)
choice4 = input("最后一层，按b返回>>:")
if choice4 == "b":
pass
elif choice4 == "q":
exit_flag = True
if choice3 == "b":
break
elif choice3 == "q":
exit_flag = True
if choice2 == "b":
break
elif choice2 == "q":
exit_flag = True

简易写法：
menu = {
'北京':{
'海淀':{
'五道口':{
'soho':{},
'网易':{},
'google':{}
},
'中关村':{
'爱奇艺':{},
'汽车之家':{},
'youku':{},
},
'上地':{
'百度':{},
},
},
'昌平':{
'沙河':{
'老男孩':{},
'北航':{},
},
'天通苑':{},
'回龙观':{},
},
'朝阳':{},
'东城':{},
},
'上海':{
'闵行':{
"人民广场":{
'炸鸡店':{}
}
},
'闸北':{
'火车战':{
'携程':{}
}
},
'浦东':{},
},
'山东':{},
}

exit_flag = False
current_layer = menu

layers = [menu]

while not exit_flag:
for k in current_layer:
print(k)
choice = input(">>:").strip()
if choice == "b":
current_layer = layers[-1]
#print("change to laster", current_layer)
layers.pop()
elif choice not in current_layer:continue
else:
layers.append(current_layer)
current_layer = current_layer[choice]

集合操作

集合是一个无序的，不重复的数据组合，它的主要作用如下：
去重，把一个列表变成集合，就自动去重了
关系测试，测试两组数据之前的交集、差集、并集等关系

常用操作:
s = set([3,5,9,10]) #创建一个数值集合

t = set("Hello") #创建一个唯一字符的集合

a = t | s # t 和 s的并集

b = t & s # t 和 s的交集

c = t – s # 求差集（项在t中，但不在s中）

d = t ^ s # 对称差集（项在t或s中，但不会同时出现在二者中）



基本操作：

t.add('x') # 添加一项

s.update([10,37,42]) # 在s中添加多项



使用remove()可以删除一项：

t.remove('H')


len(s)
set 的长度

x in s
测试 x 是否是 s 的成员

x not in s
测试 x 是否不是 s 的成员

s.issubset(t)
s <= t
测试是否 s 中的每一个元素都在 t 中

s.issuperset(t)
s >= t
测试是否 t 中的每一个元素都在 s 中

s.union(t)
s | t
返回一个新的 set 包含 s 和 t 中的每一个元素

s.intersection(t)
s & t
返回一个新的 set 包含 s 和 t 中的公共元素

s.difference(t)
s - t
返回一个新的 set 包含 s 中有但是 t 中没有的元素

s.symmetric_difference(t)
s ^ t
返回一个新的 set 包含 s 和 t 中不重复的元素

s.copy()
返回 set “s”的一个浅复制

购物车作业：
用户入口：
1、商品信息存在文件中
2、已购商品，余额记录。

商家入口：
2、可以添加商品，修改商品价格