python3的變量作用域規則和nonlocal關鍵字

也許你已經覺得自己可以熟練使用python并能勝任許多開發任務，是以這篇文章是在浪費你的時間。不過别着急，我們先從一個例子開始：

i = 0
def f():
  print(i)
  i += 1
  print(i)

f()
print(i)
           

猜猜看輸出是什麼？你會說不就是0，1，1麼，真的是這樣嗎？

> python test.py
Traceback (most recent call last):
  File "a.py", line 7, in <module>
    f()
  File "a.py", line 3, in f
    print(i)
UnboundLocalError: local variable 'i' referenced before assignment
           

這是為什麼？如果你還不清楚産生錯誤的原因，那就請繼續往下閱讀吧！

本文索引

• LEGB原則
• 名字隐藏和暫時性死區
• 消除暫時性死區
• 使用nonlocal聲明閉包作用域變量
• 總結

變量的作用域，這是一個老生常談的問題了。

在python中作用域規則可以簡單的歸納為

LEGB原則

，也就是說，對于一個變量

name

，首先會從目前的作用域開始查找，如果它不在函數裡那就從global開始，沒找到就查找builtin作用域，如果它位于函數中，就先從local作用域查找，接着如果目前的函數是一個閉包，那麼就查找外層閉包的作用域，也就是規則中的

E

，接着是global和builtin，如果都沒找到

name

這個變量，則抛出

NameError

。

那麼我們來看一段代碼：

i = 100
def f():
  print(i)
           

在這段代碼中，print位于builtin作用域，i位于global，那麼：

1. 在函數f中找不到這兩個名字，是以從local向上查找，
2. 首先f不是閉包，是以跳過閉包作用域的查找，
3. 然後查找global，找到了i，但print還未找到，
4. 然後查找builtin，找到了print的builtin子產品裡的一個函數。

至此名字查找結束，調用找到的函數，輸出結果100。

現在你可能更加疑惑了，既然查找規則按照

LEGB

的方向進行，那麼test.py中的f不就應該找到i為global中的變量嗎，為什麼會報錯呢？

在揭曉答案之前，我們先複習一下名字隐藏。

它是指一個聲明在局部作用中的名字會隐藏外層作用域中的同名的對象。許多語言都遵守這一特性，python也不例外。

那麼暫時性死區是什麼呢？這是es6的一個概念，當你在局部作用域中定義了一個非全局的名字時，這個名字會綁定在目前作用域中，并将外部作用域的同名對象隐藏：

var i = 'hello'
function f() {
  i = 'world'
  let i
}
           

這段代碼中函數中的i被綁定在局部作用域（也就是函數體内）中，在綁定的作用域中可見，并将外部的名字隐藏，而對一個未聲明的局部變量指派會導緻錯誤，是以上面的代碼會引發

ReferenceError: i is not defined

對于python來說也是一樣的問題，python代碼在執行前首先會被編譯成位元組碼，這就會導緻某些時候實際執行的程式會和我們看到的産生出入。不過我們有

dis

子產品幫忙，它可以輸出python對象的位元組碼，下面我們就來看下經過編譯後的

f

：

> dis(f)

2           0 LOAD_GLOBAL              0 (print)
            2 LOAD_FAST                0 (i)
            4 CALL_FUNCTION            1
            6 POP_TOP

3           8 LOAD_CONST               1 ('a')
           10 STORE_FAST               0 (i)

4          12 LOAD_GLOBAL              0 (print)
           14 LOAD_FAST                0 (i)
           16 CALL_FUNCTION            1
           18 POP_TOP
           20 LOAD_CONST               0 (None)
           22 RETURN_VALUE
           

位元組碼的解釋在這裡。

其中

LOAD_FAST

和

STORE_FAST

是讀取和存儲local作用域的變量，我們可以看到，i變成了局部作用域的變量！而對i的指派早于i的定義，是以報錯了。

産生這種現象的原因也很簡單，python對函數的代碼是獨立編譯的，如果未加說明而在函數内對一個變量指派，那麼就認為你定義了一個局部變量，進而把外部的同名對象屏蔽了。這麼做無可厚非，畢竟python沒有獨立的聲明一個局部變量的文法，但結果就會造成我們看到的類似暫時性死區的現象。是以請允許我把es6的概念套用在python身上。

既然知道問題的症結在于python無法區分局部變量的聲明和定義，那麼我們就來解決它。

對于一個可以區分聲明和定義的語言來說是沒有這種煩惱的，比如c：

int i = 0;
void f(void)
{
  i++;
  printf("%d\n", i); // 1
  const char *i = "hello";
  printf("%s\n", i); // "hello"
}
           

python中不能這麼做，但是我們可以換一個思路，聲明一個變量是全局作用域的，這樣不就解決了嗎？

global

運算符就是為了這個目的而存在的，它聲明一個變量始終是全局作用域的變量，是以隻要存在global聲明，那麼目前作用域裡的這個名字就是一個對同名全局變量的引用。改進後的函數如下：

def f():
  global i
  print(i)
  i += 1
  print(i)
           

現在運作程式就會是你想要的結果了：

> python test.py
0
1
1
           

如果你還是不放心，那麼我們再來看看位元組碼：

> dis(f)

3           0 LOAD_GLOBAL              0 (print)
            2 LOAD_GLOBAL              1 (i)
            4 CALL_FUNCTION            1
            6 POP_TOP

4           8 LOAD_CONST               1 ('a')
           10 STORE_GLOBAL             1 (i)

5          12 LOAD_GLOBAL              0 (print)
           14 LOAD_GLOBAL              1 (i)
           16 CALL_FUNCTION            1
           18 POP_TOP
           20 LOAD_CONST               0 (None)
           22 RETURN_VALUE
           

對于i的存取已經由

LOAD_GLOBAL

STORE_GLOBAL

接手了，沒問題。

當然

global

也有它的局限性：

• 一旦聲明global，那麼這個名字始終是global作用域的一個變量，不可以再是局部變量
• 名字必須存在于global裡，因為python在運作時進行名字查找，是以你的變量在global裡找不到的話對它的引用将會出錯
• 接上一條，因為global限定了名字查找的範圍，是以像閉包作用域的變量就找不到了

事實上需要引用非global名字的需求是極其常見的，是以為了解決global的不足，python3引入了

nonlocal

假設我們有一個需求，一個函數需要知道自己被調用了多少次，最簡單的實作就是使用閉包：

def closure():
  count = 0
  def func():
    # other code
    count += 1
    print(f'I have be called {count} times')

  return func
           

還是老問題，這樣寫對嗎？

答案是不對，你又制造暫時性死區啦！

>>> f=closure()
>>> f()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 5, in func
UnboundLocalError: local variable 'count' referenced before assignment
           

這時候就要

nonlocal

出場了，它聲明一個名字位于閉包作用域中，如果閉包作用域中未找到就報錯。

是以修正後的函數如下：

def closure():
  count = 0
  def func():
    # other code
    nonlocal count
    count += 1
    print(f'I have be called {count} times')

  return func
           

測試一下：

>>> f=closure()
>>> f()
I have be called 1 times
>>> f()
I have be called 2 times
>>> f()
I have be called 3 times
>>> f2=closure()
>>> f2()
I have be called 1 times
           

現在可以正常使用和修改閉包作用域的變量了。

當然，在函數裡修改外部變量往往會導緻潛在的缺陷，但有時這樣做又是對的，是以希望你在好好了解作用域規則的前提下合理地利用它們。

作用域規則可以總結為下：

1. 名字查找按照LEGB規則進行，如果目前代碼在global中則從global作用域開始查找，否則從local開始
2. builtin作用域中是内置類型和函數，是以它們總是能被找到，前提是不要在局部作用域中對它們指派
3. global中存放着所有定義在目前子產品和導入的名字
4. local是局部作用域，存放在形成局部作用于的代碼中有指派行為的名字
5. 閉包作用域是閉包函數的外層作用域，裡面可以存放一些自定義的狀态
6. global聲明一個名字在global作用域中
7. nonlocal聲明一個名字在閉包作用域中
8. 最重要的一條，當你在能産生局部作用域的代碼中對一個名字進行指派，那麼這個名字就會被認為是一個local作用域的變量進而屏蔽其他作用域中的同名對象

隻要記住這些規則你就可以和因作用域引起的各種問題說再見了。而且了解了這些規則還會為你探索更深層次的python打下堅實的基礎，是以請将它牢記于心。