Python多重循环实战：从鸡兔同笼到打印字母金字塔，新手必练的5个经典案例

当你第一次接触Python的多重循环时，可能会觉得这个概念既抽象又枯燥。但事实上，多重循环是解决许多实际问题的强大工具。本文将通过5个经典案例，带你从零开始掌握多重循环的应用技巧，让你在解决实际问题时游刃有余。

1. 鸡兔同笼问题：数学与编程的完美结合

鸡兔同笼是中国古代著名的数学问题，也是理解多重循环的绝佳起点。假设笼子里有鸡和兔子，我们知道头的总数和脚的总数，如何计算出鸡和兔子的数量？

这个问题看似简单，但如果没有编程思维，可能需要花费不少时间。使用Python的多重循环，我们可以轻松解决：

heads = int(input("请输入头的总数: "))
legs = int(input("请输入脚的总数: "))

solution_found = False

for chickens in range(heads + 1):
    rabbits = heads - chickens
    if 2 * chickens + 4 * rabbits == legs:
        print(f"鸡有{chickens}只，兔有{rabbits}只")
        solution_found = True
        break

if not solution_found:
    print("无解")

这段代码的工作原理：

1. 外层循环遍历所有可能的鸡的数量（从0到头的总数）
2. 内层计算对应的兔子数量（总头数减去鸡的数量）
3. 检查当前组合的脚数是否匹配输入值

提示：在真实项目中，可以添加输入验证，确保输入的头和脚数量合理（如脚数不能少于头数的2倍，不能多于头数的4倍）。

2. 完全数查找：探索数学的奥秘

完全数是指等于其所有真因子（不包括自身）之和的数。例如6=1+2+3，28=1+2+4+7+14。查找完全数是检验多重循环能力的经典案例。

def find_perfect_numbers(limit):
    perfect_numbers = []
    for num in range(1, limit + 1):
        sum_of_divisors = 0
        for divisor in range(1, num):
            if num % divisor == 0:
                sum_of_divisors += divisor
        if sum_of_divisors == num:
            perfect_numbers.append(num)
    return perfect_numbers

upper_limit = int(input("请输入查找上限: "))
print(f"{upper_limit}以内的完全数有: {find_perfect_numbers(upper_limit)}")

性能优化技巧：

• 内层循环只需遍历到num的平方根即可
• 可以预先排除奇数（已知的完全数都是偶数）

优化方法	原方法时间复杂度	优化后时间复杂度
遍历所有除数	O(n²)	O(n√n)
只检查偶数	减少一半检查量	进一步减少检查量

3. 字母金字塔：图形打印的艺术

打印图形是学习循环结构的必经之路。让我们尝试用多重循环打印字母金字塔，例如输入E时输出：

    A
   ABA
  ABCBA
 ABCDCBA
ABCDEDCBA

实现代码：

def print_letter_pyramid(letter):
    levels = ord(letter.upper()) - ord('A') + 1
    for i in range(levels):
        # 打印前导空格
        print(' ' * (levels - i - 1), end='')
        
        # 打印上升字母
        for j in range(i + 1):
            print(chr(ord('A') + j), end='')
            
        # 打印下降字母
        for k in range(i - 1, -1, -1):
            print(chr(ord('A') + k), end='')
            
        print()  # 换行

user_input = input("请输入一个大写字母: ")
print_letter_pyramid(user_input)

关键点解析：

1. ord() 函数获取字符的ASCII码
2. 外层循环控制金字塔的层数
3. 第一个内层循环打印上升的字母序列
4. 第二个内层循环打印下降的字母序列

4. 数字组合问题：排列组合实战

假设我们需要找出所有满足以下条件的三位数：

1. 每个数位上的数字不超过给定的最大值x
2. 各个数位的数字互不相同

def find_unique_digit_numbers(x):
    numbers = []
    for i in range(1, x + 1):        # 百位数
        for j in range(0, x + 1):    # 十位数
            if j == i: continue      # 确保十位不等于百位
            for k in range(0, x + 1):# 个位数
                if k == i or k == j: continue  # 确保个位不等于百位和十位
                numbers.append(i * 100 + j * 10 + k)
    return numbers

max_digit = int(input("输入数字x(1-9): "))
result = find_unique_digit_numbers(max_digit)
print(f"符合条件的数字共{len(result)}个:")
for i, num in enumerate(result):
    print(num, end=' ' if (i + 1) % 10 != 0 else '\n')

这段代码展示了三重循环的典型应用：

• 外层循环控制百位数
• 中间循环控制十位数
• 内层循环控制个位数
• 通过条件判断确保数字不重复

5. 阶乘等式生成：数学与格式化的结合

最后，我们来看一个生成阶乘等式的例子。输入一个数字n，输出从1!到n!的等式，例如输入5时输出：

1!=1=1
2!=2=2*1
3!=6=3*2*1
4!=24=4*3*2*1
5!=120=5*4*3*2*1

实现代码：

def generate_factorial_equations(n):
    for i in range(1, n + 1):
        # 计算阶乘值
        factorial = 1
        for j in range(1, i + 1):
            factorial *= j
        
        # 构建等式字符串
        equation = f"{i}!="
        equation += "*".join(str(k) for k in range(i, 0, -1))
        equation += f"={factorial}"
        
        print(equation)

number = int(input("请输入一个正整数: "))
generate_factorial_equations(number)

代码亮点：

1. 外层循环控制阶乘的基数
2. 内层循环计算阶乘值
3. 使用字符串拼接和 join() 方法构建等式
4. 展示了如何将数学计算与字符串格式化结合

在实际项目中，这类代码可以用于生成数学练习题或教学材料。