去年一位朋友从前端转向后端开发，开始学习Python。他写了一小段极简的代码：

for i in range(5):
    message = f"当前数字是{i}"
    
print(message)  # 最后一行，想打印最后一次的message

在JavaScript中，这段代码会抛出错误——因为message定义在for循环的块内部，外部无法访问。

然而Python却正常输出了：当前数字是4

他愣住了：“等一下，message不就是在循环内部定义的吗？为什么外部仍然能访问到？”

答案其实很简单：Python语言中没有块级作用域。for、if、while等代码块并不会创建新的作用域。

他更加困惑了：“为什么？其他语言都有块级作用域啊？这样做不会导致混乱吗？”

这个问题问得非常到位。今天我们就来深入探讨：Python为什么没有采用块级作用域？

首先理解：什么是块级作用域？

“块”（block）通常指由一对花括号{}括起来的代码区域。

在C、Java、JavaScript（ES6之后用let）这些语言中，你在一个块内部定义的变量，仅在该块内有效。

看一个JavaScript的例子：

if (true) {
    let x = 10;  // 用let声明，块级作用域
    console.log(x);  // 10
}
console.log(x);  // 报错！x is not defined

x只在if的那个花括号内存在，跳出后即消失。

同样，for循环也是如此：

for (let i = 0; i < 3; i++) {
    let temp = i * 2;
}
console.log(temp);  // 报错！temp is not defined

这就是块级作用域：每个{}都是一个独立的小房间，房间里的变量无法逃逸。

许多程序员习惯了这种规则，转到Python时就会踩坑。

Python的实际情况：只有函数能创造新作用域

在Python里，能够创造新作用域的只有一种结构：函数。

def定义的函数、lambda表达式，都会创建一个新的局部作用域。

但if、for、while、with、try/except这些，都不会。

验证一下：

# if块
if True:
    a = 100
print(a)  # 100，a还在

# for循环
for i in range(3):
    b = i * 2
print(b)  # 4，b还在（最后一次循环的值）

# while循环
count = 0
while count < 3:
    c = count * 10
    count += 1
print(c)  # 20，c还在

# with块
with open('test.txt', 'w') as f:
    d = "写入的内容"
print(d)  # "写入的内容"，d还在

# try/except块
try:
    e = 1 / 1
except:
    e = 0
print(e)  # 1.0，e还在

所有在代码块里创建的变量，都会“泄漏”到外层。

唯一能让变量“消失”的是函数：

def test():
    f = 500

test()
print(f)  # 报错！NameError: name 'f' is not defined

这就是Python与那些具备块级作用域的语言之间最显著的区别。

为什么Python要这样设计？

这个问题没有官方文档直接回答过，但我们可以从Python的设计哲学和历史中找到答案。

理由一：简单

Python的作者Guido van Rossum在设计这门语言时，有一个核心原则：简单明了，减少规则。

块级作用域意味着要引入一套新规则：哪些代码块创造作用域？哪些不创造？如果块嵌套了怎么办？

而且，如果Python支持块级作用域，那就需要区分变量的关键字——就像JavaScript的var和let。Python的设计哲学是“一种事情最好只有一种做法”，不希望引入过多关键字。

Guido本人的一句话很有说服力：

"A block is a piece of Python program text that is executed as a unit. The following are blocks: a module, a function body, and a class definition. ... Not blocks: a conditional block, a loop block."

翻译一下即：只有模块、函数体、类定义是块。条件语句块、循环块则不是。

这个选择让Python的规则变得简洁：只需记住一条——只有函数创造作用域。

理由二：Python是动态的

Python是动态语言，变量无需事先声明。你在任何地方写x = 10，Python就在当前作用域中创建变量x。

如果引入块级作用域，这个简单规则就会复杂化：在一个块里写x = 10，是创建块级变量？还是往外层查找？

JavaScript的var就因为这个问题搞得一团糟，直到ES6引入let和const才解决。Python不愿重蹈覆辙。

理由三：实际影响不大

Guido可能认为，缺少块级作用域在实际编程中并不会造成大问题。

大多数情况下，你希望在循环中使用的临时变量，循环结束后本就不需要了。Python的做法只是让它们多存活了一会儿，并不会导致程序错误——只要你注意不重用变量名就行。

而且，Python通过函数提供了足够的作用域隔离手段。如果一个循环过于复杂，应当抽离成函数。这是一种更好的代码组织方式。

但这个设计确实带来了问题

当然，没有块级作用域并非毫无缺陷。有几个常见的坑，几乎每个Python新手都会踩到。

坑1：循环变量泄漏

最经典的例子：

for i in range(10):
    # 做一些事情
    pass

print(i)  # 9，i还在！

你可能以为循环结束后i就消失了，但它没有。如果后面不小心又用到了i，可能会得到意外的值。

更危险的是这个：

items = [1, 2, 3]
for item in items:
    if item == 2:
        break

print(item)  # 2，item还在

本意是检查列表里是否有2，然后想用item做别的事情，但item保留的是最后一个被赋值的元素。

坑2：列表推导式里的变量泄漏（Python 2）

这个问题在Python 2中非常典型：

# Python 2代码
x = 10
squares = [x**2 for x in range(5)]
print(x)  # 4！外面的x被覆盖了

列表推导式中的循环变量x泄漏到了外部，覆盖了原来的x。这是一个著名的设计失误。

Python 3修复了该问题：列表推导式拥有了自己的作用域。注意，字典推导式、集合推导式也一样。

# Python 3
x = 10
squares = [x**2 for x in range(5)]
print(x)  # 10，没问题了

坑3：意外重用变量名

# 想根据条件设置不同的值
if user_is_admin:
    status = "管理员"
else:
    status = "普通用户"

# 后面又用status做别的事情
status = check_user_status(user_id)  # 覆盖了上面的值

因为if块没有作用域，status从一开始就是当前函数的局部变量。如果不小心重用了这个名字，就会覆盖。

坑4：lambda函数里的坑

这个坑与块级作用域有点关系，但更复杂：

funcs = []
for i in range(3):
    funcs.append(lambda: i)

for f in funcs:
    print(f())  # 2 2 2，不是0 1 2

很多人期望输出0 1 2，但实际都是2。

原因：所有lambda函数都引用了同一个变量i，而循环结束后i的值是2。当lambda被调用时，它使用的是i的当前值。

如果Python有块级作用域，每次迭代创建一个新的i，这个问题就不会出现。

解决方案（让每个lambda捕获当前i的值）：

funcs = []
for i in range(3):
    funcs.append(lambda i=i: i)  # 把i作为默认参数固定下来

for f in funcs:
    print(f())  # 0 1 2

其他语言是怎么做的？

对比一下其他语言的设计，能更好地理解Python的选择。

C / Java：严格的块级作用域

// C语言
for (int i = 0; i < 10; i++) {
    int temp = i * 2;
}
// i 和 temp 在这里都不可见

花括号里的变量只在花括号里有效。简单、严格、安全。

JavaScript：从混乱到清晰

JavaScript早期只有var，它没有块级作用域：

if (true) {
    var x = 10;
}
console.log(x);  // 10，x泄漏了！

这导致了很多bug。直到ES6引入了let和const，才有了真正的块级作用域。

if (true) {
    let y = 10;
}
console.log(y);  // 报错，y不在这个作用域里

Ruby：和Python类似

# Ruby
if true
  x = 10
end
puts x  # 10，x还在

Ruby也没有块级作用域（除非使用特定语法）。这点与Python非常相似。

Go：有块级作用域，但很灵活

Go语言具备块级作用域，花括号{}创建新的作用域。

if true {
    x := 10
}
fmt.Println(x) // 编译错误，x未定义

Go不仅支持块级作用域，还通过包（package）控制可见性。

如果没有块级作用域，怎么写出干净的代码？

Python虽然没有块级作用域，但一些好习惯可以让代码更清晰、更安全。

方法1：用函数隔离

如果一段逻辑比较复杂，把它封装进一个函数里。

def process_items(items):
    result = []
    for item in items:
        temp = item * 2# temp只在函数里有效
        result.append(temp)
    return result

函数是Python唯一的作用域边界，用它来隔离临时变量。

方法2：循环后删除临时变量

如果你担心循环变量泄漏，可以手动删除它：

for i in range(10):
    # 处理逻辑
    pass

del i  # 删除i，后面再用就会报错

不过这种做法不太常见，通常不会造成问题。

方法3：用小函数替代复杂循环

如果你的循环很长，或者有嵌套循环，考虑拆成小函数：

# 不推荐：长循环里有很多临时变量
for i in range(100):
    temp1 = i * 2
    temp2 = temp1 ** 2
    # 很多行...
    
# 推荐：把逻辑抽成函数
def process_single_item(i):
    temp1 = i * 2
    temp2 = temp1 ** 2
    return temp2

for i in range(100):
    result = process_single_item(i)

方法4：写清晰的名字，避免重用

最简单的办法：不要在同一个函数里重用同一个变量名做不同的事情。

# 不推荐
status = "active"
# ... 50行代码 ...
status = check_user_status()  # 复用status，但意思变了

# 推荐
initial_status = "active"
# ... 50行代码 ...
current_status = check_user_status()

如果Python加入块级作用域会怎样？

想象一下。假设Python的下一个版本突然支持了块级作用域，用let关键字：

if condition:
    let x = 10# 块级变量
    print(x)    # 10
print(x)        # 报错

会发生什么？

• 现有的代码会大量报错（因为很多人依赖变量泄漏的行为）
• Python需要引入新关键字let或block
• 语言变得更复杂，初学者要学习两套规则

这显然不符合Python“渐进式改进”和“不破坏已有代码”的原则。

所以Python不太可能加入块级作用域。Guido在多个场合提到过，保持简单是Python的核心价值。

回到开头的故事

那个从JavaScript转过来的朋友，后来慢慢适应了Python的方式。

他说：“习惯之后，其实觉得也没什么。反正写代码的时候知道，函数才是作用域边界。循环里的变量就让它去吧，只要我注意命名，不会出问题。”

他说得对。

Python没有块级作用域，这不叫缺陷，这叫设计选择。

每种语言都有自己的特点和哲学。JavaScript的设计者觉得块级作用域很重要，所以加进了语言。Python的设计者觉得保持简单更重要，所以选择了不加入。

作为开发者，我们的任务是：理解自己用的语言是怎么设计的，然后按它的方式来写代码。

一张表总结

最后一句

Python没有块级作用域。记住这一条就够了：只有函数才能创造新天地，其他地方都是共享的。

这个特性让Python变得简单、直观，也带来了一些小坑。理解了它，你就能写出更为地道的Python代码。