为什么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代码。