Python每日一学 11——流程跳转语句

Python每日一学 11——流程跳转语句

一、pass语句

pass相当于一个空语句，他不执行任何操作，可用在语法上需要语句，却不需要执行任何操作时，如：

while True:
    pass         # 忙-等待键盘中断

也常用作为类、函数或条件体的占位符，或者创建占位程序、保证格式完整、保证语义完整等。

def initlog():
    pass        # 占位，提醒这是一个待完成的函数定义

二、continue

continue语句应用于while或for…in循环语句中。

一般置于条件判定语句块中，当满足某条件时触发该语句的执行。

作用是跳过跳过本次循环中continue后面剩余语句的执行，提前进入下一次循环。

三、实例一：统计平均成绩

现有一个读文件切分得到的列表，其元素是表示一位同学各门课程成绩的字符串，空字符串表示该门课程因缓考原因导致成绩缺失，请计算并输出该同学的平均成绩。

我们知道，缓考导致的成绩缺失并不表示成绩为0，所以计算平均成绩时，应该略过缺失的成绩，只统计正常参加考试获得的成绩，这种情况下，就可以用continue跳过本次循环中剩余程序语句。

# 读成绩文件得到各门课程成绩，空字符串表示选课但无成绩
score = ['69', '85', '88', '', '100', '76', '', '95']
total = 0                   # 总分初值
amount = 0                  # 有成绩的课程数量初值
for x in score:             # 遍历列表，x每次取值为一个字符串
    if x == '':             # 若当前取值为空字符串
        continue            # 跳过当前循环剩余语句，开始下一循环
    total = total + int(x)  # 字符串转整数，并累加到总成绩上
    amount = amount + 1     # 有成绩课程数量增加1
avg_score = total / amount  # 计算平均成绩
print(avg_score)            # 忽略无成绩课程的平均分

运行的结果是：

85.5

可以改变判定条件为当前成绩是非空字符串时进行累加，避免使用continue。实际上，python中，大部分使用continue 的情况都可以通过改变条件回避其使用。

score = ['69', '85', '88', '', '100', '76', '', '95']
total = 0                       # 总分初值
amount = 0                      # 有成绩的课程数量初值
for x in score:                 # 遍历列表，x每次取值为一个字符串
    if x:                       # 若当前取值为非空字符串时值为True
        total = total + int(x)  # 字符串转整数，并累加到总成绩上
        amount = amount + 1     # 有成绩课程数量增加1
avg_score = total / amount      # 计算平均成绩
print(avg_score)                # 忽略无成绩课程的平均分

四、break语句

break语句应用于while或for循环语句中，一般置于条件判定语句块中，当满足某条件时触发该语句的执行。

其作用是在循环次数未达到设定次数或未达到循环终止条件时跳出循环，提前结束语句所在层次的循环。

例如枚举时，找到一个满足条件的结果就终止循环。如果一个 for…in 循环被 break 所终结，该循环的控制目标会保持其当前值。

五、实例二：加法训练机

random模块random.randint(m, n)可以随机产生一个n, m之间的整数，利用这个函数产生两个20以内的正整数a和b，屏幕上输出“a + b = ”，用户计算并输入计算结果，计算机评测计算是否正确。

结果正确时输出“恭喜你，回答正确”，回答错误时输出“回答错误，你要加油哦！”。

编写一个程序，重复产生两个整数做计算练习，直到用户不再计算，直接输入回车时，输出“练习结束”并结束程序。

import random                       # 导入随机数模块

while True:                         # 无限循环，每次产生一个新问题
    a = random.randint(1, 20)       # 随机产生一个20以内的整数
    b = random.randint(1, 20)       # 随机产生一个20以内的整数
    print(f'{a} + {b} = ', end='')  # 格式化输出
    result = input()                # 用户输入计算结果字符串
    if result == '':                # 如果直接输入回车(接收到空字符串)
        print('练习结束')
        break                       # 结束循环
    elif int(result) == a + b:      # 若输入数字等于a+b的值
        print('恭喜你，回答正确')      
    else:
        print('回答错误，你要加油哦！')

运行的结果是：

10 + 15 = 25
恭喜你，回答正确
11 + 16 = 27
恭喜你，回答正确
4 + 6 = 10
恭喜你，回答正确
15 + 6 = 
练习结束

我们修改上面的程序使之能够随机产生正整数四则运算的题目进行训练,用户输入计算结果，判断输入正确与否,并统计正确率（只输出算式，未计算的题目不统计在内）。

import random

all_count, right_count = 0, 0       # 统计答题总数和答题正确数
while True:                         # 无限循环，每次产生一个新问题
    a = random.randint(1, 20)       # 随机产生一个20以内的整数
    b = random.randint(1, 20)       # 随机产生一个20以内的整数
    sign = random.choice('+-*/')	# 随机获取一个运算符号
    print(f'{a} {sign} {b} = ', end='')  # 格式化输出
    result = input()                # 用户输入计算结果字符串
    answer = eval(f'{a}{sign}{b}')  # 计算出正确答案,可将a、运算符和b组成的字符串转为可运算的表达式求值
    if result == '':                # 如果直接输入回车(接收到空字符串)
        print('练习结束')
        break                       # 结束循环
    elif int(result) == answer:      # 若输入数字等于answer的值
        right_count += 1            # 正确数+1
        all_count += 1              # 答题总数+1
        print('恭喜你，回答正确') 
    else:
        all_count += 1
        print('回答错误，你要加油哦！')
correct_rate = (right_count / all_count) * 100      # 计算答题的正确率
print(f"答对{right_count}题,正确率为{correct_rate}%")

运行的结果是：

13 + 20 = 33
恭喜你，回答正确
11 * 2 = 22
恭喜你，回答正确
3 + 7 = 10
恭喜你，回答正确
12 / 7 = 1
回答错误，你要加油哦！
6 + 16 = 22
恭喜你，回答正确
3 * 19 = 57
恭喜你，回答正确
12 / 13 =
练习结束
答对5题,正确率为83.33333333333334%

六、实例三：自身以外的最大因数

输入一个大于1的整数，编程输出其自身以外的最大因数。

若一个数对i取模的结果为0，则i 是这个数的因数。一个整数的因数可能有很多个，可以用遍历的方法逐一判定。本题要求找最大因数，为提高效率，可以从大到小进行判定，找到的第一个因数时便为最大因数。输出该数后，用break结束循环，不再进行判定。

num = int(input())               # 输入一个整数，例如：100
for i in range(num - 1, 0, -1):  # 遍历小于num且大于1的整数
    if num % i == 0:             # 如num可被i整除，则i为num的因数
        print(i)                 # 输入100时，输出50
        break                    # 中止循环，退出循环

运行的结果是：

100
50

break只能提前结束当前循环。当循环层数多于一层时，不能直接用break跳出多重循环。

一般的方法可以用一个标记变量，用break退出一重循环后，根据标记变量的值决定是否继续退出外层循环。

七、实例四：百钱买百鸡进阶

公鸡五元一只，母鸡三元一只，小鸡三只一元。

用户输入想买的鸡的数量和付出的钱数，计算公鸡、母鸡和小鸡的数量。

如果有解，输出公鸡最少，小鸡最多的一组；

如果无解则输出“无解”。

题目要求如果有解，输出公鸡最少，小鸡最多的一组，可以按公鸡数量由少到多遍历，找到一组解后就结束程序。

题目需要两层循环，一个break只能结束一层循环，所以可以在找到解后设定一个标记，根据标记的值决定是否结束外层循环。也可以根据标记的值是否发生改变判定是否找到了解。

num, money = map(int, (input().split()))  # 切分空格分隔的输入转整型
flag = False                              # 设定标记，False为无解，或solution = '无解'
for cock in range(1, num):                # 从小到大遍历公鸡数量
    for hen in range(1, num):             # 从小到大遍历母鸡数量
        chicken = num - cock - hen        # 小鸡数量计算得到
        if chicken % 3 == 0 and chicken > 0 and 5 * cock + 3 * hen + chicken // 3 == money:
            flag = True                   # 找到解后改变标记，或solution = '有解' 
            print(cock, hen, chicken)     # 输出找到的第一组解
            break                         # 结束内层循环
    if flag:       # 根据flag值是否为True判断是否找到解，或if solution == '有解' 
        break      # 找到解时结束外层循环，否则继续执行外层循环
if not flag:       # 两层循环都结束时，如not flag值为True，表明未找到解，或if solution == '无解'
    print("无解")

运行的结果是：

20 50
3 11 6

程序中有两重循环，在内层循环中找到一个满足条件的解并输出后，按题目要求应该终止程序的执行。

提前终止循环可以用break关键字，但该关键字只能终止当前层次的循环，无法终止外层循环的执行。

外层循环不能无条件终止，需要先判断是否已经在内层中找到了满足条件的解。
所以可以在内层找到解时设定一个标记，上述程序中设置变量flag作为标记，一旦找到了满足条件的解，就改变flag变量的值。

在外层循环中根据flag的值是否发生了变化判定是否找到了解，一旦找到了一个满足条件的解，就用break提前终止外层循环。

八、else子句

Python中的 for…in 和 while 循环都有一个可选的else子句，在循环迭代正常完成之后执行（包括执行0次）。

else 子句可以省略，这个子句只有当循环以正常方式结束时，else子句中的语句才能被执行。

如果在循环语句块中遇到break语句跳出循环或遇到return语句结束程序，则不会执行else 部分。

九、实例五：输出小于n的素数

用户输入一个大于 1 的正整数n，计算并输出小于 n 的素数。素数也称为质数，是指在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数。

判定一个整数 n 是否是素数有两个条件：

一是这个数 n 是大于1的；

二是这个数 n 不能被从2到n-1中的任意一个数整除，只要存在2到n-1之间的因子，那么n就不是素数。
算法描述：

1. 从n到1逆序遍历：
   a. 判定从 2 到 i-1 之中是否还存在能整除的数：
   ⅰ. 如果存在一个能整除的数字：
   1. 则数字 i 必然不是素数，不需要继续判断，用break跳出循环
      ⅱ. 如果顺利完成从 2 到 i-1 的遍历，未发现能整除的数，说明该数是素数
   2. 输出这个数

n = int(input())           # 输入一个正整数，例如输入50
for i in range(2, n):      # 0,1不是素数，产生从2 到 n 的整数序列
    for j in range(2, i):  # 产生从2到i-1序列，j逐个取值为2到i-1
        if i % j == 0:     # 若2到i-1中存在能被i整除的数，i不是素数
            break          # 存在整数因子时执行break语句并跳过else语句的执行
    else:                  # 与for对齐，循环中未执行到break时执行此语句
        print(i, end=' ')  # 输出

运行的结果是：

50
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 

用else语句改写实例 4.12 百钱买百鸡进阶，了解break和continue的使用：

num, money = map(int, (input().split()))  # 切分空格分隔的输入转整型
flag = False                              # 设定标记，False为无解，或solution = '无解'
for cock in range(1, num):                # 从小到大遍历公鸡数量
    for hen in range(1, num):             # 从小到大遍历母鸡数量
        chicken = num - cock - hen        # 小鸡数量计算得到
        if chicken % 3 == 0 and chicken > 0 and 5 * cock + 3 * hen + chicken // 3 == money:
            flag = True                   # 找到解后改变标记，或solution = '有解'
            print(cock, hen, chicken)     # 输出找到的第一组解
            break                         # 结束内层循环
    else:         # 内层未遇到break时执行continue
        continue  # 跳过后面的break语句，开始下次循环
    break
else:       # 外层循环未遇到break时执行缩进语句块
    print("无解")

while…else用法类似于for…else，仅当while因条件为假而退出（即没有被break中断）时运行else分支下的语句块。

十、实例六：自除数

一个不含0的多位数，如果它能被它的每一位除尽，则它是一个自除数。
例如128是一个自除数，因为128能被1、2、8整除。编写函数selfDivisor(num)判断num是否为自除数，使用该函数输出不大于N的所有自除数。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬（注意，含有数字0的数不是自除数）‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬

需要注意的是，每次都要从最小的质数开始尝试除，例如360可以除2、除2、除2，被2整除3次才得到一个不能被2整除的45，然后再除3，除3，最后得到质数5。

num = int(input())         # 输入一个多位正整数
for c in str(num):         # 对数字num中的每位数字进行遍历
    if num % int(c) != 0:  # 测试num的每一位是否是num的因子
        print('不是自除数')  # 如果存在不能整除的数，则不是自除数
        break              # 提前结束循环
else:  # 如果for遍历顺利结束，未遇到break，则执行else子句
    print('是自除数')

运行的结果是：

128
是自除数