Day 4 ：字典，集合，while循环

2020/8/23

字典

字典其实“键值对”的 无序可变序列。 其实就是 在字典的序列里 键值对 是里面的元素。键值对有 键对象 和 值对象。可以通过键对象来查找和改删值对象。
键对象 是不可以重复 且唯一。如果出现了重复的建队 后面的会覆盖前面的
值对象 就可以任意类型的

创建字典

用{} 花括号 a={“name”: “gaoqi”,“age”:“18”}
用dict（）函数 dict(name=‘gaoqi’,age=18)
用zip 函数

k=['name','age']
v=['gaoqi',18]
d = dict(zip(k,v))

也可以通过fromkeys 创建为空的字典

a= dict.fromkeys(['name','age'])
a ={‘name’：None,‘age’:None} # None是一个值 

访问字典元素

1. 通过键获得值对象 a[‘name’]
2. 通过get方式 指定键不存在的话 会返回none 或者返回默认对象 推荐使用 a.get(‘minzi’,‘不存在’)
3. 列出所有键值对 a.items()
4. 列出所有的键 和值 a.keys() a.values()
5. 键值的个数 len（）
6. 检测一个键是否在字典里用in ‘name’ in a

字典元素的添加和删除

1. 添加新的键值对。如果键已经存在，则覆盖原来的 a[‘address’]=‘beijing’
2. 使用update（）等于是合并两个字典，如果新的字典里有原来的键，那就直接覆盖
   b{‘phone’：187，‘sex’：‘male’，‘name’：xi}
   a.update(b) update括号里是新个字典
3. 字典元素的删除，使用del（）;或者clear（）全删；pop（）删除一个 返回这个元素

del(a['name'])
clear(a)
b= a.pop('name')

5. popitem（）随机删除和返回该键的值 ，因为字典是无序的。所以只会随机弹出一个元素

序列解包

序列解包 默认为键对象解包

b,c,e =a
b='name'
c='age'
e='phone'

想要用键值对的话就是

b,c,e = a.items

想要用值对象的话

b,c,e = a.values

小练习

d1={'name':'blue','age':16,'salary':5000,'city':'chongqing'}
d2={'name':'yellow','age':28,'salary':10000,'city':'ankang'}
d3={'name':'red','age':7,'salary':100,'city':'sichuan'}

tb=[d1,d2,d3]
g = d1.keys()

print(tb[1].get('name'))
print(g)
for i in range(len(tb)):
    
    print(tb[i].get('name'),tb[i].get('age'),tb[i].get('salary'),tb[i].get('city'))

字典核心底层原理

字典的核心是散列表。散列表本身也是个数组 ，就是不能放满。数据的每个单元叫做桶bucket，bucket里面有两个部分 就是键对象 和值对象。由于所有的bucket 结构都相同，所以可以通过偏移量来读取指定bucket。

集 合

集合是无序可变，元素是不能重复。实际上 集合也是字典实现的，但是只有字典的键对象。所以 集合里面的键是不可重复的
a = {1,2,3}
a.add(4)

2. 使用set（） 可以将列表，元组等可迭代对象转成集合，如果有重复的就保留一个
3. remove（）删除指定元素，clear（）清空整个集合

###相关操作
可以并集| a|b == a.union(b)，交集& a&b = a.difference(b)，差集- a-b = = a.intersection(b)
a={1,3,sxt}
b={‘he’,‘it’,‘sxt’}

选择结构

选择结构通过判断条件是否成立，来决定执行哪个分支。有单分支，双分支，多分支。

单分支

if 条件表达式:
语句块

其中
条件表达式可以式逻辑表达式，关系表达式，算数表达式等等
语句块： 可以是一条语句，也可以是多条语句，缩进必须对齐

num= int(input('input a number'))
if num >10:
	print(num)

在选择和循环结构中，条件表达式的值为false的情况如下：
False，0，0.0，空值None，空序列（空字典，空列表，空元组），空range对象，空迭代对象
其他情况均为true

t= "False"
if t
	print(这不是False)

在条件表达式中，不能有赋值操作符“=”，关系运算符

双分支

if 条件表达式：
语句1
else
语句2

s = int(input('请输入一个数字'))
if s > 20:
	print("数字大于20")
else：
	print("数字小于或等于20")

三元条件运算符
python 提供了三元运算符，用来在某些简单的双分支赋值，三元条件运算符语法格式如下：

条件为真时的值     if（条件表达式） else   条件为假时的值

#如上一个例子一样
print（"数字大于20"if s>20 else "数字小于或等于20"）

三元条件语句 主要就是更加简洁 美观

多分支

if 条件语句：
语句块
elif 条件语句：
语句块2
elif 条件语句：
语句块3
.。。。
elif 条件语句：
语句块n

score = int(input("输入你的成绩:"))
grade = ''
if score < 60:
	grade = '不及格'
elif score < 80：
	grade = '及格'
else:
	grade = '优秀'
print ("分数是：{0}，等级是：{1}"，format(score,grade) )

选择结构的嵌套

使用时一定要注意控制号代码的缩进量，缩进量决定了代码的从属关系。
if 表达式1：
语句块1
if 表达式2：
语句块2
else：
语句块3
else：
if 表达式4：
语句块4

score = int(input('输入一个0到100的数'))
grade = ''
if score < 0 or score > 100：
	score = int(input('输入错误，输入一个0到100的数'))
else：
	if score < 60:
	grade = '不及格'
	elif score < 80：
	grade = '及格'
	else:
	grade = '优秀'
print ("分数是：{0}，等级是：{1}"，format(score,grade) )
###########################################################
#简单方法
score = int(input('输入一个0到100的数'))
degree = ‘ABCDE’
num = 0
if score < 0 or score > 100：
	score = int(input('输入错误，输入一个0到100的数'))
else：
	num //= 10
	if num < 6:
		num = 5
	else: 
		print(your degree is {0},format(degree[9-num])

While 循环

while 条件表达式：
循环语句

num = 0
while num <= 10:
	print(num, end"\t")
	num += 1 
#计算100内的和
num2 = 0
sum = 0
while num<= 100:
	sum = sum +num2
	num += 1
print("1-100的加和是："，sum)