首页 > 脚本专栏 > python > Python缩进规则与代码块规范

Python缩进规则与代码块规范的实现

2026-06-22 09:55:38 作者：星河耀银海

本文介绍了Python中独特的缩进规则与代码块规范,Python通过缩进而非花括号划分代码块,强制代码风格统一,文章还列举了常见的缩进错误,感兴趣的可以了解一下

一、开篇：Python最独特的设计

如果你问我Python和其他编程语言最明显的区别是什么，我会毫不犹豫地说：缩进。

在C、Java、JavaScript等大多数语言中，缩进只是"看起来好看"的可选格式，实际的代码块靠花括号 {} 来划分。这些语言中，你把代码全写在一行也是合法的（只是没人这么写）。

但在Python中，缩进就是语法本身。代码块的划分、语句的归属关系，全靠缩进来决定。这个设计非常大胆，问世之初争议很大，但事实证明它是Python成功的关键原因之一。

💡 缩进强制代码看起来整洁。你在任何地方看到的Python代码，都有着高度一致的视觉风格。这是一种"代码可读性"的制度性保障。

二、缩进的基本规则

2.1 用空格还是Tab

这是Python社区最经典的"圣战"话题之一。答案是：

✅ PEP 8（Python官方代码风格指南）推荐使用4个空格

# 推荐：4个空格
if True:
    print('缩进了4个空格')

# 不推荐：Tab
if True:
	print('缩进了1个Tab')

⚠️ 关键规则：不要混用空格和Tab！ 在一个文件中，要么全用空格，要么全用Tab。混用会导致 TabError: inconsistent use of tabs and spaces in indentation。

所有现代Python IDE（PyCharm、VS Code）在你按Tab键时默认插入4个空格而不是Tab字符。这个设置一般在IDE的"缩进"选项中可以看到。

2.2 缩进层级

同一个代码块中的所有语句必须使用相同数量的缩进：

# ✅ 正确：同一代码块使用相同的缩进（4个空格）
if True:
    print('第一条语句')
    print('第二条语句')
    print('第三条语句')

# ❌ 错误：同一个代码块缩进不一致
if True:
    print('第一条语句')
      print('第二条语句')  # 缩进多了2个空格，报错！
    print('第三条语句')

2.3 什么情况下需要缩进

以下Python语句后面需要缩进，因为它们都会引入一个新的代码块：

关键字	场景	示例
if/elif/else	条件判断	if x > 0:
for/while	循环	for i in range(10):
def	函数定义	def my_function():
class	类定义	class MyClass:
try/except/finally	异常处理	try:
with	上下文管理器	with open('file'):
match/case	模式匹配	match value:

这些关键字后面都有一个冒号 :，冒号就是"接下来要缩进"的信号。

# 冒号后面必须缩进
if score >= 60:         # 冒号
    print('及格')       # 缩进4个空格，属于if代码块

print('判断结束')       # 没有缩进，不属于if代码块

三、缩进的嵌套

3.1 多层缩进

当代码逻辑嵌套时，每嵌套一层就增加一级缩进：

def analyze_score(name, score):
    """分析学生成绩"""
    if score >= 60:                          # 0级缩进（函数内第1层）
        print(f'{name} 及格了')               # 1级缩进（if内）
        if score >= 90:                      # 1级缩进（if内，另一个if）
            print('太棒了，成绩优秀！')        # 2级缩进（内层if内）
            if score == 100:                 # 2级缩进（内层if内）
                print('满分！你是传奇！')       # 3级缩进
        elif score >= 80:                    # 1级缩进
            print('成绩良好，继续加油！')       # 2级缩进
        else:                                # 1级缩进
            print('成绩及格，还有提升空间')     # 2级缩进
    else:                                    # 0级缩进
        print(f'{name} 不及格，需要努力！')    # 1级缩进
        if score < 30:                       # 1级缩进
            print('成绩太低，建议找老师辅导')   # 2级缩进

    # 0级缩进——回到函数体层级
    print(f'{name} 的成绩分析完毕')           # 1级缩进


# 调用函数
analyze_score('小明', 95)

💡 缩进就像俄罗斯套娃。外层套内层，内层再套内层。缩进级别告诉你"当前代码属于哪一层"。

3.2 缩进的可视化理解

把上面的代码用方括号标注一下代码块的边界：

def analyze_score(name, score):
│   如果 score >= 60:
│   │   print('及格')
│   │   如果 score >= 90:
│   │   │   print('优秀')
│   │   │   如果 score == 100:
│   │   │   │   print('满分')
│   │   否则如果 score >= 80:
│   │   │   print('良好')
│   │   否则:
│   │   │   print('及格')
│   否则:
│   │   print('不及格')
│   │   如果 score < 30:
│   │   │   print('太低')
│   print('分析完毕')

每个 │ 代表一级缩进。同一竖线上的代码属于同一代码块。

四、常见的缩进错误

4.1 IndentationError: expected an indented block

这个错误发生在：写了冒号，但下一行没有缩进。

>>> if True:
>>> print('hello')
# IndentationError: expected an indented block

✅ 解决方法：在冒号后面按回车，然后加上缩进：

if True:
    print('hello')

4.2 IndentationError: unexpected indent

这个错误发生在：不该缩进的地方缩进了。

>>> print('hello')
>>>     print('world')
# IndentationError: unexpected indent

通常出现在缩进层级搞混的时候：

# ❌ 错误：第二个print不应该缩进
def greet():
    print('hello')
        print('world')  # 这一行多缩进了！

# ✅ 正确：同级代码使用相同的缩进
def greet():
    print('hello')
    print('world')

4.3 TabError: inconsistent use of tabs and spaces

混用了Tab和空格：

# ❌ 第2行用了Tab，第3行用了空格——混用了！
if True:
	print('用Tab缩进')   # Tab
    print('用空格缩进')   # 4个空格

✅ 现代的IDE通常会自动统一缩进方式。如果你手动用文本编辑器写代码，建议设置编辑器"将Tab转换为空格"。

4.4 缩进导致的逻辑错误

这是最隐蔽的一类错误——代码能正常运行，但逻辑和你想的不一样：

# 你能看出这个程序的bug吗？
total = 0
for i in range(1, 11):
    total += i
    print(f'当前累加到{i}，总和为{total}')
    print('循环体内的最后一行')

print(f'最终结果：{total}')

上面这段是正确的。但看下面这个：

# 这个程序的输出和你想的一样吗？
total = 0
for i in range(1, 11):
    total += i
print(f'当前累加到{i}，总和为{total}')    # 注意：这行在循环外面！
print('循环结束')

第二个程序中，print 语句没有缩进在循环内部，所以它只会在循环完全结束之后执行一次，而不是每次循环都执行。但代码不会报错——这是个逻辑bug。

五、代码块：Python的组织单元

5.1 什么是一个代码块

代码块是一组逻辑相关的语句，它们有相同的缩进级别。每当Python遇到一个冒号，它就期待下面出现一个缩进的代码块。

# if语句引入的代码块
if condition:
    statement1     # 这两行有相同的缩进，
    statement2     # 它们属于同一个代码块

# for循环引入的代码块
for item in sequence:
    process(item)  # 循环体代码块
    log(item)

# 函数定义引入的代码块
def my_function():
    setup()        # 函数体代码块
    result = calculate()
    return result

5.2 代码块可以嵌套

def outer_function():
    """外层函数"""
    print('进入外层函数')

    def inner_function():
        """内层函数——嵌套在外层函数内部"""
        print('进入内层函数')
        for i in range(3):
            print(f'内层循环：{i}')
        print('离开内层函数')

    print('调用内层函数之前')
    inner_function()
    print('离开外层函数')

outer_function()

输出：

进入外层函数
调用内层函数之前
进入内层函数
内层循环：0
内层循环：1
内层循环：2
离开内层函数
离开外层函数

📝 这个例子展示了几层嵌套：外层函数体内有内层函数定义，内层函数体内有for循环，for循环体内有print语句。每一层都对应一级缩进。

5.3 空代码块：pass语句

有时你需要一个代码块占位（函数还没想好怎么写），但不能让它空着。这时用 pass：

# ❌ 错误：代码块为空
def function_not_ready_yet():
    # 这里什么也没有——报错！

# ✅ 正确：用pass占位
def function_not_ready_yet():
    pass    # 占位符，表示"这里以后会写代码"

# pass的其他使用场景
if condition_not_met_yet:
    pass    # 暂时不知道条件满足时该做什么

class FutureClass:
    pass    # 类的骨架，以后再填充

for item in large_list:
    if item is None:
        pass    # 跳过None值，不做任何处理
    else:
        process(item)

六、PEP 8缩进规范详解

PEP 8是Python的官方代码风格指南，它关于缩进有以下规定：

6.1 基本规则

每个缩进级别使用4个空格
不要使用Tab，或者在IDE中设置Tab自动转4个空格
同一文件中保持缩进方式一致

6.2 续行缩进

当一行代码太长需要换行时，续行有两种缩进方式：

方式一：与开括号对齐

# 续行与第一个括号后面的内容对齐
result = some_function(param_one, param_two,
                       param_three, param_four)

方式二：悬挂缩进

# 续行额外缩进一级（4个空格）
result = some_function(
    param_one, param_two,
    param_three, param_four
)

两者都可以，但在同一个项目中要保持一致。

6.3 长if语句的换行

# 当if条件太长时
if (student_score >= 60
        and student_attendance >= 0.8
        and not student_is_suspended
        and course_is_available):
    print('该学生可以参加期末考试')

用括号把条件包裹起来，然后在合适的位置换行。注意续行要额外缩进以示区分。

6.4 空行的使用

PEP 8不仅定义了缩进，还定义了空行的使用：

import os
import sys
                                # 两个空行
class MyClass:
    """类的文档字符串"""
                                # 一个空行
    def __init__(self):
        self.data = []
                                # 一个空行
    def add_data(self, item):
        """添加数据"""
        self.data.append(item)
                                # 一个空行
    def get_data(self):
        """获取数据"""
        return self.data
                                # 两个空行
def standalone_function():
    """独立的函数"""
    pass

规则总结：

顶层函数和类之间：两个空行
类中的方法之间：一个空行
函数/方法内部逻辑段落之间：一个空行

七、不同语言缩进对比

了解其他语言的做法，能帮助你更好地理解Python为什么选择缩进作为语法：

C语言——花括号，缩进可选：

if (x > 0) {
    printf("positive\n");
    printf("this is inside if\n");
}
printf("this is outside if\n");

Java语言——花括号，缩进可选：

if (x > 0) {
    System.out.println("positive");
}

Python——缩进就是语法：

if x > 0:
    print('positive')

在C/Java中，下面的两种写法都是合法的（虽然第二种很难看）：

// 写法一（正常）
if (x > 0) {
    printf("yes");
}

// 写法二（合法但不推荐）
if (x > 0) { printf("yes"); }

但在Python中，你不能省略缩进来压缩代码——缩进是语法的一部分，不是可选的格式。

⌨️ 这种设计带来的好处是：你看到的代码结构和代码的实际结构永远是一致的。不存在"缩进看起来在循环里，但代码实际在循环外"的情况。在C/Java中，这种缩进和实际结构不一致的问题是很多bug的来源。

八、IDE中的缩进助手

8.1 VS Code中的缩进设置

在VS Code中，打开 设置，搜索"缩进"：

{
    "[python]": {
        "editor.tabSize": 4,
        "editor.insertSpaces": true,
        "editor.detectIndentation": true
    },
    "editor.renderWhitespace": "boundary"
}

tabSize: 4：Tab键插入/删除4个空格
insertSpaces: true：按Tab键插入空格而非Tab字符
detectIndentation: true：自动检测文件的缩进风格

8.2 PyCharm中的缩进设置

文件 → 设置 → 编辑器 → 代码风格 → Python：

Tab大小：4
缩进：4
续行缩进：8
使用Tab字符：[取消勾选]

8.3 可视化空格

建议在编辑器中开启"显示空白字符"的功能，这样你就能看到每个空格和Tab：

VS Code：View → Render Whitespace
PyCharm：View → Active Editor → Show Whitespaces

开启后，空格显示为灰色小点（·），Tab显示为灰色箭头（→）。

九、实战：重构混乱缩进的代码

9.1 原始混乱代码

def process_students(students):
    passed = []
failed = []
for student in students:
        if student['score'] >= 60:
            passed.append(student)
    else:
        failed.append(student)
    return passed, failed

这段代码缩进混乱，运行会报 IndentationError。

9.2 修复后的代码

def process_students(students):
    """处理学生列表，分开及格和不及格的学生"""
    passed = []
    failed = []

    for student in students:
        if student['score'] >= 60:
            passed.append(student)
        else:
            failed.append(student)

    return passed, failed


# 测试
students = [
    {'name': '小明', 'score': 85},
    {'name': '小红', 'score': 42},
    {'name': '小刚', 'score': 96},
    {'name': '小丽', 'score': 58},
]

passed, failed = process_students(students)
print(f'及格的学生：{[s["name"] for s in passed]}')
print(f'不及格的学生：{[s["name"] for s in failed]}')

9.3 使用IDE自动格式化

选中所有代码，按 Ctrl + Alt + L（PyCharm）或 Shift + Alt + F（VS Code），IDE会自动修复缩进问题。

💡 养成一个好习惯：写完一段代码后，按快捷键格式化一下。这能自动修复缩进和其他格式问题。

十、本篇小结

✅ Python的缩进规则是它最独特的设计，也是初学者最容易踩坑的地方。核心要点：

4个空格 = 1级缩进（PEP 8标准）
冒号 : 后面必须缩进，开始一个新的代码块
同级代码块必须保持相同缩进
不要混用Tab和空格（IDE中设置Tab转4空格）
空代码块用 pass 占位
缩进决定逻辑归属——不恰当的缩进可能导致代码能运行但逻辑不对

📝 缩进规则是Python的"第一道门槛"，一旦掌握了，你就会发现它是一个非常有价值的设计——让你的代码天然整洁、统一、可读。

到此这篇关于Python缩进规则与代码块规范的实现的文章就介绍到这了,更多相关Python缩进规则与代码块规范内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！