python控制语句包括分支语句和循环语句，另外还有顺序语句。
三种结构：顺序结构，选择结构，循环结构
顺序结构就是代码按顺序来执行，比如第一步先执行语句1，第二句再执行语句2，第三步再执行语句3。但这并不是说从上往下一句一句地执行代码。
分支语句也叫选择结构，依据某些条件来判断选择哪些代码语句来执行。就像去学校有很多条路，我们依据某一天的具体情况来决定走哪一条路。
循环语句也叫循环结构，依据是不是满足条件来一直循环某些代码语句。就像小明的身份是学生，那么它将不间断地每天都去上学。
科学家已经证实，由顺序结构，选择结构，循环结构组成的代码，能够解决任何问题。
目录
一，选择结构
1，单分支结构
2，双分支结构
3，多分支结构
4，分支结构的嵌套
二，循环结构
1，while循环
2，for循环和可迭代对象的遍历
1，for循环
2，可迭代对象
3，循环的嵌套
4，break语句和continue语句
三，python丰富的else用法
四，循环语句的优化
五，字典推导式和集合推导式
1，字典推导式
2，集合推导式
一，选择结构
1，单分支结构
一句话概括就是：要么做要么不做
a = 2
if a < 3:
print('yes')
a = 4
if a < 3:
print('yes')
#yes
# 代码按照顺序从第一行开始执行，然后执行第二句并依据是否满足条件来决定是执行第三句还是直接跑到第四句取执行，代码很明显条件是满足的，故要执行第三句。
# 然后是第四句。然后是第五句，明显条件不满足，所第五句不执行。
2，双分支结构
一句话概括就是：不管条件对错，二选一必须做一个
a = 2
if a < 3:
print('yes')
else:
print('no')
# yes
a = 4
if a < 3:
print('yes')
else:
print('no')
# no
python的三元运算符语法如下：口诀：真前假后
a = 1 b = 2 print(a if a >= b else b) # 2
3，多分支结构
一句话概括就是：多选一必须做一个。也就是给你很多个事情，如果条件为真你必须选一个事情做，当然这个事情可以是不做任何事情。
score = 80
if 60 <= score < 70:
print('d')
elif 70 <= score < 80:
print('c')
elif 80 <= score < 90:
print('b')
else:
print(666)
# b
假如我们条件为真却不想做任何事情，那么可以执行else下的代码来pass掉。另外，python支持60 <= score < 70这种数学上的写法，而不用and来连接两次判断。
4，分支结构的嵌套
分支结构支持嵌套，用缩进来确定代码块。
a = 10
if 0 <= a <= 9:
if a < 10:
print(1)
else:
print(2)
else:
if a < 10:
print(3)
else:
print(4)
# 4
二，循环结构
1，while循环
执行时，首先判断条件，当条件为真时，则进入循环的代码块执行。之后再来判断条件，如果为真，则进入循环的代码块执行。之后再来判断条件，如果为真，则进入循环的代码块执行……就这样无限重复下去。
当然，如果条件为假，则不会执行循环体，而是按照顺序结构去执行循环结构下面的代码。
flag = 0
sum = 0
while flag <= 100:
sum += flag
flag += 1
print(sum)
print(666)
# 5050
# 666
上面的代码计算从1一直加到100的和。循环结束后按顺序结构再执行print(666)。
2，for循环和可迭代对象的遍历
1，for循环
for循环的语法格式如下：
for 变量 in iteration:
对变量进行操作
iteration是一个可迭代对象。
变量指的是可迭代对象里的元素。从索引为0开始取数据，取完之后取索引为2的，……
for item in (1, 2, 3, 4, '666'):
print(item)
print(item)
# 1
# 2
# 3
# 4
# 666
# 666
上面的代码中，利用for循环，依次从一个元组中把他的数据取出来，然后再进行打印。
另外也可以看出，for循环代码块里的变量在代码块之外仍然能使用。
2，可迭代对象
可迭代对象包括序列，生成器函数，迭代器对象，文件对象。其中，序列包括：字符串，列表，元组，字典，集合。range对象就是迭代器对象。
什么是可迭代对象？能使用for循环进行循环遍历的对象，就叫可迭代对象。
3，循环的嵌套
也就是while循环的循环体里含有while循环或者for循环。
也就是for循环的循环体里含有while循环或者for循环。
外层循环在循环他的第一次循环期间，内层循环会把所有次数都循环完；外层循环在循环他的第二次循环期间，内层循环也会把所有次数都循环完；外层循环在循环他的第三次循环期间，内层循环会把所有次数都循环完；……
也就是外层循环一次，内层循环一圈。
range = 1
while range <= 6:
count = 1
while count <= range:
print(count, '*', range, '=', range * count, end=' ')
count += 1
range += 1
print('n')
# 1 * 1 = 1
#
# 1 * 2 = 2 2 * 2 = 4
#
# 1 * 3 = 3 2 * 3 = 6 3 * 3 = 9
#
# 1 * 4 = 4 2 * 4 = 8 3 * 4 = 12 4 * 4 = 16
#
# 1 * 5 = 5 2 * 5 = 10 3 * 5 = 15 4 * 5 = 20 5 * 5 = 25
#
# 1 * 6 = 6 2 * 6 = 12 3 * 6 = 18 4 * 6 = 24 5 * 6 = 30 6 * 6 = 36
上面的代码打印66乘法表。
4，break语句和continue语句
break语句：
break语句用于while和for循环，用来结束整个循环。当有嵌套循环时，break语句只能跳出最近一层的循环。也就是说假如break作用于内层循环，内层循环直接跳过不继续循环了，而去执行外层循环的下一次循环。
continue语句：
continue语句用于结束本次循环，继续下一次。多个循环嵌套时，continue也是应用于最近的一层循环。也就是说假如continue作用于内层循环，内层循环直接跳过本次了，而去执行内层循环的下一次循环。
三，python丰富的else用法
1，要么怎么样要么不怎么样
也就是if-else语法。不管怎么样都得二选一执行。
2，全都做完了要怎么样
这里是说循环结构也可加上else语句。当循环顺利执行完毕，才执行else语句，假如中间被break给跳出了循环，则不会执行else语句下面的代码块了。
for i in range(5):
print(i)
else:
print('最后的i的值是：', i)
# 0
# 1
# 2
# 3
# 4
# 最后的i的值是： 4
for i in range(5):
print(i)
if i == 3:
break
else:
print('最后的i的值是：', i)
# 0
# 1
# 2
# 3
3，没有问题的话怎么样
这是说try语句块如果啥异常也没有，就会执行else语句下的代码块。
def func(a, b):
print(a / b)
try:
func(1, 1)
except ZeroDivisionError as e:
print(e)
else:
print('一切正常')
# 1.0
# 一切正常
try:
func(1, 0)
except ZeroDivisionError as e:
print(e)
else:
print('一切正常')
# division by zero
四，循环语句的优化
由于嵌套循环的运行逻辑是外层的循环一次，内层循环一圈。这就造成了执行的代码会加倍的效果，如外层需要循环m次，内层需要循环n次，那么一共需要执行m*n次。
因此需要注意：
1，尽量使循环体里的计算表达式变少
2，在循环里尽量不要调用外部变量，使用局部变量效率更高。
五，字典推导式和集合推导式
1，字典推导式
字典推导式与列表推导式，元组推导式类似，不过字典推导式需要可迭代对象提供键值对，而不是单一的数据。
语法格式如下：
{key表达式: value表达式 for 可迭代对象里的元素 in 可迭代对象}
keys = ["1", "2", "3", "4"]
dict1 = {key: val for key, val in zip(keys, range(1, 5))}
print(dict1)
# {'1': 1, '2': 2, '3': 3, '4': 4}
2，集合推导式
集合推导式只是在列表推导式的基础上将中括号[]换成了小括号()而已。此时生成的是一个生成器对象，需要用tuple函数将生成器可迭代对象转化为元组。
tu1 = (i for i in range(5)) print(type(tu1)) print(tuple(tu1)) ## (0, 1, 2, 3, 4)
