第四章 流程控制
python提供了两种基本流程控制结构：分支结构和循环结构。其中分支结构用于实现根据条件来选择性地执行某段代码；循环结构则用于实现根据循环条件重复执行某段代码。python使用if语句提供分支支持，提供了while、for-in循环，也提供了break和continue来控制程序的循环结构。
顺序结构
顺序结构就是程序从上到下一行行地执行，中间没有任何判断和跳转，排在前面的代码先执行，排在后面的代码后执行。
if分支结构
if分支使用布尔表达式或布尔值作为分支条件来进行分支控制。
if分支即可作为语句使用，也可作为表达式使用。
if语句有如下三种形式：
- 第一种形式
if expression :
statements
- 第二种形式
if expression :
statements
else :
statements
- 第三种形式
if expression :
statements
elif expression :
statements
... // 可以有零条或多条elif语句
else :
statement
在上面的条件语句中，if expression : 、 elif expression : 和 else : 后缩进的多行代码被称为代码块，被当成一个整体来执行，这个代码块也被称为条件执行体
python是一门很独特的语言，它的代码块是通过缩进来标记的（大部分语言都是用花括号或end作为代码块的标记），具有相同缩进的多行代码属于同一个代码块。如果代码莫名其妙地乱缩进，python解释器会报错。
s_age = input("请输入您的年龄:")
age = int(s_age)
if age > 20 :
# 只有当age > 20时，下面用整体缩进的代码块才会执行
# 整体缩进的语句是一个整体，要么一起执行，要么一起不执行
print("年龄已经大于20岁了")
print("20岁以上的人应该学会承担责任...")
输出结果：
请输入您的年龄:28
年龄已经大于20岁了
20岁以上的人应该学会承担责任...
再次强调：python不是格式自由的语言，不能碎银所欲地缩进，必须按python语法要求缩进。下面介绍缩进过程中可能导致的错误
不要忘记缩进
代码块一定要缩进，否则就不是代码块
s_age = input("请输入您的年龄:")
age = int(s_age)
if age > 20 :
print("年龄已经大于20岁了")
输出结果：
runfile('C:/Users/zh/.spyder-py3/temp.py', wdir='C:/Users/zh/.spyder-py3')
File "C:Userszh.spyder-py3 emp.py", line 4
print("年龄已经大于20岁了")
^
IndentationError: expected an indented block
注意：if条件后的条件执行体一定要缩进，只有缩进后的代码才能算条件执行体。
有些时候，python解释器不会报错，但并不代表程序没有错误，示例：
s_age = input("请输入您的年龄:")
age = int(s_age)
if age > 20 :
print("年龄已经大于20岁了")
print("20岁以上的人应该学会承担责任...")
输出结果：
请输入您的年龄:12
20岁以上的人应该学会承担责任...
如果忘记正确地缩进，很可能导致程序的运行结果超出我们的预期，示例：
# 定义变量b，并为其赋值
b = 5
if b > 4:
# 如果b>4，则执行下面的执行体，只有一行代码作为代码块
print("b大于4")
else:
# 否则，执行下面的执行体，只有一行代码作为代码块
b -= 1
# 对于下面代码而言，它已经不再是条件执行体的一部分，因此总会执行
print("b不大于4")
输出结果：
b大于4
b不大于4
if、else、elif 后的条件执行体必须使用相同缩进的代码块，将这个代码块整体作为条件执行体，当if后有多条语句作为条件执行体时，如果忘记了缩进某一行代码，则会引起语法错误，示例：
# 定义变量c，并为其赋值
c = 5
if c > 4:
# 如果c>4，则执行下面的执行体，将只有c-=1一行代码为执行体
c -= 1
# 下面是一行普通代码，不属于执行体
print("c大于4")
# 此处的else将没有if语句，因此编译出错
else
# 否则，执行下面的执行体，只有一行代码作为代码块
print("c不大于4")
输出结果：
File "C:Userszh.spyder-py3 emp.py", line 9
else
^
SyntaxError: invalid syntax
不要随意缩进
虽然python语法允许代码块随意缩进N个空格，但同一个代码块内的代码必须保持相同的缩进
s_age = input("请输入您的年龄:")
age = int(s_age)
if age > 20 :
print("年龄已经大于20岁了")
print("20岁以上的人应该学会承担责任...")
输出结果：
File "C:Userszh.spyder-py3 emp.py", line 5
print("20岁以上的人应该学会承担责任...")
^
IndentationError: unexpected indent
s_age = input("请输入您的年龄:")
age = int(s_age)
if age > 20 :
print("年龄已经大于20岁了")
print("20岁以上的人应该学会承担责任...")
输出结果：
File "C:Userszh.spyder-py3 emp.py", line 5
print("20岁以上的人应该学会承担责任...")
^
IndentationError: unindent does not match any outer indentation level
通过上面介绍可以看出，python代码块中的所有语句必须保持相同的缩进，既不能多、也不能少。
需要说明的是，对于不需要使用代码块的地方，千万不要随意缩进，否则程序也会报错，示例：
msg = "Hello, Charlie"
print(msg)
输出结果：
File "C:Userszh.spyder-py3 emp.py", line 2
print(msg)
^
IndentationError: unexpected indent
不要遗忘冒号
从python语法解释器的角度来看，python冒号精确表示代码块的开始点 --- 这个功能不仅在条件执行体中如此，后面的循环体、方法体、类体全部遵循该规则。
如果遗忘了冒号，那么python解释器将无法识别代码块的开始点，示例：
age = 24
if age > 20
print("年龄已经大于20岁了")
print("20岁以上的人应该学会承担责任...")
输出结果：
File "C:Userszh.spyder-py3 emp.py", line 2
if age > 20
^
SyntaxError: invalid syntax
if条件的类型
python执行if语句时，会判断if条件是True还是False。那么if条件是不是只能使用bool类型的表达式呢？不是。if条件可以使任意类型，当下面的值作为bool表达式时，会被解释器当做False处理。
False、None、0、""、()、[]、{}
除了False本身，各种代表“空”的None、空字符串、空元组、空列表、空字典 都会被当成False处理。
# 定义空字符串
s = ""
if s :
print('s不是空字符串')
else:
print('s是空字符串')
# 定义空列表
my_list = []
if my_list:
print('my_list不是空列表')
else:
print('my_list是空列表')
# 定义空字典
my_dict = {}
if my_dict:
print('my_dict不是空字典')
else:
print('my_dict是空字典')
输出结果：
s是空字符串
my_list是空列表
my_dict是空字典
上面可以看到，if条件分别使用了str类型、list类型、dict类型，由于这些str、list、dict都是空值，因此python会把它们当成False处理。
if分支的逻辑错误
else的隐含条件是对前面条件取反。在使用if else 语句时有一条基本规则：总是优先把包含范围小的条件放在前面处理。 对比age>60和age>20两个条件，明显age>60的范围更小，所以应该先处理age>60的情形。
age = 45
if age > 20 :
print("青年人")
# 在原本的if条件中增加了else的隐含条件
if age > 40 and not(age > 20) :
print("中年人")
# 在原本的if条件中增加了else的隐含条件
if age > 60 and not(age > 20) and not(age > 40 and not(age > 20)) :
print("老年人")
上面这个语句，后面两个if语句永远不会执行，第2个if语句 等价于 age> 40 && age <= 20 ，这个条件永远不会满足。
age = 45
if age > 60 :
print("老年人")
elif age > 40 :
print("中年人")
elif age > 20 :
print("青年人")
输出结果：
中年人
上面程序等同于下面程序：
age = 45
if age > 60 :
print("老年人")
# 在原本的if条件中增加了else的隐含条件
if age > 40 and not(age >60) :
print("中年人")
# 在原本的if条件中增加了else的隐含条件
if age > 20 and not(age > 60) and not(age > 40 and not(age >60)) :
print("青年人")
当使用if else语句进行流程控制时，一定不要忽略了else所带的隐含条件。
if表达式
if表达式相当于其他语言中的三目运算符，之前讲过，此处不再赘述。
pass语句
很多程序都提供了“空语句”支持，python也不例外，python的pass语句就是空语句。
有时候程序需要占一个位、放一条语句，但又不希望这条语句做任何事情，此时就可通过pass语句来实现。通过使用pass语句，可以让程序更完整。
s = input("请输入一个整数: ")
s = int(s)
if s > 5:
print("大于5")
elif s < 5:
# 空语句，相当于占位符
pass
else:
print("等于5")
断言
断言语句和if分支有点类似，它用于对一个bool表达式进行断言，如果该bool表达式为True，该程序可以继续往下执行；否则程序会引发 AssertionError 错误，示例：
s_age = input("请输入您的年龄:")
age = int(s_age)
assert 20 < age < 80
print("您输入的年龄在20和80之间")
输出结果：
请输入您的年龄:10
Traceback (most recent call last):
File "C:Userszhanghu.spyder-py3 emp.py", line 3, in <module>
assert 20 < age < 80
AssertionError
请输入您的年龄:40
您输入的年龄在20和80之间
从上面的运行过程可以看到，断言也可以对逻辑表达式进行判断，因此实际上断言也相当于一个特殊分支：
if 条件为False :
程序引发AssertionError错误
循环结构
循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体。当反复执行这个循环体时，需要在合适的时候将循环条件改为假，从而结束循环；否则循环将一直执行下去，形成死循环。循环语句可能包含如下4部分：
- 初始化语句（init_statements）
- 循环条件（test_statement）
- 循环体（body_statement）
- 迭代语句（iteration_statement）
while循环
while循环的语法格式：
[init_statement]
while test_expression :
body_expression
[iteration_expression]
# 循环的初始化条件
count_i = 0
# 当count_i小于10时，执行循环体
while count_i < 10 :
print("count:", count_i)
# 迭代语句
count_i += 1
print("循环结束!")
输出结果：
count: 0
count: 1
count: 2
count: 3
count: 4
count: 5
count: 6
count: 7
count: 8
count: 9
循环结束!
如下是死循环示例：
# 下面是一个死循环
count_i2 = 0
while count_i2 < 10 :
print("不停执行的死循环:", count_i2)
count_i2 -=1
print("永远无法跳出的循环体")
注意：while循环的循环体中所有代码必须使用相同缩进，否则python也会引发错误（下面是一个死循环），示例：
# 循环的初始化条件
count_i = 0
# 当count小于10时，执行循环体
while count_i < 10:
print('count_i的值', count_i)
count_i += 1
count_i += 1 代码不属于循环体，导致程序变成了一个死循环。
使用while循环遍历列表和数组
由于列表和元组的元素都是有索引的，因此程序可通过while循环、列表或元组的索引来遍历列表和元组中的所有元素。示例：
a_tuple = ('fkit', 'crazyit', 'Charli')
i = 0
# 只有i小于len(a_list)，继续执行循环体
while i < len(a_tuple):
print(a_tuple[i]) # 根据i来访问元组的元素
i += 1
输出结果：
fkit
crazyit
Charli
遍历列表，示例：
src_list = [12, 45, 34,13, 100, 24, 56, 74, 109]
a_list = [] # 定义保存整除3的元素
b_list = [] # 定义保存除以3余1的元素
c_list = [] # 定义保存除以3余2的元素
# 只要src_list还有元素，继续执行循环体
while len(src_list) > 0:
# 弹出src_list最后一个元素
ele = src_list.pop()
# 如果ele % 2不等于0
if ele % 3 == 0 :
a_list.append(ele) # 添加元素
elif ele % 3 == 1:
b_list.append(ele) # 添加元素
else:
c_list.append(ele) # 添加元素
print("整除3:", a_list)
print("除以3余1:",b_list)
print("除以3余2:",c_list)
输出结果：
整除3: [24, 45, 12]
除以3余1: [109, 100, 13, 34]
除以3余2: [74, 56]
for-in循环
for-in循环专门用于遍历范围、列表、元组和字典等可迭代对象包含的元素。for-in循环的语法格式如下：
for 变量 in 字符串|范围|集合等 :
statements
对于上面的语法格式有两点说明：
- for-in循环中的变量（此变量也称为循环计数器）的值受for-in循环控制，该变量将会在每次循环开始时自动被赋值，因此程序不应该在循环中对该变量赋值（虽然赋值也不会报错，但没有什么意义）
- for-in循环可用于遍历任何可迭代对象。所谓可迭代对象，就是指该对象中包含一个_iter_方法，且该方法的返回值对象具有next()方法。
遍历范围，示例：
s_max = input("请输入您想计算的阶乘:")
mx = int(s_max)
result = 1
# 使用for-in循环遍历范围
for num in range(1, mx + 1):
result *= num
print(result)
输出结果：
请输入您想计算的阶乘:7
5040
使用for-in循环遍历列表和元组
遍历元组，示例：
a_tuple = ('crazyit', 'fkit', 'Charlie')
for ele in a_tuple:
print('当前元素是:', ele)
输出结果：
当前元素是: crazyit
当前元素是: fkit
当前元素是: Charlie
遍历列表，示例:
src_list = [12, 45, 3.4, 13, 'a', 4, 56, 'crazyit', 109.5]
my_sum = 0
my_count = 0
for ele in src_list:
print("元素：",ele)
# 如果该元素是整数或浮点数
if isinstance(ele, int) or isinstance(ele, float):
print(ele)
# 累加该元素
my_sum += ele
# 数值元素的个数加1
my_count += 1
print('总和:', my_sum)
print('平均数:', my_sum / my_count)
输出结果：
元素： 12
12
元素： 45
45
元素： 3.4
3.4
元素： 13
13
元素： a
元素： 4
4
元素： 56
56
元素： crazyit
元素： 109.5
109.5
总和: 242.9
平均数: 34.7
上面程序中使用了python的isinstance函数，该函数用于判断某个变量是否为指定类型的实例，其中前一个参数是要判断的变量，后面一个参数是类型。
如果需要，for-in循环也可通过索引来遍历列表或元组：只要让循环计数器遍历0到列表长度的区间，即可通过该循环计数器访问列表元素，示例：
a_list = [330, 1.4, 50, 'fkit', -3.5]
# 遍历0到len(a_list)的范围
for i in range(0, len(a_list)) :
# 根据索引访问列表元素
print("第%d个元素是 %s" % (i , a_list[i]))
输出结果：
第0个元素是 330
第1个元素是 1.4
第2个元素是 50
第3个元素是 fkit
第4个元素是 -3.5
使用for-in循环遍历字典
使用for-in循环遍历字典其实也是通过遍历普通列表来实现的。前面提到，字典包含了三个方法：
- items():返回字典中所有key-value对的列表
- key():返回字典中所有key的列表
- values():返回字典中所有value的列表
my_dict = {'语文': 89, '数学': 92, '英语': 80}
# 通过items()方法遍历所有key-value对
# 由于items方法返回的列表元素是key-value对，因此要声明两个变量
for key, value in my_dict.items(): // 序列解包的应用，使用2个变量来接收
print('key:', key)
print('value:', value)
print('-------------')
# 通过keys()方法遍历所有key
for key in my_dict.keys():
print('key:', key)
# 在通过key获取value
print('value:', my_dict[key])
print('-------------')
# 通过values()方法遍历所有value
for value in my_dict.values():
print('value:', value)
输出结果：
key: 语文
value: 89
key: 数学
value: 92
key: 英语
value: 80
-------------
key: 语文
value: 89
key: 数学
value: 92
key: 英语
value: 80
-------------
value: 89
value: 92
value: 80
假如需要一个程序：用于统计列表中各元素出现的次数。由于我们不清楚列表中包含多少个元素，因此考虑定义一个字典，以列表的元素为key，该元素出现的次数为value。示例：
src_list = [12, 45, 3.4, 12, 'fkit', 45, 3.4, 'fkit', 45, 3.4]
statistics = {}
for ele in src_list:
# 如果字典中包含ele代表的key
if ele in statistics:
# 将ele元素代表出现次数加1
statistics[ele] += 1
# 如果字典中不包含ele代表的key，说明该元素还未出现国
else:
# 将ele元素代表出现次数设为1
statistics[ele] = 1
print(statistics)
# 遍历dict，打印出各元素的出现次数
for ele, count in statistics.items():
print("%s的出现次数为:%d" % (ele, count))
输出结果：
{12: 2, 45: 3, 3.4: 3, 'fkit': 2}
12的出现次数为:2
45的出现次数为:3
3.4的出现次数为:3
fkit的出现次数为:2
循环使用else
python的循环都可以定义else代码块，当循环条件为False时，程序会执行else代码块。
count_i = 0
while count_i < 5:
print('count_i小于5: ', count_i)
count_i += 1
else:
print('count_i大于或等于5: ', count_i)
输出结果：
count_i小于5: 0
count_i小于5: 1
count_i小于5: 2
count_i小于5: 3
count_i小于5: 4
count_i大于或等于5: 5
上面程序等同于：
count_i = 0
while count_i < 5:
print('count_i小于5: ', count_i)
count_i += 1
print('count_i大于或等于5: ', count_i)
从这个角度看，else代码块其实没有太大的价值。
循环的else代码块是python的一个很特殊的语法（其他编程语言通常不支持），else代码块的主要作用是便于生成更优雅的python代码。
for循环同样可使用else代码块，当for循环把区间、元组或列表的所有元素遍历一次之后，for循环会执行else代码块，在else代码块中，循环计数器的值依然等于最后一个元素的值。
a_list = [330, 1.4, 50, 'fkit', -3.5]
for ele in a_list:
print('元素: ', ele)
else:
# 访问循环计数器的值，依然等于最后一个元素的值
print('else块: ', ele)
输出结果：
元素: 330
元素: 1.4
元素: 50
元素: fkit
元素: -3.5
else块: -3.5
嵌套循环
如果把一个循环放在另一个循环体内，那么就可以形成嵌套循环。嵌套循环就是把内层循环当成外层循环的循环体，只有内层循环的循环条件为假时，才会完全跳出内层循环，才可以结束外层循环的当次循环，开始下一个循环。
# 外层循环
for i in range(0, 5) :
j = 0
# 内层循环
while j < 3 :
print("i的值为: %d , j的值为: %d" % (i, j))
j += 1
输出结果：
i的值为: 0 , j的值为: 0
i的值为: 0 , j的值为: 1
i的值为: 0 , j的值为: 2
i的值为: 1 , j的值为: 0
i的值为: 1 , j的值为: 1
i的值为: 1 , j的值为: 2
i的值为: 2 , j的值为: 0
i的值为: 2 , j的值为: 1
i的值为: 2 , j的值为: 2
i的值为: 3 , j的值为: 0
i的值为: 3 , j的值为: 1
i的值为: 3 , j的值为: 2
i的值为: 4 , j的值为: 0
i的值为: 4 , j的值为: 1
i的值为: 4 , j的值为: 2
for表达式
for表达式用于利用其他区间、列表、元组等可迭代对象创建新的列表。for表达式的语法格式如下：
[表达式 for 循环计数器 in 可迭代对象 ]
for表达式和普通for循环的区别有两点：
- 在for关键字之前定义一个表达式，该表达式通常会包含循环计数器
- for表达式没有循环体，因此不需要冒号
for表达式当然也是有循环的，它同样会对可迭代对象进行循环 --- 可迭代对象包含多个对象，该循环就对for之前的“表达式”执行几次（相当于for之前的表达式就是循环体），并将每次执行的值收集起来作为新的列表元素。
for表达式最终返回的是列表，因此for表达式也被称为列表推导式
a_range = range(10)
# 对a_range执行for表达式
a_list = [x * x for x in a_range]
# a_list集合包含10个元素
print(a_list)
输出结果：
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
还可以在for表达式后面添加if条件，这样for表达式将只迭代那些符合条件的元素，示例：
a_range = range(10)
b_list = [x * x for x in a_range if x % 2 == 0]
# a_list集合包含5个元素
print(b_list)
输出结果：
[0, 4, 16, 36, 64]
如果将for表达式的方括号改为圆括号，for表达式将不再生成列表，而是生成一个生成器（generator），该生成器同样可使用for循环迭代。
对于使用圆括号的for表达式，它最终返回的是生成器，因此这种for表达式也被称为生成器推导式。示例：
a_range = range(10)
# 使用for表达式创建生成器
c_generator = (x * x for x in a_range if x % 2 == 0)
print("类型：",type(c_generator))
# 使用for循环迭代生成器
for i in c_generator:
print(i, end=' ')
print()
输出结果：
类型： <class 'generator'>
0 4 16 36 64
在前面看到的for表达式只有一个循环，实际上for表达式可使用多个循环，就像嵌套循环一样，示例：
d_list = [(x, y) for x in range(5) for y in range(4)]
# d_list列表包含20个元素
print(d_list)
输出结果：
[(0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (4, 0), (4, 1), (4, 2), (4, 3)]
上面代码中,x是遍历range(5)的计数器，y是遍历ra的计数器，上面for表达式相当于如下嵌套循环：
dd_list = []
for x in range(5):
for y in range(4):
dd_list.append((x, y))
print(dd_list)
输出结果：
[(0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (4, 0), (4, 1), (4, 2), (4, 3)]
三层嵌套的for表达式，示例：
e_list = [[x, y, z] for x in range(5) for y in range(4) for z in range(6)]
# 3_list列表包含120个元素
print(e_list)
输出结果：
[[0, 0, 0], [0, 0, 1], [0, 0, 2], [0, 0, 3], [0, 0, 4], [0, 0, 5], [0, 1, 0], [0, 1, 1], [0, 1, 2], [0, 1, 3], [0, 1, 4], [0, 1, 5], [0, 2, 0], [0, 2, 1], [0, 2, 2], [0, 2, 3], [0, 2, 4], [0, 2, 5], [0, 3, 0], [0, 3, 1], [0, 3, 2], [0, 3, 3], [0, 3, 4], [0, 3, 5], [1, 0, 0], [1, 0, 1], [1, 0, 2], [1, 0, 3], [1, 0, 4], [1, 0, 5], [1, 1, 0], [1, 1, 1], [1, 1, 2], [1, 1, 3], [1, 1, 4], [1, 1, 5], [1, 2, 0], [1, 2, 1], [1, 2, 2], [1, 2, 3], [1, 2, 4], [1, 2, 5], [1, 3, 0], [1, 3, 1], [1, 3, 2], [1, 3, 3], [1, 3, 4], [1, 3, 5], [2, 0, 0], [2, 0, 1], [2, 0, 2], [2, 0, 3], [2, 0, 4], [2, 0, 5], [2, 1, 0], [2, 1, 1], [2, 1, 2], [2, 1, 3], [2, 1, 4], [2, 1, 5], [2, 2, 0], [2, 2, 1], [2, 2, 2], [2, 2, 3], [2, 2, 4], [2, 2, 5], [2, 3, 0], [2, 3, 1], [2, 3, 2], [2, 3, 3], [2, 3, 4], [2, 3, 5], [3, 0, 0], [3, 0, 1], [3, 0, 2], [3, 0, 3], [3, 0, 4], [3, 0, 5], [3, 1, 0], [3, 1, 1], [3, 1, 2], [3, 1, 3], [3, 1, 4], [3, 1, 5], [3, 2, 0], [3, 2, 1], [3, 2, 2], [3, 2, 3], [3, 2, 4], [3, 2, 5], [3, 3, 0], [3, 3, 1], [3, 3, 2], [3, 3, 3], [3, 3, 4], [3, 3, 5], [4, 0, 0], [4, 0, 1], [4, 0, 2], [4, 0, 3], [4, 0, 4], [4, 0, 5], [4, 1, 0], [4, 1, 1], [4, 1, 2], [4, 1, 3], [4, 1, 4], [4, 1, 5], [4, 2, 0], [4, 2, 1], [4, 2, 2], [4, 2, 3], [4, 2, 4], [4, 2, 5], [4, 3, 0], [4, 3, 1], [4, 3, 2], [4, 3, 3], [4, 3, 4], [4, 3, 5]]
对于包含多个循环的for表达式，同样可指定if条件，
src_a = [30, 12, 66, 34, 39, 78, 36, 57, 121]
src_b = [3, 5, 7, 11]
# 只要y能整除x，就将它们配对在一起
result = [(x, y) for x in src_b for y in src_a if y % x == 0]
print(result)
输出结果：
[(3, 30), (3, 12), (3, 66), (3, 39), (3, 78), (3, 36), (3, 57), (5, 30), (11, 66), (11, 121)]
常用工具函数
使用zip()函数可以把两个列表“压缩”成一个zip对象（可迭代对象），这样就可以使用一个循环并行遍历两个列表。zip()函数压缩得到的可迭代对象所包含的元素是员列表元素组成的元组。如果zip()函数压缩的两个列表长度不相等，那么zip()函数将以长度更短的列表为准。如果使用zip()函数压缩N个列表，那么zip()函数返回的可迭代对象的元素就是长度为N的元组。
books = ['aaa', 'bbb', 'ccc']
prices = [79, 69, 89]
# 使用zip()函数压缩两个列表，从而实现并行遍历
for book, price in zip(books, prices):
print("%s的价格是: %5.2f" % (book, price))
输出结果：
aaa的价格是: 79.00
bbb的价格是: 69.00
ccc的价格是: 89.00
有些时候，程序需要进行反向遍历，此时可通过reversed()函数，该函数可接收各种序列（元组、列表、区间等）参数，然后返回一个“反向排列”的迭代器，该函数对参数本身不会产生任何影响。示例：
books = range(10)
b=[ x for x in reversed(books) ]
print(b)
print(books)
输出结果：
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
range(0, 10)
前面提到过，str其实也是序列，因此可通过函数实现在不影响字符串本身的前提下，对字符串实现反向遍历。示例：
a = "helle world,hello python!!"
b=[ x for x in reversed(a) ]
print(b)
print(a)
输出结果：
['!', '!', 'n', 'o', 'h', 't', 'y', 'p', ' ', 'o', 'l', 'l', 'e', 'h', ',', 'd', 'l', 'r', 'o', 'w', ' ', 'e', 'l', 'l', 'e', 'h']
helle world,hello python!!
与reversed函数类似的还有sorted()函数，该函数接收一个可迭代对象作为参数，返回一个对元素排序的列表。该函数对参数本身不会产生任何影响。该函数只是返回一个新的、排序号的列表。使用该函数时，可传入一个reverse参数，当reverse设置为True时，则表示反向排序。还可传入一个len参数，该参数可指定一个函数来生成排序的关键值。
控制循环结构
python提供了break和continue来控制循环结构，使用return可以结束整个方法，当然也就结束了一次循环
使用break结束循环
break用于完全结束一个循环，跳出循环体，开始执行循环之后的代码。
# 一个简单的for循环
for i in range(0, 10) :
print("i的值是: ", i)
if i == 2 :
# 执行该语句时将结束循环
break
else:
print('else块: ', i)
输出结果：
i的值是: 0
i的值是: 1
i的值是: 2
为了使用break语句跳出嵌套循环的外层循环，定义一个bool类型的变量来标志是否需要跳出外层循环，然后在内层循环、外层循环中分别使用break语句来实现，示例：
exit_flag = False
# 外层循环
for i in range(0, 5) :
# 内层循环
for j in range(0, 3 ) :
print("i的值为: %d, j的值为: %d" % (i, j))
if j == 1 :
exit_flag = True
# 跳出里层循环
break
# 如果exit_flag为True，跳出外层循环
if exit_flag :
break
输出结果：
i的值为: 0, j的值为: 0
i的值为: 0, j的值为: 1
使用continue忽略本次循环的剩余语句
continue只是忽略当次循环的剩下语句，接着开始下一次循环，并不会中止循环；而break则是完全中止循环本身。
# 一个简单的for循环
for i in range(0, 3 ) :
print("i的值是: ", i)
if i == 1 :
# 忽略本次循环的剩下语句
continue
print("continue后的输出语句")
输出结果：
i的值是: 0
continue后的输出语句
i的值是: 1
i的值是: 2
continue后的输出语句
使用return结束方法
return用于从包围它的最直接方法、函数或匿名函数返回。当函数或方法执行执行到一条return语句时，这个函数或方法将被结束。
python程序中的大部分循环都被放在函数或方法中执行，一旦在循环体内执行到一条return语句时，return语句就会结束该函数或方法，循环自然也随之结束。
原文来源于我的语雀，我的微信公众号：细细研磨