第七章 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) 指令，其他可依次类推。
- 对于上述 for 循环而言，每次执行第 7 行时，player 的内容是 players 的一个元素，而这个元素是一个列表，例如：第一次执行 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 个变量遍历这个对象，只要仍有元素尚未遍历循环就会继续。
扫一扫
2136
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
