第七章 python 循环设计

第七章 python 循环设计

7-1 基本 for 循环

• for 循环可以让程序将整个对象内的元素（也可以称迭代），在遍历期间，同时可以纪录或输出每次遍历的状态或轨迹。for 循环基本语法如下：
  • for var in 可迭代对象
• 可迭代对象可以是列表、元组、字典与集合，在信息科学中迭代可以解释为重复执行，上述语法可以解释为将可迭代对象的元素当作 var，重复执行，直到每个元素被执行一次，整个循环才会停止。设计上述程序代码时，必须要留竟意缩排问题，可以参考 if 叙述观念。由于这里笔者介绍列表，所以读者可以想象这个可迭代对象是列表，第 8 章笔者会讲解元组，第 9 章会讲解字典，第 10 章会讲解集合。另外，上述 for 循环的可迭代对象也常上 range() 函数产生的可迭代对象，将在 7-2 说明

7-1-1 for 循环基本运作

• 例如，一个 NBA 球队有 5 位球员，分别是 ‘Curry’,‘Jordan’,‘James’,‘Durant’,‘Obama’，现在想列出这 5 位球员，那么使用 for 循环执行这个工作就很适合
• 例：列出球员名称

players = ['Curry','Jordan','James','Durant','Obama']
for player in players:
    print(player)
   
#输出结果
Curry
Jordan
James
Durant
Obama

7-1-2 如果程序代码区块只有一行

• 使用 for 循环时，如果程序代码区块只有一行，它的语法可以用下列方式表达：

  • for var in 可迭代对象：程序代码区块

• 例：重新设计上面例子

  players = ['Curry','Jordan','James','Durant','Obama']
  for player in players:print(player)
  
  #输出结果
  Curry
  Jordan
  James
  Durant
  Obama
  

7-1-3 有多行的程序代码区块

• 如果 for 循环的程序代码区块有多行程序时，要留意这些语句同时需要做缩排处理。它的语法格式可以用下列方式表达：

  • for var in 可迭代对象：
  • 程序代码
  • 程序代码
  • …

• 例：这个程序在设计时，首先笔者将列表的元素英文名字全部改成小写，然后 for 循环的程序代码区块有 2 行，这 2 行（第 4 和 5 行）皆需内缩处理，player.title() 的 title() 方法可以处理第一个字母以大写显示。

  players = ['curry','jordan','james','durant','obama']
  for player in players:
      print(player.title() + "， it was a great game.")
      print("我迫不及待想看下一场比赛，"+ player.title())
      
  #输出结果
  Curry， it was a great game.
  我迫不及待想看下一场比赛，Curry
  Jordan， it was a great game.
  我迫不及待想看下一场比赛，Jordan
  James， it was a great game.
  我迫不及待想看下一场比赛，James
  Durant， it was a great game.
  我迫不及待想看下一场比赛，Durant
  Obama， it was a great game.
  我迫不及待想看下一场比赛，Obama
  

7-1-4 将 for 循环应用在列表区间元素

• 例：列出列表前 3 位和后 3 位

  players = ['Curry','Jordan','James','Durant','Obama']
  print("列出前 3 位")
  for player in players[:3]:
      print(player)
  print("列出r后 3 位")
  for player in players[-3:]:
      print(player)
      
  #输出结果
  列出前 3 位
  Curry
  Jordan
  James
  列出r后 3 位
  James
  Durant
  Obama
  

7-1-5 将 for 循环应用在数据类别的判断

• 例1：有一个 files 列表内含一系列文件名，请将 “.py” 的 python 程序另外建立到 py 列表，然后打印

  files = ['da1.c','da2.py','da3.py','da4','java']
  py = []
  for file in files:
      if file.endswith('.py'):  # endswith 从结尾查找内容
          py.append(file)
  print(py)
  
  #输出结果
  ['da2.py', 'da3.py']
  

• 例2：有一个列表 names，元素内容是姓名，请将姓洪的成员建立在 lastname 列表内，然后打印：

  names = ['洪锦魁','洪冰儒','东霞','大成']
  lastname = []
  for name in names:
      if name.startswith('洪'):  # startswith 从开头查找内容
          lastname.append(name)
  print(lastname)
  
  #输出结果
  ['洪锦魁', '洪冰儒']
  

删除列表内所有元素

• 例： python 没有提供删除整个列表元素的方法，不过我们可以使用 for 循环完成此工作

  fruits = ['苹果','香蕉','西瓜','水密桃','百香果']
  print('目前 files 列表：',fruits)
  i = 1
  for fruit in fruits[:]:
      fruits.remove(fruit)
      print("删除 %s" % fruit)
      print("目前 files 列表：",fruits)
      
  #输出结果：
  目前 files 列表： ['苹果', '香蕉', '西瓜', '水密桃', '百香果']
  删除 苹果
  目前 files 列表： ['香蕉', '西瓜', '水密桃', '百香果']
  删除 香蕉
  目前 files 列表： ['西瓜', '水密桃', '百香果']
  删除 西瓜
  目前 files 列表： ['水密桃', '百香果']
  删除 水密桃
  目前 files 列表： ['百香果']
  删除 百香果
  目前 files 列表： []
  

7-2 range() 函数

• python 可以使用 range() 函数产生一个等差序列，我们又称这等差序列为可迭代对象，也可以称是 range 对象，由于 range() 是产生等差序列，我们可以直接使用，将此等差序列当作循环的计数器。

• 在前一小节我们使用 “for var in 可迭代对象” 当作循环，这时会使用可迭代对象元素当作循环指针，如果是要迭代对象内的元素，这是好方法，但是如果只要执行普通的循环迭代，由于可迭代对象占用内存空间，所以这类循环需要占用较多系统资源，这时我们应该直接使用 range() 对象，这类迭代只有迭代时的计数指针需要内存，所以可以节省内存空间，range() 的用法与列表的切片类似。

• range( start , stop , step )

  • 上述 stop 是唯一必须的值，等差序列是产生 stop 的前一个值，例如：如果省略 start 所产生等差序列范围是从 0 至 stop - 1。step 的预设是 1，所以预设等差序列是递增 1。如果将 step设为 2，等差序列是递增 2.如果将 step 设为 -1，则是产生递减的等差序列。

• 由 range 产生的可迭代等差对象的数据类型是 range，可参考下列实例。

• 例：

  x = range(3)
  print(type(x))
  #下列代码用来打印 range() 对象内容
  for x in range(3):
      print(x)
  for x in range(0,3):
      print(x)
      
  #输出结果
  <class 'range'>
  0
  1
  2
  0
  1
  2
  

• 上述代在码执行循环迭代时，即使是执行 3 个循环，但是系统不用一次预留 3 个整数空间储存循环计数指针，而是每次循环用 1 个整数空间储存循环计数指针，所以可以节省系统资源。下列是 range() 含 step 参数的应用，第 1 个是建立 1 ~ 10 的奇数序列，第 2 个是建立每次递减 2 的序列

  #----------第一个----------
  for x in range(1,10,2):
      print(x)
      
  #输出结果
  1
  3
  5
  7
  9
  
  #----------第二个----------
  for x in range(3,-3,-2):
      print(x)
  
  #输出结果
  3
  1
  -1
  

7-2-1 只有一个参数的 range() 函数的应用

• 当 range(n) 函数搭配一个参数时：

  • range(n)：它将产生 0,1, … , n-1 的可迭代对象内容

• 例：输入数字，本程序会将此数字当作打印星号的数量。

  n = int(input("请输入星号数量："))
  for number in range(n):
      print("*",end="")
      
  #输出结果
  请输入星号数量：10
  **********
  

7-2-2 有 2 个参数的 range() 函数

• 当 range() 函数搭配 2 个参数时，它的语法格式如下：

  • range( start , end )：start 是起始值，end -1 是终止值

• 上述可以产生 start 起始值到 end -1 终止值之间每次递增 1 的序列，start 或 end 可以是负整数，如果终止值小于起始值则产生空序列或称空 range 对象，可参考下列程序实例。

  for x in range(10,2):
      print(x)
      
  #输出结果
  
  

• 下列代码是使用负值当作起始值。

  for x in range(-1,2):
      print(x)
      
  #输出结果
  -1
  0
  1
  

• 例：输入正整数值 n，这个程序会计算从 0 加到 n 之值：

  n = int(input("请输入 n 值："))
  sum = 0
  for num in range(1,n+1):
      sum += num
  print("总和：",sum)
  
  #输出结果
  请输入 n 值：100
  总和： 5050
  

• 例：此外，step 值也可以是负值，此时起始值必须大于终止值。

  for x in range(10,0,-2):
      print(x)
      
  #输出结果
  10
  8
  6
  4
  2
  

7-2-3 有 3 个参数的 range() 函数

• 当 range() 函数搭配 3 个参时，它的语法格式如下：

  • range( start , end , step )：start 是起始值，end 是终止值，step 是间隔值

• 然后会从起始值开始产生等差数列，每次间隔 step 时产生新数值元素，到 end - 1为止，下列是产生 2 ~ 11 间的偶数

  for x in range(2,11,2):
      print(x)
      
  #输出结果
  2
  4
  6
  8
  10
  

活用 range() 应用

• 程序设计时我们也可以直接应用 range()，可以产生程序精简的效果。

• 例：输入一个正整数 n，这个程序会输出从 1 加到 n 的总和

  n = int(input("请输入整数："))
  total = sum(range(n+1))
  print("从 1 到 %d 的总和是：" % n,total)
  
  #输出结果
  请输入整数：100
  从 1 到 100 的总和是： 5050
  

• 上述程序笔者使用了可迭代对象的内置函数 sum 执行总和的计算，它的工作原理并不是一次预留储存 1、2、… 10 的内存空间，然后执行运算，而是只有一个内存空间，每次将迭代的指针放在此空间，然后执行 sum() 运算，可以增加工作效率并节省内存空间。

• 例：建立一个整平方的列表，为了避免数值太大，若是输入值大于 10，此大于 10 的数值将被设为 10。

  squares = []
  n = int(input("请输入整数："))
  if n > 10:n = 10
  for num in range(1,n+1):
      value = num * num
      squares.append(value)
  print(squares)
  
  #输出结果
  请输入整数：10
  [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
  

7-2-5 列表生成（list generator）的应用

• 这个方式是将 for 循环与加入列表的代码浓缩为一行，对上述程序而言，可以将第 5 和 6 行浓缩为一行，在说明实例前先看基本语法。基本语法如下

  • 新列表 = [ 表达式 for 项目 in 可迭代对象 ]

• 上述语法观念是，将每个可迭代对象套入表达式，每次产生一个列表元素。如果将第 5 ~ 6 行转成上述语法，内容如下：

  • square = [ num ** 2 for num in range(1,n+1) ]

• 此外，用这种方式设计时，我们可以省略第 2 行（建立空列表）。

• 例：进阶列表生成的应用

  n = int(input("请输入整："))
  if n > 10 : n = 10
  squares = [num ** 2 for num in range(1,n+1)]
  print(squares)
  
  #输出结果
  请输入整：10
  [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
  

• 例：毕达可拉斯直角三角形定义，其实这是中学数学的勾股定理，基本观念是直角三角形两边长的平方和等于斜边的平方，如下：

  • a2 + b2 = c2 # C是斜边长

• 这个定理我们可以用（a , b , c ）方式表达，最著名的实例是（3 , 4 , 5），小括号是数组的表达方式，我们尚未介绍，所以本节使用 [ 3 , 4 , 5 ] 列表表示，这个程序会生成 0 ~ 19 间符合定义的 a、b、c 列表值。

  x = [[a,b,c] for a in range(1,20) for b in range(a,20) for c in range(b,20) if a ** 2 + b ** 2 == c **2]
  print(x)
  
  #输出结果
  [[3, 4, 5], [5, 12, 13], [6, 8, 10], [8, 15, 17], [9, 12, 15]]
  

• 例：在数学的使用中会碰上下列数学定义

  • A * B = { ( a , b ) }：a 属于 A 元素，b 属于 B 元素

• 例：我们可以用下列程序生成这类的表

  colors = ['A','B','C']
  shapes = ['1','2','3']
  result = [[color,shape] for color in colors for shape in shapes]
  print(result)
  
  #输出结果
  [['A', '1'], ['A', '2'], ['A', '3'], ['B', '1'], ['B', '2'], ['B', '3'], ['C', '1'], ['C', '2'], ['C', '3']]
  

7-2-6 打印含列表元素的列表

• 这个小节的观念称为 list unpacking，这个程序会从每个列表中拉出 color 和 shape 的列表元素值。

• 例：简化上一个程序，然后列出列表内每个元素列表值

  colors = ['A','B','C']
  shapes = ['1','2','3']
  result = [[color,shape] for color in colors for shape in shapes]
  for color,shape in result:
      print(color,shape)
      
  #输出结果
  A 1
  A 2
  A 3
  B 1
  B 2
  B 3
  C 1
  C 2
  C 3
  

7-2-7 生成含有条件的列表

• 这时语法如下：

  • 新列表 = [ 表达式 for 项目 in 可迭代对象 if 条件式 ]

• 例：下列是用传统方法生成 1，3，…，9 的列表：

  oddlist=[]
  for num in range(1,10):
      if num % 2 == 1:
          oddlist.append(num)
  print(oddlist)
  
  #输出结果
  [1, 3, 5, 7, 9]
  

• 下列是使用 python 精神，设计含有条件式的列表生成程序

  oddlist = []
  oddlist = [num for num in range(1,10) if num % 2 == 1]
  print(oddlist)
  
  #输出结果
  [1, 3, 5, 7, 9]
  

7-3 进阶的 for 循环应用

7-3-1 嵌套 for 循环

• 一个循环内有另一个循环，我们称这是嵌套循环，如果外循环要执行 n 次，内循环要执行 m 次，则整 个循环执行的次数是 n * m 次，设计这类循环时要特别注意下列事项：

  • 外层循环的索引值与内层循环的索引值必须不同。
  • 程序代码的内缩一定要小心。
  • 下列是周嵌套的基本语法。
    • for 变量 in 对象 : #外层 for 循环
    • ​ …
    • ​ for 变量 in 对象 : #内层 for 循环
    • ​ …

• 例：打印 9 * 9 的乘法表

  for i in range(1,10):
      for j in range(1,10):
          result = i * j
          print("%d*%d=%-3d" % (i,j ,result),end = "")
      print()
      
  #输出结果
  1*1=1  1*2=2  1*3=3  1*4=4  1*5=5  1*6=6  1*7=7  1*8=8  1*9=9  
  2*1=2  2*2=4  2*3=6  2*4=8  2*5=10 2*6=12 2*7=14 2*8=16 2*9=18 
  3*1=3  3*2=6  3*3=9  3*4=12 3*5=15 3*6=18 3*7=21 3*8=24 3*9=27 
  4*1=4  4*2=8  4*3=12 4*4=16 4*5=20 4*6=24 4*7=28 4*8=32 4*9=36 
  5*1=5  5*2=10 5*3=15 5*4=20 5*5=25 5*6=30 5*7=35 5*8=40 5*9=45 
  6*1=6  6*2=12 6*3=18 6*4=24 6*5=30 6*6=36 6*7=42 6*8=48 6*9=54 
  7*1=7  7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49 7*8=56 7*9=63 
  8*1=8  8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64 8*9=72 
  9*1=9  9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81 
  

  • 上述程序第 5 行，%-3d 主要是供 result 使用，表示每一个输出预留 3 格，同时靠左输出，同一行 end = " " 则是设定，输出完空一格，下次输出不换行输出，当内层循环执行完一次，则执行第 6 行，这是外层循环叙述，主要是设定下次执行输出，相当下次再执行内层循环时换行输出。

• 例：绘制直角三角形（乘法表格式）

  for i in range(1,10):
      for j in range(1,10):
          result = i * j
          if j <= i:
              print("%d*%d=%-3d" % (i,j ,result),end = " ")
      print()
      
  #输出结果
  1*1=1   
  2*1=2   2*2=4   
  3*1=3   3*2=6   3*3=9   
  4*1=4   4*2=8   4*3=12  4*4=16  
  5*1=5   5*2=10  5*3=15  5*4=20  5*5=25  
  6*1=6   6*2=12  6*3=18  6*4=24  6*5=30  6*6=36  
  7*1=7   7*2=14  7*3=21  7*4=28  7*5=35  7*6=42  7*7=49  
  8*1=8   8*2=16  8*3=24  8*4=32  8*5=40  8*6=48  8*7=56  8*8=64  
  9*1=9   9*2=18  9*3=27  9*4=36  9*5=45  9*6=54  9*7=63  9*8=72  9*9=81  
  

7-3-2 强制离开 for 循环 -break 指令

• 在设计 for 特环时，如果期待某些条件发生时可以离开循环，可以在循环内执行 break 指令，即可立即离开循环，这个指令通常是和 if 语句配合使用，下列是常用的语法格式：

  • for 变量 in 对象 :
  • ​ 程序代码区块 1
  • ​ if 条件表达式 : #判断条件表达式
  • ​ 程序代码区块 2
  • ​ break #如果条件表达式是 True 则离开 for 循环
  • 程序代码区块 3

• 例如，设计一个比赛，可以将参加比赛者的成绩列在列表内，如果想列出前 20 名参加决赛，可以设定 for 循环当选取 20 名后，即离开循环，此时可以使用 break 功能。

• 例：输出一系列数字元素，当数字为 5 时，循环将终止执行。

  print("测试1")
  for digit in range(1,11):
      if digit == 5:
          break
      print(digit,end =",")
  print()
  print("测试2")
  for digit in range(0,11,2):
      if digit == 5:
          break
      print(digit,end=",")
      
  #输出结果
  测试1
  1,2,3,4,
  测试2
  0,2,4,6,8,10,
  

  • 上述在第一个列表的测试中（第 3 ~ 6 行），当碰到列表元素是 5 时，循环将终止，所以只有列出 ” 1，2，3，4，“ 元素，在第二个列表的测试中（第 9~ 12 行），当碰到列表元素是5 时，循环将终止，可是这个列表元素中没有 5，所以整 个循环可以正常执行到结束。

• 例：列出球员名称，列出多少个球员则是由屏幕输入，这个程序同时设定，如果屏幕输入人数大于列表的球员数时，自动将所输入的人数降为列表的球员数。

  players = ["Curry","Jordan","James","Durant","Obama","Kevin","Lin"]
  n = int(input("请输入人数："))
  if n > len(players) :n = len(players)    #列出人数不大于列表元素数
  index = 0
  for player in players:
      if index == n:
          break
      print(player,end=" ")
      index += 1
      
  #输出结果1
  请输入人数：5
  Curry Jordan James Durant Obama 
  
  #输出结果2
  请输入人数：9
  Curry Jordan James Durant Obama Kevin Lin 
  

7-3-3 for 循环暂时停止不往下执下 - continue 指令

• 在设计 for 循环时，如果期待某些条件发生时可以不往下执行循环内容，此时可以用 continue 指令，这个指令通常是和 if 语句配合使用，下列是常用的语法格式

  • for 变量 in 对象 :
  • ​ 程序代码区块1
  • ​ if 条件表达式： 如果条件表达式是 True，则不执行程序代码区块3
  • ​ 程序代码区块2
  • ​ continue
  • 程序代码区块3

• 例：有一个列表 scores 纪录 James 的比赛得分，设计一个程序可以列出 James 有多少场次得分大于或等于 30 分

  scores = [33,22,41,25,39,43,38,40]
  games = 0
  for score in scores:
      if score < 30:
          continue
      games += 1
  print("有%d场得分超过30分" % games)
  
  #输出结果
  有6场得分超过30分
  

• 例：有一个列表 players，这个列表的元素也是列表，包含球员名字和身高数据，列出所有身高是 200（含）公分以上的球员数据

  players = [['James',202],
             ['Curry',193],
             ['Durant',205],
             ['Jordan',199],
             ['Davld',211]]
  for player in players:
      if player[1] < 200:
          continue
      print(player)
      
  #输出结果
  ['James', 202]
  ['Durant', 205]
  ['Davld', 211]
  

  • 对于上述 for 循环而言，每次执行第 7 行时，player 的内容是 players 的一个元素，而这个元素是一个列表，例如：第一次执行 player 内容是如下：
    • [‘James’,202]
  • 执行第 8 行时，player[1] 的值是 202，由于 if 判断的结果是 False，所以会执行第 10 行的 print(player) 指令，其他可依次类推。

7-3-4 for … else 循环

• 在设计 for 循环时，如果期待所有的 if 叙述条件是 False 时，在最后一次循环后，可以执行特定程序区块指令，可使用这个叙述，这个指令通常是和 if 和 break 语句配合使用，下列是常用的语法格式：

  • for 变量 in 对象 :
  • ​ 程序代码区块1
  • ​ if 条件表达式 : #如果条件表达式是 True，则离开 for 循环
  • ​ 程序代码区块2
  • ​ break
  • ​ 程序代码区块3
  • else :
  • ​ 程序代码区块4

• 其实这个语法很适合传统数学中测试一个数字 n 是否是质数，质数的条件是：

  • 2 是质数
  • n 不可被 2 至 n - 1 的数字整 除

• 例：质数测试的程序，如果所输入的数字是质数则列出是质数，否则列出不是质数。

  num = int(input("请输入大于1的整数做质数测试"))
  if num ==2:
      print("%d是质数" % num)
  else:
      for n in ramge(2,num):
          if num % n == 0:
              print("%d不是质数"%num)
              break
      else:
          print("%d是质数"%num)
          
  #输出结果1
  请输入大于1的整数做质数测试2
  2是质数
  
  #输出结果2
  请输入大于1的整数做质数测试7
  7是质数
  
  #输出结果3
  请输入大于1的整数做质数测试10
  10不是质数
  

7-4 while 循环

• 这也是一个循环，基本上循环会一直执行直到条件运算为 False 才会离开循环，所以充计 while 循环时一定要设计一个条件可以离开循环，相当于让循环结束，程序设计时，如果忘了设计条件可以离开循环，程序造成无限循环状态，此时可以同时按 Ctrl + C 键，中断程序的执行离开无限循环的陷阱。
• 一般 while 循环常应用在不知道循环何时可以结束的状况，for 循环在使用时是早已经知道循环即将执行的次数。不过我们也可以透过一些技巧，让 while 循环也可以应用在已经知道循环将执行的次数上。它的语法如下：
  • while 条件运算 :
  • ​ 程序区块

7-4-1 基本 while 循环

• 例：这个程序会输出你所输入的内容，当输入 q 时，程序才会执行结束

  msg1 = '人机对话专栏，告诉我心事吧，我会重复你告诉我的心事'
  msg2 = '输入 q 可以结束对话'
  msg = msg1 + msg2 + '\n' + '='
  input_msg = ''
  while input_msg != "q":
      input_msg = input(msg)
      print(input_msg)
      
  #输出结果
  人机对话专栏，告诉我心事吧，我会重复你告诉我的心事输入 q 可以结束对话
  =111
  111
  人机对话专栏，告诉我心事吧，我会重复你告诉我的心事输入 q 可以结束对话
  =你好
  你好
  人机对话专栏，告诉我心事吧，我会重复你告诉我的心事输入 q 可以结束对话
  =q
  q
  

  • 上述程序最大的缺点就是，当输入 q 时，程序也将输出 q，然后才结束 while 循环，我们可以使用下列第 8 行增加 if 条件判断方式改良。

• 例：当输入 q 时，不再输出 q。

  msg1 = '人机对话专栏，告诉我心事吧，我会重复你告诉我的心事'
  msg2 = '输入 q 可以结束对话'
  msg = msg1 + msg2 + '\n' + '='
  input_msg = ''
  while input_msg != "q":
      input_msg = input(msg)
      if input_msg != 'q':
          print(input_msg)
          
  #输出结果
  人机对话专栏，告诉我心事吧，我会重复你告诉我的心事输入 q 可以结束对话
  =111
  111
  人机对话专栏，告诉我心事吧，我会重复你告诉我的心事输入 q 可以结束对话
  =你好
  你好
  人机对话专栏，告诉我心事吧，我会重复你告诉我的心事输入 q 可以结束对话
  =q
  

  • 上述程序尽管可以完成工作，但是当我们在设计大型程序时，如果可以更明确的标记记录程序是否继续执行将更佳，下列笔者将用一个布尔量值 active 当作标记，如果 True 则 while 循环继续，否则 while 循环结束。

• 例：程序的可读性，使用标记 active 记录是否循环继续。

  msg1 = '人机对话专栏，告诉我心事吧，我会重复你告诉我的心事'
  msg2 = '输入 q 可以结束对话'
  msg = msg1 + msg2 + '\n' + '='
  active = True
  while active:
      input_msg = input(msg)
      if input_msg != 'q':
          print(input_msg)
      else:
          active = False
          
  #输出结果
  人机对话专栏，告诉我心事吧，我会重复你告诉我的心事输入 q 可以结束对话
  =111
  111
  人机对话专栏，告诉我心事吧，我会重复你告诉我的心事输入 q 可以结束对话
  =你好
  你好
  人机对话专栏，告诉我心事吧，我会重复你告诉我的心事输入 q 可以结束对话
  =q
  

• 例：猜数字游戏，程序第 2 行用变量 answer 存储欲猜的数字，程序执行时用变量 guess 存储所猜的数字。

  answer = 30
  guess = 0
  while guess != answer:
      guess = int(input("请猜1~100间的数字= "))
      if guess > answer:
          print("请猜小一点")
      elif guess < answer:
          print("请猜大一点")
      else:
          print("恭喜答对了")
          
  #输出结果
  请猜1~100间的数字= 20
  请猜大一点
  请猜1~100间的数字= 50
  请猜小一点
  请猜1~100间的数字= 30
  恭喜答对了
  

• 例：下列是使用 while 循环，已经知道要执行多少次循环了的实例

  index = 1
  while index <= 5:
      print("第 %d 次 while 循环" % index)
      index += 1
      
  #输出结果
  第 1 次 while 循环
  第 2 次 while 循环
  第 3 次 while 循环
  第 4 次 while 循环
  第 5 次 while 循环
  

7-4-2 嵌套 while 循环

• while 循环也允许嵌套循环，此时的语法格式如下：

  • while 条件运算 : #外层 while 循环
  • ​ …
  • ​ while 条件运算 : #内层 while 循环
  • ​ …

• 例：使用 while 循环重新设计，打印九九乘法表：

  i = 1
  while i <= 9:
      j = 0
      while j <= 9:
          j +=1
          result = i * j
          if i >= j:
              print("%d*%d=%-3d" % (i,j,result),end = "")
      print()
      i += 1
      
  #输出结果
  1*1=1  
  2*1=2  2*2=4  
  3*1=3  3*2=6  3*3=9  
  4*1=4  4*2=8  4*3=12 4*4=16 
  5*1=5  5*2=10 5*3=15 5*4=20 5*5=25 
  6*1=6  6*2=12 6*3=18 6*4=24 6*5=30 6*6=36 
  7*1=7  7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49 
  8*1=8  8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64 
  9*1=9  9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81 
  

7-4-3 强制离开 while 循环 - break 指令

• 在设计 while 循环时，如果期待某此条件发生时可以离开循环，可以在循环内执行 break 指令立即离开循环，这个指令通常是和 if 语句配合使用，下列是常用的语法格式

  • while 条件表达式A :
  • ​ 程序代码区块1
  • ​ if 条件表达式B :
  • ​ 程序代码区块2
  • ​ break
  • ​ 程序代码区块3

• 这个程序会建立 while 无限循环，如果输入 q，则可跳出这个 while 无限循环。

  msg1 = '人机对话专栏，告诉我心事吧，我会重复你告诉我的心事'
  msg2 = '输入 q 可以结束对话'
  msg = msg1 + msg2 + '\n' + '='
  input_msg = ''
  while input_msg != "q":
      input_msg = input(msg)
      if input_msg == 'q':
          break
      else:
          print('你输入的是：%s' % input_msg.title())
          
  #输出结果
  人机对话专栏，告诉我心事吧，我会重复你告诉我的心事输入 q 可以结束对话
  =111
  你输入的是：111
  人机对话专栏，告诉我心事吧，我会重复你告诉我的心事输入 q 可以结束对话
  =你好
  你输入的是：你好
  人机对话专栏，告诉我心事吧，我会重复你告诉我的心事输入 q 可以结束对话
  =q
  

• 例：使用 while 循环重新设计上面例子

  players = ["Curry","Jordan","James","Durant","Obama","Kevin","Lin"]
  n = int(input("请输入人数："))
  if n > len(players) : n = len(players)  #如果n大于列表个数就等于列表的个数
  index = 0
  while index < len(players):
      if index == n:
          break
      print(players[index],end=" ")
      index += 1
      
  #输出结果1
  请输入人数：2
  Curry Jordan 
  
  #输出结果2
  请输入人数：15
  Curry Jordan James Durant Obama Kevin Lin 
  

  • 上述程序第 6 行的 “ index < len(players) ” 相当于是语法格式的条件表达式A，控制循环是否终止。程序第 7 行的 " index == n " 相当于是语法格式的条件表达式B，可以控制是否中途离开 while 循环。

7-4-4 while 循环暂时停止不往下执行 - continue 指令

• 在设计 while 循环时，如果期待某些条件发生时可以不往下执行循环内容，此时可以用 continue 指令，这个指令通常是和 if 语句配合使用，下列是常用的语法格式：

  • while 条件运算A :
  • ​ 程序代码区块1
  • ​ if 条件表达式B : #如果条件表达式是 True，则不执行程序代码区块3
  • ​ 程序代码区块2
  • ​ continue
  • ​ 程序代码区块3

• 例：例出 1 至 10 之间偶数：

  index = 0
  while index <= 10:
      index += 1
      if (index % 2 != 0):
          continue
      print(index)
      
  #输出结果
  2
  4
  6
  8
  10
  

7-4-5 while 循环条件表达式与对象

• while 循环的条件表达式也可与对象（列表、元组或字典）配合使用，此时它的语法格式如下：

  • while 条件表达式 : #与有关的条件表达式
  • ​ 程序区块

• 例：删除列表内的 apple 字符串，程序第 5 行，只要在 fruits 列表内可以找到变量 apple，就会传回 True，循环将继续：

  fruits = ['apple','orange','apple','banana','apple']
  fruit = 'apple'
  print("删除前的 fruits ",fruits)
  while fruit in fruits:
      fruits.remove(fruit)
  print("删除后的 fruits ",fruits)
  
  #输出结果
  删除前的 fruits  ['apple', 'orange', 'apple', 'banana', 'apple']
  删除后的 fruits  ['orange', 'banana']
  

• 例：有一个列表 buyers，此列表内含购买者和消费金额，如果购买金额超过或达到 1000 元，则归类为 VIP 买家 vipbuyers 列表。否则是 Gold 买家 goldbuyers 列表。

  buyers = [['James',1030],
             ['Curry',893],
             ['Durant',2050],
             ['Jordan',990],
             ['Davld',2110]]
  goldbuyers = []
  vipbuyers = []
  while buyers:
      index_buyer = buyers.pop()
      if index_buyer[1] >= 1000:
          vipbuyers.append(index_buyer)
      else:
          goldbuyers.append(index_buyer)
  print("VIP 买家资料 ：",vipbuyers)
  print("Gold 买家资料：",goldbuyers)
  
  #输出结果
  VIP 买家资料 ： [['Davld', 2110], ['Durant', 2050], ['James', 1030]]
  Gold 买家资料： [['Jordan', 990], ['Curry', 893]]
  

  • 上述程序第 9 行只要列表不是空列表，while 循环就会一直执行。

7-4-6 pass

• pass 指令是什么事也不做，如果我们想要建立一个无限循环可以使用下列写法。

  • while True :
  • ​ pass

• 不过不建议这么做，这会让程序进入无限循环，这个指令有时候会用在设计一个循环或函数（将在第 11 - 8 节解说）尚未完成时，先放 pass，未来再用完整程序代码取代。

• 例：pass 应用在循环的实例，这个程序的循环尚未设计完成，所以笔者先用 pass 处理

  schools = ['明志科大','台湾科大','台北科大']
  for school in schools:
      pass
      
  #输出结果：没有任何数据输出
  

7-5 enumerate 对象使用 for 循环解析

• 延续 6 - 11 节的 enumerate 对象可知，这个对象是由计数值与元素值配对出现：

• 所以我们可以使用 for 循环将每一个计数值与元素值解析出来。

• 例：将 enumerate 对象的计数值与元素值解析出来。

  drinks = {'coffee',"tea","wine"}
  #解释 enumerate 对象
  for drink in enumerate(drinks):
      print(drink)
  for count,drink in enumerate(drinks):
      print(count,drink)
  print("*******************")
  #解释 enumerate 对象
  for drink in enumerate(drinks,10):
      print(drink)
  for count,drink in enumerate(drinks,10):
      print(count,drink)
      
  #输出结果
  (0, 'tea')
  (1, 'coffee')
  (2, 'wine')
  0 tea
  1 coffee
  2 wine
  *******************
  (10, 'tea')
  (11, 'coffee')
  (12, 'wine')
  10 tea
  11 coffee
  12 wine
  

• 由于 enumerate(drinks) 产生的 enumerate 对象是配对存在，可以用 2 个变量遍历这个对象，只要仍有元素尚未遍历循环就会继续。