Python实战：用for循环打印不同风格的金字塔（附完整代码）

最近在辅导几位刚入门Python的朋友时，我发现一个有趣的现象：很多初学者在掌握了print和for循环的基本语法后，面对稍微复杂一点的图形输出问题，比如打印一个金字塔，还是会感到无从下手。这其实是一个绝佳的练习机会，它能把看似枯燥的循环、字符串操作和逻辑判断，变成一个看得见、摸得着的“作品”。今天，我们就来深入聊聊如何用Python的for循环，玩转几种不同风格的金字塔打印。这不仅仅是完成一个练习，更是理解程序如何将抽象逻辑转化为具体形态的思维训练。

无论你是想巩固基础的编程新手，还是希望寻找一个清晰案例来教学的朋友，这篇文章都会从最朴素的思路出发，一步步推导出代码，并探讨不同实现背后的设计考量。我们会涵盖经典的实心金字塔、优雅的空心金字塔，以及节省空间的紧凑型金字塔。更重要的是，我会分享一些在调试这类图形程序时非常实用的小技巧，帮你避开常见的“坑”。

1. 理解核心：空格与星号的舞蹈

在命令行里用字符画出一个金字塔，本质上是在精确控制每一行输出中空格和星号（或其他字符）的数量和位置。for循环负责按行推进，而我们需要在每一轮循环中，计算出当前行所需的空格数和星号数。这是所有图形打印问题的通用解题框架。

1.1 建立坐标系与观察规律

我们先以最常见的实心金字塔为例，假设用户输入层数 n = 5。我们期望的输出是：

    *
   * *
  * * *
 * * * *
* * * * *

注意，这里为了美观，我让每个星号后面跟了一个空格，形成“* ”单元。这样金字塔的轮廓会更清晰。

观察这个目标图形，我们可以发现两个关键规律：

1. 空格数量：每行开头的空格数在递减。具体来说，第 i 行（i从0开始计数）前面的空格数等于 n - i - 1。比如第0行（顶层），5-0-1=4个空格；第4行（底层），5-4-1=0个空格。
2. 星号单元数量：每行的“* ”单元数在递增，恰好等于 i + 1。顶层1个，底层5个。

提示：在编程中，从0开始计数通常更自然，因为它与列表索引、range函数的行为直接对应。将行号i设定为从0到n-1，会让后续的公式更简洁。

基于这个观察，代码的逻辑就呼之欲出了。我们用一个for循环遍历每一行，在每一行中，先打印计算出的空格，再打印计算出的星号单元。

def print_classic_solid_pyramid(n):
    """打印经典实心金字塔（星号带空格）"""
    for i in range(n):  # i 从 0 到 n-1
        spaces = " " * (n - i - 1)
        stars = "* " * (i + 1)  # 注意星号后有一个空格
        print(spaces + stars)

# 测试
print_classic_solid_pyramid(5)

运行这段代码，你就能得到上面展示的5层金字塔。这里的" " * (n - i - 1)和"* " * (i + 1)利用了Python字符串的乘法操作，可以快速生成重复的字符序列，这是实现图形打印的关键技巧之一。

1.2 从规律到公式的推导

为什么空格公式是 n - i - 1？我们可以这样理解：金字塔最底层（第n-1行）应该顶格打印，不需要前导空格，所以空格数为0。那么对于第i行，它距离底层还有 (n-1) - i 行。因为每向上一层，前面就会多一个空格，所以第i行的空格数就是 (n-1) - i，化简后就是 n - i - 1。

为了更直观地对比不同层数的变化，我们可以看看下面这个表格：

行号 (i)	前导空格数 (n-i-1)	星号单元数 (i+1)	本行总字符宽度
0 (顶层)	4	1	空格4 + “* “*1 = 5字符
1	3	2	空格3 + “* “*2 = 7字符
2	2	3	空格2 + “* “*3 = 9字符
3	1	4	空格1 + “* “*4 = 11字符
4 (底层)	0	5	空格0 + “* “*5 = 13字符

从这个表格可以清晰地看出，每一行的总宽度（字符数）是 2*i + 5（对于n=5的情况），它构成了一个等差数列。这种分析有助于我们理解图形在控制台中的对齐方式。

2. 实现多种金字塔变体

掌握了基础模型后，我们就可以像玩积木一样，通过修改内部逻辑来创造不同的金字塔变体。这不仅能巩固循环和条件判断，还能极大地提升解决复杂问题的能力。

2.1 空心金字塔：勾勒轮廓的艺术

空心金字塔只保留金字塔的外轮廓，内部是空的。它的打印逻辑比实心金字塔稍复杂一些，因为我们需要区分三种情况：

• 第一行（顶层）：只有一个星号单元。
• 最后一行（底层）：需要打印完整的星号单元，和实心金字塔一样。
• 中间行：只在行首和行尾有星号单元，中间用空格填充。

关键点在于计算中间部分的空格数量。如果我们的星号单元是“* ”（一个星号加一个空格，占2个字符位置），那么中间的空格数应该是 2 * (i - 1) 个普通空格。因为第i行（i>0）有i+1个星号单元的位置，首尾被占用，中间就有 (i+1)-2 = i-1个“空位”，每个空位原本是一个“* ”单元（2字符），现在要用2个空格代替。

def print_hollow_pyramid(n):
    """打印空心金字塔"""
    for i in range(n):
        leading_spaces = " " * (n - i - 1)
        if i == 0:  # 第一行
            print(leading_spaces + "* ")
        elif i == n - 1:  # 最后一行
            print(leading_spaces + "* " * (i + 1))
        else:  # 中间行
            middle_spaces = "  " * (i - 1)  # 两个空格为一组
            print(leading_spaces + "* " + middle_spaces + "* ")

# 测试
print_hollow_pyramid(5)

输出结果：

    *
   * *
  *   *
 *     *
* * * * *

你会发现，中间行的轮廓被清晰地勾勒出来了。这种“分情况讨论”的思维在编程中非常普遍，比如处理边界条件、异常输入等。

2.2 紧凑型金字塔：另一种美学

前面我们打印的金字塔，星号之间有空隙，看起来比较“松散”。有时我们可能需要一种更“紧凑”的金字塔，星号紧密排列在一起，尤其是当层数很多时，这种样式更节省横向空间，视觉上也更敦实。

对于紧凑型实心金字塔，规律发生了变化：

1. 每行的星号数量是奇数序列：1, 3, 5, 7, ...
2. 空格用于居中显示这些星号串。

因此，对于第i行（i从0开始），星号数量是 2*i + 1。为了让这一串星号在视觉上居中，左边的空格数应该是 (n - i - 1)。注意，这里的n仍然是总层数，但因为我们只打印奇数行（如果总层数n是奇数），或者我们需要调整逻辑来适应这种紧凑模型。一个更通用的方法是，我们直接决定要打印多少层“奇数行”的金字塔。

def print_compact_solid_pyramid(levels):
    """打印紧凑型实心金字塔
    levels: 你希望金字塔有多少层（每层星号数为奇数递增）
    """
    for i in range(levels):
        stars_count = 2 * i + 1
        leading_spaces = " " * (levels - i - 1)
        print(leading_spaces + "*" * stars_count)

# 测试：打印5层紧凑金字塔
print_compact_solid_pyramid(5)

输出：

    *
   ***
  *****
 *******
*********

这个金字塔看起来更加扎实。代码中的 2*i+1 确保了星号数构成奇数序列，levels - i - 1 确保了每一层都能在上一层的正下方居中。

基于这个紧凑模型，我们同样可以实现它的空心版本。逻辑和之前的空心金字塔类似，但空格计算方式不同：

• 第一行：一个星号，居中。
• 最后一行：满星号。
• 中间行：首尾各一个星号，中间用 stars_count - 2 个空格填充。

def print_compact_hollow_pyramid(levels):
    """打印紧凑型空心金字塔"""
    for i in range(levels):
        stars_count = 2 * i + 1
        leading_spaces = " " * (levels - i - 1)
        if i == 0:  # 第一行
            print(leading_spaces + "*")
        elif i == levels - 1:  # 最后一行
            print(leading_spaces + "*" * stars_count)
        else:  # 中间行
            middle_spaces = " " * (stars_count - 2)
            print(leading_spaces + "*" + middle_spaces + "*")

# 测试
print_compact_hollow_pyramid(5)

输出：

    *
   * *
  *   *
 *     *
*********

3. 代码优化与功能增强

写出能运行的代码只是第一步，写出清晰、健壮、易扩展的代码才是我们追求的目标。下面我们来对上面的基础版本进行一些优化和功能增强。

3.1 输入验证与错误处理

最初的代码直接使用 int(input(...))，如果用户输入的不是数字，或者输入了负数、零，程序就会崩溃或产生无意义的输出。一个健壮的程序应该能优雅地处理这些情况。

def get_positive_integer(prompt):
    """获取用户输入的正整数，提供重试机制"""
    while True:
        try:
            value = int(input(prompt))
            if value > 0:
                return value
            else:
                print("请输入一个正整数！")
        except ValueError:
            print("输入无效，请输入一个整数！")

def print_pyramid_robust():
    """带输入验证的完整金字塔打印示例"""
    print("请选择金字塔类型：")
    print("  1. 经典实心金字塔")
    print("  2. 经典空心金字塔")
    print("  3. 紧凑实心金字塔")
    print("  4. 紧凑空心金字塔")

    choice = input("请输入选项 (1-4): ").strip()
    n = get_positive_integer("请输入金字塔的层数: ")

    if choice == '1':
        print_classic_solid_pyramid(n)
    elif choice == '2':
        print_hollow_pyramid(n)
    elif choice == '3':
        print_compact_solid_pyramid(n)
    elif choice == '4':
        print_compact_hollow_pyramid(n)
    else:
        print("无效的选择！")

# 可以运行 print_pyramid_robust() 来体验

这个增强版本使用了 try...except 来捕获输入非整数时的错误，并用 while 循环确保用户必须输入一个有效的正整数。同时，它提供了一个简单的菜单让用户选择金字塔类型，使程序更加友好和实用。

3.2 使用函数提升代码复用性

我们已经将每种金字塔的打印逻辑封装成了独立的函数，这是一个好习惯。但我们还可以更进一步，通过参数化来让函数更加灵活。例如，我们可以让函数接受一个可选的“填充字符”参数，这样就能轻松打印出由不同字符（如#, @, $）构成的金字塔。

def print_classic_pyramid(n, hollow=False, char='*'):
    """打印经典风格金字塔（可定制字符和空心/实心）
    Args:
        n: 层数
        hollow: 是否为空心
        char: 用于构建金字塔的字符
    """
    unit = char + " "  # 基础单元，字符加一个空格
    for i in range(n):
        line = " " * (n - i - 1)
        if hollow:
            if i == 0 or i == n - 1:
                line += unit * (i + 1)
            else:
                line += unit + "  " * (i - 1) + unit
        else:
            line += unit * (i + 1)
        print(line)

# 测试：用‘#’打印一个5层空心的经典金字塔
print_classic_pyramid(5, hollow=True, char='#')

输出：

    #
   # #
  #   #
 #     #
# # # # #

通过引入 hollow 和 char 参数，我们将两个相似函数合并为一个，代码更简洁，功能却更强大了。这种“参数化”思维是编写通用、可复用代码的核心。

4. 思维拓展：从金字塔到更多图案

掌握了金字塔的打印，你就掌握了用循环控制台输出图形的核心心法。这套方法可以轻松迁移到其他经典图案上，让你的编程练习之旅充满乐趣和成就感。

4.1 打印菱形

菱形可以看作是一个正金字塔和一个倒金字塔的组合。我们可以先打印上半部分（递增），再打印下半部分（递减）。关键在于下半部分的行号和空格、星号的计算要反过来。

def print_diamond(levels):
    """打印指定层数（上半部分）的菱形"""
    # 上半部分（正金字塔）
    for i in range(levels):
        spaces = " " * (levels - i - 1)
        stars = "* " * (i + 1)
        print(spaces + stars)
    # 下半部分（倒金字塔，少一行避免重复中间行）
    for i in range(levels - 2, -1, -1):  # 从 levels-2 递减到 0
        spaces = " " * (levels - i - 1)
        stars = "* " * (i + 1)
        print(spaces + stars)

print_diamond(5)

这段代码中，range(levels - 2, -1, -1) 是关键，它生成了一个从 levels-2 到 0 的递减序列，完美地构建了菱形的下半部分。

4.2 打印沙漏和箭头

基于同样的组合思想，我们可以创造更多图案。比如沙漏，就是先打印一个倒金字塔，再打印一个正金字塔（注意连接处的行不要重复）。箭头则可能是在一行特定位置打印星号。这些练习能极大地锻炼你的空间想象力和逻辑分解能力。

我建议你不妨尝试自己推导一下下面这个数字金字塔的代码：

    1
   2 2
  3 3 3
 4 4 4 4
5 5 5 5 5

提示：每行打印的数字等于行号（从1开始），数字之间用空格隔开。这需要你将之前处理星号单元的逻辑，灵活地应用到数字和字符串的拼接上。

4.3 调试技巧：可视化中间过程

在编写和调试图形打印程序时，如果结果不对，一个非常有效的方法是可视化中间变量。你可以在循环内打印出关键变量的值，而不是直接打印最终图形。

例如，在打印空心金字塔时，如果不确定中间的空格数对不对，可以临时修改代码：

for i in range(n):
    leading_spaces_count = n - i - 1
    middle_spaces_count = 2 * (i - 1) if i not in [0, n-1] else 0
    print(f"第{i}行: 前导空格={leading_spaces_count}, 中间空格={middle_spaces_count}")
    # ... 原有的打印逻辑

通过观察这些计算出的数值是否符合你的预期，可以快速定位是公式错误还是边界条件处理不当。

纸上得来终觉浅，绝知此事要躬行。图形打印是一个“所见即所得”的练习，非常适合用来建立编程的直觉和信心。当你看到自己写的几行代码在屏幕上构建出整齐的图案时，那种成就感是无可替代的。不妨打开你的代码编辑器，从修改层数、替换字符开始，然后尝试挑战菱形、沙漏，甚至更复杂的图案。编程的乐趣，就在这一次次将想法变为现实的过程中。