07.分支和循环结构实战

分支和循环结构实战

通过前面两节课的学习，大家对 Python 中的分支结构和循环结构已经有了初步的认知。分支结构和循环结构是构造程序逻辑的基础，它们的重要性不言而喻，但是对于初学者来说这也是比较困难的部分。很多人对分支结构和循环结构的语法是能够理解的，但是遇到实际问题的时候又无法下手；看懂别人的代码很容易，但是要自己写出类似的代码却又很难。如果你也有同样的问题和困惑，千万不要沮丧，这只是因为你的编程之旅才刚刚开始，你的练习量还没有达到让你可以随心所欲写出代码的程度，只要加强编程练习，通过量的积累来产生质的变化，这个问题迟早都会解决的。

例子1：100以内的素数

说明：素数指的是只能被 1 和自身整除的正整数（不包括 1），之前我们写过判断素数的代码，这里相当于是一个升级版本。

"""
输出100以内的素数

Version: 1.0

"""
for num in range(2, 100):
    is_prime = True
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            is_prime = False
            break
    if is_prime:
        print(num)

例子2：斐波那契数列

要求：输出斐波那契数列中的前 20 个数。

说明：斐波那契数列（Fibonacci sequence），通常也被称作黄金分割数列，是意大利数学家莱昂纳多·斐波那契（Leonardoda Fibonacci）在《计算之书》中研究理想假设条件下兔子成长率问题而引入的数列，因此这个数列也常被戏称为“兔子数列”。斐波那契数列的特点是数列的前两个数都是 1，从第三个数开始，每个数都是它前面两个数的和。按照这个规律，斐波那契数列的前 10 个数是：1, 1, 2, 3, 5, 8, 13, 21, 34, 55。斐波那契数列在现代物理、准晶体结构、化学等领域都有直接的应用。

"""
输出斐波那契数列中的前20个数

Version: 1.0

"""

a, b = 0, 1
for _ in range(20):
    a, b = b, a + b
    print(a)

说明：上面循环中的a, b = b, a + b表示将变量b的值赋给a，把a + b的值赋给b。通过这个递推公式，我们可以依次获得斐波那契数列中的数。

例子3：寻找水仙花数

要求：找出 100 到 999 范围内的所有水仙花数。

提示：在数论中，水仙花数（narcissistic number）也被称为超完全数字不变数、自恋数、自幂数、阿姆斯特朗数，它是一个 $\small{N}$ 位非负整数，其各位数字的 $\small{N}$ 次方和刚好等于该数本身，例如： $\small{153 = 1^{3} + 5^{3} + 3^{3}}$ ，所以 153 是一个水仙花数； $\small{1634 = 1^{4} + 6^{4} + 3^{4} + 4^{4}}$ ，所以 1634 也是一个水仙花数。对于三位数，解题的关键是将它拆分为个位、十位、百位，再判断是否满足水仙花数的要求，这一点利用 Python 中的//和%运算符其实很容易做到。

"""
找出100到999范围内的水仙花数

Version: 1.0

"""
for num in range(100, 1000):
    low = num % 10
    mid = num // 10 % 10
    high = num // 100
    if num == low ** 3 + mid ** 3 + high ** 3:
        print(num)

上面利用//和%拆分一个数的小技巧在写代码的时候还是很常用的。我们要将一个不知道有多少位的正整数进行反转，例如将 12389 变成 98321，也可以利用这两个运算来实现，代码如下所示。

"""
正整数的反转

Version: 1.0

"""
num = int(input('num = '))
reversed_num = 0
while num > 0:
    reversed_num = reversed_num * 10 + num % 10
    num //= 10
print(reversed_num)

例子4：百钱百鸡问题

说明：百钱百鸡是我国古代数学家张丘建在《算经》一书中提出的数学问题：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？翻译成现代文是：公鸡 5 元一只，母鸡 3 元一只，小鸡 1 元三只，用 100 块钱买一百只鸡，问公鸡、母鸡、小鸡各有多少只？

"""
百钱百鸡问题

Version: 1.0

"""
for x in range(0, 21):
    for y in range(0, 34):
        for z in range(0, 100, 3):
            if x + y + z == 100 and 5 * x + 3 * y + z // 3 == 100:
                print(f'公鸡: {x}只, 母鸡: {y}只, 小鸡: {z}只')

上面使用的方法叫做穷举法，也称为暴力搜索法，这种方法通过一项一项的列举备选解决方案中所有可能的候选项，并检查每个候选项是否符合问题的描述，最终得到问题的解。上面的代码中，我们使用了嵌套的循环结构，假设公鸡有x只，显然x的取值范围是 0 到 20，假设母鸡有y只，它的取值范围是 0 到 33，假设小鸡有z只，它的取值范围是 0 到 99 且取值是 3 的倍数。这样，我们设置好 100 只鸡的条件x + y + z == 100，设置好 100 块钱的条件5 x + 3 y + z // 3 == 100，当两个条件同时满足时，就是问题的正确答案，我们用print函数输出它。这种方法看起来比较笨拙，但对于运算能力非常强大的计算机来说，通常都是一个可行的甚至是不错的选择，只要问题的解存在就能够找到它。

事实上，上面的代码还有更好的写法，既然我们已经假设公鸡有x只，母鸡有y只，那么小鸡的数量就应该是100 - x - y，这样减少一个条件，我们就可以把上面三层嵌套的for-in循环改写为两层嵌套的for-in循环。循环次数减少了，代码的执行效率就有了显著的提升，如下所示。

"""
百钱百鸡问题

Version: 1.1

"""
for x in range(0, 21):
    for y in range(0, 34):
        z = 100 - x - y
        if z % 3 == 0 and 5 * x + 3 * y + z // 3 == 100:
            print(f'公鸡: {x}只, 母鸡: {y}只, 小鸡: {z}只')

说明：上面代码中的z % 3 == 0是为了确保小鸡的数量是 3 的倍数。

例子5：CRAPS赌博游戏

说明：CRAPS又称花旗骰，是美国拉斯维加斯非常受欢迎的一种的桌上赌博游戏。该游戏使用两粒骰子，玩家通过摇两粒骰子获得点数进行游戏。简化后的规则是：玩家第一次摇骰子如果摇出了 7 点或 11 点，玩家胜；玩家第一次如果摇出 2 点、3 点或 12 点，庄家胜；玩家如果摇出其他点数则游戏继续，玩家重新摇骰子，如果玩家摇出了 7 点，庄家胜；如果玩家摇出了第一次摇的点数，玩家胜；其他点数玩家继续摇骰子，直到分出胜负。为了增加代码的趣味性，我们设定游戏开始时玩家有 1000 元的赌注，每局游戏开始之前，玩家先下注，如果玩家获胜就可以获得对应下注金额的奖励，如果庄家获胜，玩家就会输掉自己下注的金额。游戏结束的条件是玩家破产（输光所有的赌注）。

"""
Craps赌博游戏

Version: 1.0

"""
import random

money = 1000
while money > 0:
    print(f'你的总资产为: {money}元')
    # 下注金额必须大于0且小于等于玩家的总资产
    while True:
        debt = int(input('请下注: '))
        if 0 < debt <= money:
            break
    # 用两个1到6均匀分布的随机数相加模拟摇两颗色子得到的点数
    first_point = random.randrange(1, 7) + random.randrange(1, 7)
    print(f'\n玩家摇出了{first_point}点')
    if first_point == 7 or first_point == 11:
        print('玩家胜!\n')
        money += debt
    elif first_point == 2 or first_point == 3 or first_point == 12:
        print('庄家胜!\n')
        money -= debt
    else:
        # 如果第一次摇色子没有分出胜负，玩家需要重新摇色子
        while True:
            current_point = random.randrange(1, 7) + random.randrange(1, 7)
            print(f'玩家摇出了{current_point}点')
            if current_point == 7:
                print('庄家胜!\n')
                money -= debt
                break
            elif current_point == first_point:
                print('玩家胜!\n')
                money += debt
                break
print('你破产了, 游戏结束!')

知识点总结

一、解决综合问题的基本思路

• 先读懂题目，明确输入、输出、限制条件和结束条件，再选择分支、循环和变量。
• 把大问题拆成若干小问题：确定遍历范围、计算当前值、判断条件、保存结果、输出结果。
• 循环负责重复处理，分支负责分类判断，变量负责保存中间状态；三者通常需要组合使用。
• 写完代码后要用边界值、特殊值和无解情况进行测试，不能只测试一个正常示例。

二、素数判断与嵌套循环

• 素数是大于1且只能被1和自身整除的正整数，1不是素数。
• 输出100以内素数时，外层循环逐个遍历候选数num，内层循环寻找它是否存在因子。
• 判断num是否为素数时，只需要检查2到int(num ** 0.5) + 1的范围；如果找到因子，就可以把is_prime设为False并使用break提前结束。
• 这是“外层枚举对象、内层验证条件”的典型嵌套循环结构。

三、斐波那契数列与同步赋值

• 本讲采用的斐波那契数列从1, 1开始，后一个数等于前两个数之和。
• a, b = b, a + b是 Python 的多变量同步赋值：先根据旧值计算右侧，再同时更新左侧变量。
• 使用同步赋值可以避免先修改a后导致a + b使用错误数据的问题。
• 输出固定个数的数列时，可以使用for _ in range(20)；循环次数明确时适合使用for-in。

四、数字拆分与水仙花数

• 对三位数num进行拆分：
• 个位：num % 10。
• 十位：num // 10 % 10。
• 百位：num // 100。
• 水仙花数要求各位数字的三次方之和等于原数，例如153 = 1 3 + 5 3 + 3 ** 3。
• 这类题目的通用方法是：遍历指定范围，拆分每个数字，计算特征值，再用if判断是否满足题意。
• 对任意位数的正整数进行反转时，可以反复取出个位：num % 10；取出后用num //= 10删除原来的个位；再用reversednum = reversednum * 10 + num % 10完成拼接。

五、穷举法和约束条件

• 穷举法也称暴力搜索法，思路是列举所有可能的候选解，再检查每个候选解是否满足全部条件。
• 百钱百鸡问题中，公鸡数量范围为0到20，母鸡数量范围为0到33，小鸡数量还必须是3的倍数。
• 编写穷举程序时，应将题目中的数量条件、金额条件和整除条件分别写成清晰的布尔表达式。
• 可以利用已知条件减少循环层数，例如已知总鸡数为100时，令z = 100 - x - y，不再单独枚举z。
• 优化穷举法的常见方法是缩小变量范围、利用已知关系直接计算变量、提前排除不可能的候选值。

六、CRAPS游戏中的状态控制

• 游戏开始时用money保存玩家资产，用外层while money > 0控制整个游戏是否继续。
• 下注金额必须满足0 < debt <= money，可以使用while True反复输入，验证通过后用break离开输入校验循环。
• 使用random.randrange(1, 7)模拟一次骰子的点数，两次相加得到两颗骰子的总点数。
• 第一次投骰子后分为三类：7或11点玩家胜；2、3或12点庄家胜；其他点数保存为目标点数并进入继续投骰子的阶段。
• 继续投骰子时，出现7点庄家胜，重新出现第一次点数玩家胜，其他情况继续循环。
• 一局结束后根据胜负更新money；资产降为0时，外层循环结束并输出游戏结束信息。
• 这个项目综合使用了随机数、输入校验、嵌套while、条件分支、break以及变量状态更新。

七、综合复习与易错点

• 遇到“输出一段范围内所有满足条件的数”，通常采用for遍历范围，再用if筛选。
• 遇到“重复执行直到某个结果出现”，通常采用while，并在成功或失败时用break结束。
• 使用%获取个位或判断整除关系，使用//进行整数除法和删除末位。
• 使用嵌套循环时，要明确每层循环的变量、范围和任务，避免重复计算无关候选项。
• 随机游戏必须考虑输入合法性、胜负状态更新和循环结束条件，否则可能出现非法下注、资产错误或死循环。
• 本讲的复习重点不是死记代码，而是掌握“枚举—判断—更新—结束”的通用编程模式，并能够根据新题目重新组织代码。