八、推导式创建序列
1、列表推导式
[x for x in range(1,5)]
[a for a in "abcdef"]
2、字典推导式
格式：{key:value, for 表达式 in 可迭代对象}
例子：统计文本中字符出现的次数
3、集合推导式
{表达式 for item in 可迭代对象}
{x for x in range(1,1000) if x %9=0}
4、生成器推导式（生成元组）
gnt=(x for x in range(1,1000) if x%9=0)
元组是没有推导式的，生成的之是一个生成器对象，只能运行一次
七、zip实行并行die'dai
六、循环代码优化技巧
1、尽量减少循环内部不必要的计算
2、嵌套循环中，尽量减少内层循环的计算，尽可能向外提
3、局部变量查询较快，尽量使用局部变量。
4、其他优化手段
1）连接多个字符串，使用join不用+
os.path.join(a,b)
2）列表进行元素插入和删除，尽量在尾部使用
五、else语句
如果for，while语句没有被break中断，则会执行else语句，否则不执行。
四、continue语句
1、概念：continue语句用于结束本次循环，积雪下一次，多个嵌套循环时，continue也是应用于最近的一层循环。
num=0
totalSalary=0
salarys=[]
while True:
s=input("输入员工薪资,按Q结束")
if s.upper()=="Q":
print("end")
break
三、break语句
1、概念：break可用于while和for循环，用来结束整个循环。当有嵌套循环时，break语句只能跳出最近的一层的xun'huan
二、嵌套循环
打印99乘法表
一、for 循环和可迭代对象变量
1、表达式
for 变量 in 可迭代对象
for x in (20,30,40):
2、可迭代对象
字符串，列表，元组，字典，迭代器对象，生成器函数
3、遍历字典
for x in d
for x in d.keys():
for x in d.values():
for x in d.items():
4、range对象
range(start,end,step)
5、while循环语句
死循环：while True：
1）
while num<=10:
print(num)
num+=1
2) 计算1到100的和
num=1
i=0
while num<=100:
i+=num
num+=1
print(i)
4、选择结构的嵌套
if语句里面继续套用if语句
score=int(input(""))
degree="ABCDE"
num=0
if score>100 or score<0
print("overlimited")
else:
num=score//10
if num<6:
num=5
print(degree[9-num])
3、多分支结构选择
if-elif语句
可以判断很多种情况，只要有一组条件语句为真，则跳出整个if-elifyu'ju
print("s is larger than 10" if int(s)>10 else
"s is smaller than 10")
二、集合
1、概念：集合是无序可变的，元素不能重复，集合底层是字典是先。集合的所有元素都是字典中的键对象。
2、集合的创建
1) a={3,5,7}
a.add(9)
a={3,5,7,9}
2) 使用set（）
3) remove()删除指定元素；clear（）清空整个集合
3、集合相关操作
a|b 并集 a.union(b)
a&b 交集 a.intersection(b)
a-b 差集 a.difference(b)
9、核心底层原理：查找键值对的底层过程
a.get("name")
"lixuan"
取散列值时三位三位的取
，如果为空，返回None。如果不为空，则将这个bucket的键对象计算对应的散列值，和我们的散列值进行比较，如果相等，则将对应的值对象返回。如果不相等，再依次取其它几位数字，重新计算偏移量。
总结：
1）键必须可散列：数字字符串元组都是可散列的
2）字典在内存中开销巨大，典型的空间换时间
3）键查询速度很快
4）往字典里面添加新建可能导致扩容，导致散列表中键的次序变化。因此，不要在遍历字典的同时修改zi'dian
8、核心底层原理：
字典对象的核心是散列表。散列表是一个稀疏数组，数组的每个单元叫做bucket，每个bucket由两部分，一个是键对象的引用，一个是值对象的引用。可以通过偏移量来读取指定bucket。
bin(hash("name")) 得到散列值。找到为空的bucket里。
7、表格数据使用字典和列表存储，并实现访问
a={"name":"高小一", "age"":18, "薪资":30000,"城市":"北京"}
b={"name":"高小二", "age"":19, "薪资":20000,"城市":"上海"}
c={"name":"高小三", "age"":20, "薪资":10000,"城市":"深圳"}
t=[a,b,c]
print(t[1].get("age")): 获取第二个的age项的值，
需求：遍历所有的薪资
for i in range(len(t)):
print(t[i].get("salary")
需求：打印表的所有数据
for i in range(len(t)):
print(t[i].get("name"),t[i].get("age"),t[i].get("薪资"),t[i].get("城市")）
4、字典元素的添加
a={}
a["address"]="lilei" 添加时若key存在覆盖，不存在添加。
5、update（）将所有键值对全部添加到旧字典上
a={"name":"lilei","age":18}
b={"gender":"man"}
a.update(b)
a={"name":"lilei","age":18,"gender":"man"}
6、del（a["name"]）
clear 删除所有的键值对，
a.pop("age"): 删除的同时提取值
popitem随机删除
3、字典元素的访问
1）通过键获得值，若键不存在，抛出异常
a["name"]
2) 通过get获得值，优点是若键不存在，返回none
3）列出所有的键值对
print（a）
4) 列出所有的键
a.keys()
a.values()
5) len 返回键值对的个数
len（a）
6) 检测一个键是否在字典中
“name”in a
true or false
一、字典
1、概念：字典是键值对的无序的可变序列
键：整数，浮点数，字符串，元组
2、字典的创建：
a={"name":"lilei","age":18}
b=dict(name="lilei",age=18)
a=dict([("name","lilei"),("age",18)])
c={}
d=dict()
通过zip方式
k=["name","age"]
v=["lilei",18]
d=dict(zip(k,v))
7、生成器推导式创建元素
产生的是生成器对象
s=(x*2 for x in range(5))
print(tuple(s))
(0,2,4,6,8)
# s.__next__() 每次就打印一次,超过会报异常
8、元组的总结
1）核心是不可变序列
2) 元组的访问和处理速度比列表快
3) 与整数和字符串一样，元组可以作为字典的键，列表永远不可能作为字典的键
