为什么Python没有块级作用域？

免费编程软件「python+pycharm」

链接：https://pan.quark.cn/s/48a86be2fdc0

一个从JavaScript转Python的朋友

去年有个朋友从前端转后端，开始学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代码。