4、python字典、集合、分支结构、循环结构的while

(一)、字典
字典是有键值对构成的无序可变的序列，每个元素都是一个键值对，包含键对象和值对象。与列表通过"下标数字"获取数据类似，字典通过键对象获取值对象。整数、浮点数、字符串、元组等不可变对象可以构成字典的键，字典、列表、集合等可变对象不能构成列表的键。若字典中的键重复，后出现的键的键值对将会覆盖之前的。
1.1、字典的创建
1.1.1、{键1:值1,键2:值2,…,键n:值n}
dist(键1:值1,键2:值2,…,键n:值n)
dist([(键1,值1)(,键2,值2),…,(键n,值n)])
1.1.2、dist(zip(列表1,列表2,…,列表n)) zip对象
1.1.3、dict.fromkeys([键1,键2,…,键n]) 获得值为None（这也是一个对象）的字典。

1.2、字典元素的访问
1.2.1、dict[键]获取键对应的值对象，当键不存在时报错
dict.get(键,键不存在返回的对象)获取键对应的值对象，当键不存在时不会报错且，默认返回None。
1.2.2、dict.items()返回所有键值对dict_items对象[(键1,值1)(,键2:值2),…,(键n:值n)]，可用于迭代。
1.2.3、dict.keys()返回所有键dict_keys[键1,键2,…,键n]
1.2.4、dict.values()返回所有dict_values[值1,值2,…,值n]
1.2.5、len(dict)返回键值对的个数
1.2.6、键 in dict()：检测一个键是否在字典里面，True or False

1.3、元素的修改和删除
1.3.1、dict[键]=值：新增键值对，如果键已经存在，则覆盖旧的键值对；如果键不存在，则新增键值对。
1.3.2、a.update(b):将a、b字典合并，键有重复b覆盖a
1.3.3、del(dict[键]) 删除相应的键值对;dict.clear()删除所有键值对;dict.pop(键) 删除相应的键值对并返回值对象
1.3.5、dict.popitem() 随机删除键值对并返回键值对，因为字典是无序的，没有第一个元素也没有最后一个元素

1.4、序列解包
1.4.1、多个变量a,b,c=1,2,3 右侧实际是个元组 得到a=1,b=2,c=3
列表[a,b,c]=[1,2,3]，得到a=1,b=2,c=3
元组(a,b,c)=(1,2,3)，得到a=1,b=2,c=3
1.4.2、=左右两边的数量要对上
字典键: 键1,…,键n=dict 得到 键1,…,键n 分别取dict 中的键
字典键值对: 键值对1,…,键值对n=dict.items() 得到 键值对1,…,键值对n，键值对1为元组(键1,值1)
字典值: 值1,…,值n=dict.values() 得到 值1,…,值n 分别取dict 中的值

1.5、通过字典和列表表示表格：1个字典表示一行

r1={'name':'a','age':18,'salary':100,'city':'北京'}
r2={'name':'b','age':19,'salary':200,'city':'深圳'}
r3={'name':'c','age':19,'salary':300,'city':'广州'}
t=[r1,r2,r3]
for i in range(3):
	print(t[i].get('salary'))
for i in range(3):
	print(t[i].get('name')+' '+str(t[i].get('age'))+' '\
              +str(t[i].get('salary'))+' '+t[i].get('city'))

1.6字典底层原理
字典底层是一个稀疏的数组（散列表，总是有很多空白元素），数组由bucket组成，一个bucket存放一个键对象、值对象的引用。所有bucket结构大小一致，通过偏移量0,1,…,n读取。
存储键值对过程：将键值通过一定分方法与偏移量映射上，例如（计算键值的散列值-末尾n位n位的取-检测对应bucket是否为空，为空放进去，不为空回到上一步取下个n位），当超过2/3的bucket有值时会进行扩容。
查找值对象过程：计算键值的散列值-末尾n位n位的取-获取对应bucket键的散列值并比较是否一致，不一致回到上一步取下个n位，一致返回值对象，找不到返回None。
字典的键值必须可散列，自定义对象时要满足：1、支持hash()函数2、支持__eq__()方法检测相等性3、若a==b为真 则 hash(a)==hash(b)为真
字典在内存开销巨大，是用空间换时间
字典的增加可能会导致扩容，导致散列表键的次序变化，不要一边遍历一边修改数据
（二）、集合
集合：无序可变的序列，不含重复的元素，底层通过字典实现，只存储键对象，故不能重复。
集合的创建：a={元素1,元素2…},a=set(列表、元组等可迭代对象)：重复数据只保留一个
增加元素：a.add(元素)
删除元素：a.remove(元素)
清空元素：a.clear()
并集：a|b、a.union(b) 新的集合
交集：a&b a.intersection(b) 新的集合
差集：a-b a.difference(b) 新的集合
（三）、选择结构
单分支结构：只对True进行判断处理
双分支结构：对True、False都进行判断处理
多分支结构：对True、False都进行判断处理为False再套if

3.1、单分支结构：

if 条件表达式:
	语句块

False、0、0.0、None、空序列（空字符串、空列表、空元组、空字典、空集合）、空range()、空的迭代对象都判断为False。

s="False"
if s:
	print('非空字符串，是True')

3.2、双分支结构：条件表达式如果出现“=”会报错

if 条件表达式:
	语句块
else :
	语句块

三元条件运算符：条件为真时候的值 if 条件表达式 else 条件为假时候的值

s=input('请输入数字：')
if int(s)<10:
	print('数字小于10')
else:
	print('数字不小于10')
##等价于
print('数字小于10' if int(s)<10 else '数字不小于10')

3.3、多分支结构：else语句块可选，有分支之间有逻辑顺序不能随意调换

if 条件表达式1:
	语句块1
elif 条件表达式2: 
	语句块2
...
elif 条件表达式n:
	语句块n
else :
	语句块n+1
嵌套分支结构：
if 条件表达式:
	语句块
	if 条件表达式:
		语句块
	else :
		语句块
else :
	语句块
	if 条件表达式:
		语句块
	else :
		语句块

s=int(input('请输入0-100的分数：'))
g=''
if s<0 or s>100:
	s=int(input('请输入0-100的分数：'))
else:
	if s>=90:
		g='A'
	elif s>=80:
		g='B'
	elif s>=70:
		g='C'
	elif s>=60:
		g='D'
	else:g='F'
	print('分数为{0}，成绩为{1}'.format(s,g))
##等价于
g='ABCDE'
s=int(input('请输入0-100的分数：'))
if s<0 or s>100:
	s=int(input('请输入0-100的分数：'))
else:
	ss=s//10
	if ss<6:
		ss=5
	print('分数为{0}，成绩为{1}'.format(s,g[9-ss]))

（四）、循环
while循环：

while 条件表达式:
	循环体

###计算0-100的累加和
num=0
sum=0
while num<=100:
	sum+=num
	num+=1
print(sum)

打印表格并筛选工资

r1={'name':'a','age':18,'salary':100,'city':'北京'}
r2={'name':'b','age':19,'salary':200,'city':'深圳'}
r3={'name':'c','age':19,'salary':300,'city':'广州'}
t=[r1,r2,r3]
for i in t:
	print(i)
	if i.get('salary')>200:
		print(i)