值得收藏！16段代码入门Python循环语句

循环语句又称为重复结构，用于反复执行某一操作。面对大数量级的重复运算，即使借助计算机，重复编写代码也是费时的，这时就需要借助循环语句。使用循环语句一般要用到条件判断，根据判断式的返回值决定是否执行循环体。

循环分为两种模式，一种是条件满足时执行循环体;另一种则相反，在条件不满足时执行循环体。前者称为当型循环，后者称为直到型循环。

在图1中，虚线框内是一个当型循环结构，此结构包含判断条件和循环体，以及连接各部分的流向线。程序执行时，先判断条件的真假。判断为真时，则执行循环体;判断为假时，不再执行循环体，循环结束。当型循环先进行条件判断，如果满足循环条件，再执行循环体，因此又被称为前测试型循环。

▲图1 当型循环结构

在图2中，虚线框内是一个直到型循环结构，此结构包括判断条件和循环体，以及连接各部分的流向线。程序执行时，先执行一次循环体，再判断执行循环的结果是否满足判断条件。满足条件时，再次执行循环体;不满足条件时，不再执行循环体。直到型循环在执行判断前先进入循环体运行，因此又被称为后测试型循环。

▲图2 直到型循环结构

Python中主要有两种循环语句，即for语句和while语句。前者采用遍历的形式指定循环范围，后者视判断式返回值的情况而决定是否执行。要更灵活地操纵循环的流向，就要用到break、continue和pass等语句。

01 for

for循环是迭代循环，在Python中相当于一个通用的序列迭代器，可以遍历任何有序序列，如str、list、tuple等，也可以遍历任何可迭代对象，如dict。不同于C语言，Python中的for语句将遍历系列中的所有成员，遍历顺序为成员在系列中的顺序。需要注意，在for循环中改变任何序列的内容都是危险的!

for语句不属于当型循环或直到型循环，它遍历序列对象内的元素，对每个元素运行一次循环体，循环的步数在程序开始执行时已经指定，不属于条件判断。

在for语句中，for和in搭配组成for-in循环结构，for-in循环依次把list或tuple中的每个元素迭代出来。for语句的基本语法格式如下。

1. for 变量 in 序列: 
2.  操作语句 

for语句常用的语法格式及其参数说明如下所示：

• 序列：接收序列，表示遍历范围。无默认值
• 操作语句：接收操作语句，表示执行一段代码。无默认值

程序的执行从“for变量in序列”开始，该语句把序列中的每个元素代入变量，执行一遍操作语句1，重复的次数就是序列中元素的个数。

为了展示for循环的遍历功能，依次打印list中的姓名，如代码清单1所示。

代码清单1：for语句遍历提取str

1. # 单纯遍历的for语句 
2. names = ['Michael', 'Bob', 'Tracy'] 
3. # 遍历输出names中的元素 
4. for name in names: 
5.  print(name)  

输出结果：

1. Michael 
2. Bob 
3. Tracy  

for语句同样可以实现dict的遍历方法，如代码清单2所示。

• 代码清单2：for语句遍历查询dict

1. dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4} 
2. # 遍历键值对 
3. print('key_value：', end = '') 
4. for key, value in dic.items(): 
5.  print(key, value, sep = ':', end = ' ') 
6. # 遍历键 
7. print('keys：', end = '') 
8. for key in dic.keys(): 
9.  print(key, end = ' ') 
10. # 遍历值 
11. print('values：', end = '') 
12. for value in dic.values(): 
13.  print(value, end = ' ')  

输出结果：

1. key_value：a:1 b:2 c:3 d:4 
2. keys：a b c d 
3. values：1 2 3 4 

从代码清单2可以看到，for语句中用于遍历的“变量”不仅可以是Python默认的指代词，也可以是常规的变量。

和条件语句一样，循环语句也可以使用嵌套，作用同样是丰富程序的功能性。设计一个成绩录入系统，就必然要录入姓名和课程这两类信息，仅靠一层循环是无法实现的，可使用两层循环结构，如代码清单3所示。

• 代码清单3：嵌套for语句

1. students = ['小明', '小红'] 
2. subjects = ['语文', '数学']  
3. sum1 = [] 
4. avg = [] 
5. for i in students:  
6.  print ('开始录入%s的考试成绩!'%i)  
7.  sum = 0 
8.  for j in subjects:  
9.  print('请输入%s成绩:'%j)  
10.  score = int(input()) 
11.  sum += score 
12.  average = sum / 2 
13.  avg.append(average) 
14.  sum1.append(sum) 
15. print(students, '的总分依次是', sum1, ',', '平均分依次是', avg) 
16. print('完成成绩录入！')  

输出结果：

1. 开始录入小明的考试成绩! 
2. 请输入语文成绩: 
3. 97 
4. 请输入数学成绩: 
5. 90 
6. 开始录入小红的考试成绩! 
7. 请输入语文成绩: 
8. 89 
9. 请输入数学成绩: 
10. 100 
11. ['小明', '小红'] 的总分依次是 [187, 189] , 平均分依次是 [93.5, 94.5] 
12. 完成成绩录入！ 

理论上，for循环也可以无限嵌套，但并不推荐。

02 while

while语句是Python中最常用的递归结构。区别于for循环，while循环结构包含条件判断式，是一种条件循环，属于当型循环。

while语句最基本的形式包括一个位于顶部的布尔表达式，一个或多个属于while代码块的缩进语句。也可以在结尾处包含一个else代码块，它与while代码块是同级的，组成while-else的形式。while语句的基本语法格式如下。

1. while 条件表达式: 
2.  操作语句 1 
3.  操作语句 2  

while语句常用的参数及其说明如下所示：

• 条件表达式：接收布尔表达式，表示判断条件是否成立。无默认值
• 操作语句：接收操作语句，表示执行一段代码。无默认值

执行while语句时，只要顶部的条件表达式返回真值，就一直执行while部分嵌套的递归代码，当条件表达式返回假值时，不再执行操作语句，程序跳出while结构。

while语句的基础使用方法如代码清单4所示。

• 代码清单4：while语句

1. sum = 0 
2. n = 99 
3. while n > 0: 
4.  sum += n 
5.  n -= 2 
6. print(sum) 

输出结果：2500

如果布尔表达式不带有<、>、==、!=、in、not in等运算符，仅仅给出数值之类的条件，也是可以的。当while后写入一个非零整数时，视为真值，执行循环体;写入0时，视为假值，不执行循环体。也可以写入str、list或任何序列，长度非零则视为真值，执行循环体;否则视为假值，不执行循环体。

如果布尔表达式始终返回1，while语句就变成无限循环，如代码清单5所示。

• 代码清单5：while语句无限循环

1. # 布尔表达式为常数1，始终为真值 
2. while 1: 
3.  print('循环') 

输出结果：

1. 循环 
2. 循环 
3. …  

1. # 布尔表达式每次递归运算都为2，始终为真值 
2. x, y = 2, 1 
3. while x / y: 
4.  print('循环') 
5.  x = x * 2 
6.  y = y * 2  

输出结果：

1. 循环 
2. 循环 
3. …  

运行代码清单5，将会不断打印出“循环”。代码清单5展示了制造无限循环的两种方式，既可以在while后写入一个固定的真值，也可以写入一个一直生成真值的表达式。要终止无限循环，可以使用快捷键Ctrl+C中断循环的执行，也可以用循环终止语句，这将在下文中介绍。

灵活地利用while语句中的布尔表达式及代入表达式的递归值，可以实现特别的功能，如代码清单6所示。

• 代码清单6：while语句实现str截取

1. string = 'abcd' 
2. while string: 
3.  print(string) 
4. # 该语句的递归计算是，每次从str的第2个字符开始截取 
5.  string = string[1:]  

输出结果：

1. abcd 
2. bcd 
3. cd 
4. d  

代码清单6包含一个自减迭代值，它并不通过明显的运算符实现自减，而是利用索引法则，x变量一直从str中第2个值截取至结尾，每次都将位于str最前面的字符截取掉，最终只剩下一个字符时，再次截取就只有空的结果，布尔表达式返回0，循环终止。

通过代码清单5和代码清单6可以看到，灵活地利用递归式，可以实现程序流向的控制。

while循环同样可以使用嵌套，嵌套的while循环实现成绩录入系统如代码清单7所示。

• 代码清单7：嵌套while语句

1. j = 1 
2. while j <= 2: 
3.  sum = 0 
4.  i = 1 
5.  name = input('请输入学生姓名:') 
6.  while i <= 2: 
7.  print ('请输入第%d门的考试成绩: '%i) 
8.  sum += int(input()) 
9.  i += 1 
10.  avg = sum / (i-1) 
11.  print(name, '的平均成绩是%d'%avg) 
12.  j += 1 
13. print('学生成绩输入完成！')  

输出结果：

1. 请输入学生姓名:小明 
2. 请输入第1门的考试成绩:  
3. 98 
4. 请输入第2门的考试成绩:  
5. 88 
6. 小明 的平均成绩是93 
7. 请输入学生姓名:小红 
8. 请输入第1门的考试成绩:  
9. 65 
10. 请输入第2门的考试成绩:  
11. 100 
12. 小红 的平均成绩是82 
13. 学生成绩输入完成！ 

代码清单7的第1层while语句用于录入人名，第2层则在各人名下录入多门成绩，布尔表达式决定录入的人数和课程数。

03 break、continue与pass

在前两节中，已经介绍了Python中的两种循环语句。循环语句中还可以嵌入break、continue和pass语句，以灵活地改变流向，实现更多功能。

1. break

在Python中，break语句用于终止循环语句的执行。使用该语句时，即使循环条件判断为真，或序列未被完全递归，循环语句也会被立刻停止。

break语句一般配合条件判断使用，因为程序的终止必须是在某一条件被满足时执行。break语句在for循环和while循环中的使用如代码清单8所示。

• 代码清单8：break语句的使用

1. # break语句用于for循环 
2. string = "Python" 
3. for i in string: 
4. # 遍历至string中的字符n时，不再执行else代码块 
5.  if i == 'n': 
6.  break 
7.  else: 
8.  print("letter：{}". format(i))  

输出结果：

1. letter：P 
2. letter：y 
3. letter：t 
4. letter：h 
5. letter：o  

1. # break语句用于while循环 
2. counts = 0 
3. while True: 
4.  print(counts) 
5.  counts += 1 
6. # 满足counts等于3时跳出循环，不再进入循环体 
7.  if counts == 3:  
8.  break 

输出结果：

1. 0 
2. 1 
3. 2 

从代码清单8可以看到，break语句用于for循环和while循环是有区别的。用于for循环时，只终止遍历中某一次的循环体执行;用于while循环时，整个循环被终止。

break只终止本层循环，如有多层嵌套的循环，在其中一层循环中写入break，只在这层循环中生效，程序将跳到上一层循环中继续运行，如代码清单9所示。

• 代码清单9：break语句用于嵌套循环结构

1. # 第1层循环，遍历次数为2 
2. for i in range(2): 
3.  print("-----%d-----" %i) 
4. # 第2层循环，遍历次数为10 
5.  for j in range(10): 
6. # 使用break语句，j>1时不执行循环体 
7.  if j > 1: 
8.  break 
9.  print(j) 

输出结果：

1. -----0----- 
2. 0 
3. 1 
4. -----1----- 
5. 0 
6. 1 

在代码清单9中，break语句在条件判断式“if j>1:”后被使用，因此尽管j的指定遍历次数为10，实际上遍历只运行两次。由于break语句只终止本层循环的运行，i依旧遍历执行了两次，而不是在第1次遍历过程末尾终止。

2. continue

Python中的continue语句用于跳出当前循环，并执行下一次循环，而break跳出整层循环，两者的功能具有明显区别。

如果一段代码中包含continue语句，循环执行至continue处时，先忽略本次循环，在本层仍满足条件的剩余循环次数中继续执行，不会终止这一层循环。实际上，如果在某一层的每次循环中都使用continue语句，就相当于使用break语句。

打印一个数表，要不打印某些指定的数字，或只打印某类数，就可以使用continue语句跳过一些循环次数，该语句在for循环和while循环中都可以自由地使用，如代码清单10所示。

• 代码清单10：continue语句用于循环结构

1. # 当i等于1或3时，跳过continue后的print语句 
2. for i in range(0,5): 
3.  if i == 1 or i == 3: 
4.  continue 
5.  print(i)  

输出结果：

1. 0 
2. 2 
3. 4  

1. # 如果遇到偶数，跳过continue后的print语句 
2. counts = 0 
3. while counts < 10: 
4.  counts += 1 
5.  if counts % 2 == 0: 
6.  continue  
7.  print(counts) 

输出结果：

1. 1 
2. 3 
3. 5 
4. 7 
5. 9  

break语句一旦用于嵌套循环中的第n层，该层循环会被终止，但在执行第n-1层循环时，仍会创造一个第n层循环并执行。continue语句同样如此，只是仍会执行某一层的剩余部分。因此，无论使用哪种循环终止语句，都只会影响使用终止语句的那一层循环，而不会干扰到其他层。continue语句用于循环的例子如代码清单11所示。

• 代码清单11：continue语句用于嵌套循环结构

1. # 第1层循环，遍历次数为2 
2. for i in range(2): 
3.  print("-----%d-----" %i) 
4. # 第2层循环，遍历次数为5 
5.  for j in range(5): 
6. # 当j等于2或4时，不执行循环体 
7.  if j == 2 or j == 4: 
8.  continue 
9.  print(j)  

输出结果：

1. -----0----- 
2. 0 
3. 1 
4. 3 
5. -----1----- 
6. 0 
7. 1 
8. 3 

3. pass

pass是空语句，不做任何操作，只起到占位的作用，其作用是为了保持程序结构的完整性。尽管pass语句不做任何操作，但如果暂时不确定要在一个位置放上什么样的代码，可以先放置一个pass语句，让代码可以正常运行。pass语句并非循环或者条件语句的一部分，但与break、continue在代码形式上有些类似。

使用pass语句遍历输出str及数值计算，如代码清单12所示。

• 代码清单12：pass语句

1. for element in "Python": 
2. # element为y时，不做任何操作，不会被输出 
3.  if element == "y": 
4.  pass 
5.  else: 
6.  print(element)  

输出结果：

1. P 
2. t 
3. h 
4. o 
5. n  

1. counts = 0 
2. while counts < 5: 
3.  counts += 1 
4. # i=3时，不执行循环体 
5.  if counts == 3: 
6.  pass 
7.  else: 
8.  print(counts ** 2)  

输出结果：

1. 1 
2. 4 
3. 16 
4. 25  

从代码清单12可以看到，Python在“P”和“t”之间占位，当循环遍历到“y”时不做任何操作;当i等于3时，幂运算不执行，但不影响其他数值。上述两个代码如果在pass的位置缺失，程序将无法执行，因为判断条件没有给出相应的执行语句，会导致逻辑出错。使用pass语句占位，一方面为了让程序正常执行，另一方面也是为了方便以后补充操作语句。

04 列表推导式

推导式是可以从一个数据序列构建另一个新的数据序列的结构体，能够非常简洁地构造新的变量。列表推导式是其中最常用的类型。

列表推导式又称为列表解析式，是Python迭代机制的一种应用，也是一种高效创建列list的方式，可以动态地创建list。由于列表推导式必须用到遍历循环，因此属于一种特殊的循环。

使用列表推导式时，需要将推导式写在[]中。list中的元素可以来源于其他类型序列、可迭代对象或自建的满足一定条件的序列。使用列表推导式的好处是代码更加简洁，实现效率更高。

列表推导式的基本语法格式如下：

1. [操作语句 for变量 in 序列 if 条件表达式]  

列表推导式常用的参数及其说明如下所示：

• 操作语句：接收操作语句，表示执行一段代码。无默认值
• 序列：接收序列，表示遍历范围。无默认值
• 条件表达式：接收布尔表达式，表示判断条件是否成立。无默认值

列表推导式可以不包含条件表达式，只做遍历，生成list，如代码清单13所示。

• 代码清单13：使用列表推导式生成list

1. vec = [-4, -2, 0, 2, 4] 
2. # 用vec中元素的倍数，创建一个数组 
3. print([x * 2 for x in vec]) 

输出结果：

1. [-8, -4, 0, 4, 8] 

1. # 创建一个包含2元tuple的list 
2. print([(x, x ** 2) for x in range(6)])  

输出结果：

1. [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]  

在代码清单13中，除了列表推导式的简单形式，还说明了列表推导式中可以使用多样的函数和变量类型。另外，列表推导式中也可以包含条件语句，如代码清单14所示。

• 代码清单14：包含条件语句的列表推导式

1. # 过滤list，删除list中的负数 
2. print([x for x in vec if x >= 0]) 

输出结果：

1. [0, 2, 4] 

列表推导式最大的优点还是简洁，这需要与常规的编程方式进行对比。如代码清单15所示，要创建一个平方数组成的list，这里的两种方式是等价的，但列表推导式的方式显然代码更加简洁。

• 代码清单15：常规方式与列表推导式对比

1. # 创建一个平方数list：常规方式 
2. squares = []  
3. for x in range(10):  
4.  squares.append(x ** 2)  
5. print(squares) 

输出结果：

1. [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 

1. # 创建一个平方数list列表推导式 
2. squares = [x ** 2 for x in range(10)]  
3. print(squares)  

输出结果：

1. [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 

列表推导式中同样可以实现嵌套循环，如代码清单16所示。

• 代码清单16：包含嵌套循环的列表推导式

1. # 打印由tuple组成的list，tuple中i由0至2，j由0至2 
2. [(i, j) for i in range(0, 3) for j in range(0, 3)] 

输出结果：

1. [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)] 

1. # 打印由tuple组成的list，i在0至2之间且小于1，j在0至2之间且大于1 
2. [(i, j) for i in range(0, 3) if i < 1 for j in range(0, 3) if j > 1] 

输出结果：