Python 默認是沒有 goto 語句的，但是有一個第三方庫支持在 Python 里面實現(xiàn)類似于

goto 的功能：https://github.com/snoack/python-goto.。比如在下面這個例子里，

            
from goto import with_goto

@with_goto
def func():
  for i in range(2):
    for j in range(2):
      goto .end
  label .end
  return (i, j, k)
          

func() 在執(zhí)行第一遍循環(huán)時，就會從最內(nèi)層的 for j in range(2) 跳到函數(shù)的 return 語句前面。

按理說本文到此就該完了，但是這個庫有一個限制，如果嵌套的循環(huán)層次太深，就無法工作。比如下面這幾行代碼：

            
@with_goto
def func():
  for i in range(2):
    for j in range(2):
      for k in range(2):
        for m in range(2):
          for n in range(2):
            goto .end
  label .end
  return (i, j, k, m, n)
          

會讓它拋出 SyntaxError 。

本文接下來的內(nèi)容，就是如何打破這個限制。

python-goto 是如何工作的

python-goto 這個庫，通過 decorator 的方式修改了傳進來的函數(shù) func 的 __code__ 屬性，把插入的字節(jié)碼暗樁替換成相關(guān)的 JMP 語句。具體的瑣碎實現(xiàn)細節(jié)，可以參考該項目下 goto.py 這個文件，一共也就不到兩百行。

本文開頭的例子中， func 函數(shù)的字節(jié)碼可以用

            
import dis
dis.dis(func)
          

打印出來。

下面貼出不帶 @with_goto 時的輸出（# 號后面的內(nèi)容是我加的）：實際上

            
# for i in range(2):
# 7 是源代碼行號（跟示例不太對得上，不要太在意細節(jié)XD）
# 0/2/4 這些是 offset，在這里每條字節(jié)碼長度都是 2。
# >> 表示會跳到這里。
 7      0 SETUP_LOOP       40 (to 42)
       2 LOAD_GLOBAL       0 (range)
       4 LOAD_CONST        1 (2)
       6 CALL_FUNCTION      1
       8 GET_ITER
    >>  10 FOR_ITER        28 (to 40)
       12 STORE_FAST        0 (i)

# for j in range(2):
 8     14 SETUP_LOOP       22 (to 38)
       16 LOAD_GLOBAL       0 (range)
       18 LOAD_CONST        1 (2)
       20 CALL_FUNCTION      1
       22 GET_ITER
    >>  24 FOR_ITER        10 (to 36)
       26 STORE_FAST        1 (j)

# goto .end
 9     28 LOAD_GLOBAL       1 (goto)
       30 LOAD_ATTR        2 (end)
       32 POP_TOP
# 結(jié)束循環(huán) j
       34 JUMP_ABSOLUTE      24
    >>  36 POP_BLOCK
# 結(jié)束循環(huán) i
    >>  38 JUMP_ABSOLUTE      10
    >>  40 POP_BLOCK

# label .end
 10   >>  42 LOAD_GLOBAL       3 (label)
       44 LOAD_ATTR        2 (end)
       46 POP_TOP

# return (i, j, k)
 11     48 LOAD_FAST        0 (i)
       50 LOAD_FAST        1 (j)
       52 LOAD_GLOBAL       4 (k)
       54 BUILD_TUPLE       3
          

跟帶 @with_goto 時的輸出比較，只有這兩點差別：

            
# goto .end
- 9     28 LOAD_GLOBAL       1 (goto)
-       30 LOAD_ATTR        2 (end)
-       32 POP_TOP
+ 9     28 POP_BLOCK
+       30 POP_BLOCK
+       32 JUMP_FORWARD      14 (to 48)
          

            
# label .end
- 10   >>  42 LOAD_GLOBAL       3 (label)
-       44 LOAD_ATTR        2 (end)
-       46 POP_TOP
+ 10   >>  42 NOP
+       44 NOP
+       46 NOP

- 11     48 LOAD_FAST        0 (i)
+ 11   >>  48 LOAD_FAST        0 (i)
          

在沒有引入 @with_goto 時， goto .end 在 Python 解釋器的眼里，其實就是 goto.end ，即訪問某個叫 goto 的全局域里的對象的 end 屬性。該語句會被編譯成三條語句： LOAD_GLOBAL 、 LOAD_ATTR 、 POP_TOP 。這就是插入在字節(jié)碼里的暗樁。

在引入 @with_goto 之后，這三條語句會被替換成一條 JMP 語句外加若干條輔助的語句。這樣在執(zhí)行到這些字節(jié)碼時，就會跳到指定的地方了，比如在上面例子中跳到 offset 48，也即原來 label .end 的下一條字節(jié)碼。

（關(guān)于 Python 字節(jié)碼的官方文檔并不顯眼，藏在 dis 這個模塊下。注意它不是按字母表順序介紹每個字節(jié)碼的，所以要想查特定的字節(jié)碼，需要 Ctrl+F 一下。）

JMP 語句只需要一條，如果要向前跳，就用 JUMP_FORWARD ；向后跳，就用 JUMP_ABSOLUTE 。但是輔助的語句可能不止一條，比如要想從一個 for loop 或者 try block 跳出來，需要加 POP_BLOCK 語句。有多少層循環(huán)就需要加多少條 POP_BLOCK ，比如前面的示例里是兩層循環(huán)，就是兩條 POP_BLOCK 。

另外，由于 Python 字節(jié)碼的長度固定為兩個 byte，一個 byte 用于表示字節(jié)碼的類型，另一個用于表示參數(shù)。如果要想放下超過字節(jié)碼預留的空位的參數(shù)，需要用 EXTENDED_ARG 語句。比如

            
EXTENDED_ARG       7
EXTENDED_ARG     2046
OP            x
          

那么語句 OP 的參數(shù)就是 7 << 16 + 2046 << 8 + x。

對于 JUMP_FORWARD ，它的參數(shù)是 offset。所以當目標地址離當前位置的 offset 超過256 時，需要額外生成 EXTENDED_ARG 。 JUMP_ABSOLUTE 也是同樣的道理，只是該語句的參數(shù)是絕對地址。

所以對于深層嵌套內(nèi)、需要跳到很遠的 goto 語句，就要加不少輔助語句。而 python-goto 這個庫，在替換暗樁時，并不會額外增加語句。如果所需的語句超過暗樁的大小，會拋出 SyntaxError。

在 Python 3.6 之前，不帶參數(shù)的語句只需要 1 個字節(jié)，同樣 6 個字節(jié)的地方，可以容納 1 條必需的 JMP 語句和 4 條 POP_BLOCK 。除非你是在一個五層循環(huán)里用 goto ，不太會碰到這個限制。但是 Python 3.6 之后， POP_BLOCK 也要用 2 個字節(jié)了，頓時連三層循環(huán)都 hold 不住了，這個問題就顯得尖銳起來。上面還沒考慮到需要加 EXTENDED_ARG 的情況。

如何繞過字節(jié)碼大小的限制

那么一個顯而易見的解決方案就浮出水面了：為何不試試在修改字節(jié)碼的時候，動態(tài)改變字節(jié)碼的大小，讓它有足夠的位置容納新增的輔助語句？這樣一來，就能徹底地解決問題了。

這個就是開頭說到的，打破限制的方法。

Python 本身是允許動態(tài)增大/縮小 __code__ 屬性里的字節(jié)碼的。但是有個問題，Python里許多字節(jié)碼依賴特定的位置或者偏移。如果我們挪動了涉及的字節(jié)碼，需要同步修改這些語句的參數(shù)。（包括我們新生成的 goto 語句里面的 JUMP_ABSOLUTE 和 JUMP_FORWARD ）

這個聽起來簡單，似乎只要把參數(shù) patch 成實際修改后的值就好了。然而 Python 是通過在字節(jié)碼前面插入 EXTENDED_ARG 來實現(xiàn)定長字節(jié)碼里支持不定長參數(shù)的功能。修改參數(shù)的值可能需要動態(tài)調(diào)整 EXTENDED_ARG 語句的數(shù)量；而調(diào)整 EXTENDED_ARG 又反過來影響到各個語句的參數(shù)…… 所以這里需要一個 while True 循環(huán)，直到某一次調(diào)整不會觸發(fā) EXTENDED_ARG 語句的變化為止。

好在如果我們只單方面增大字節(jié)碼，就只需要增加 EXTENDED_ARG 語句。而每在一個地方增加完 EXTENDED_ARG 語句，就意味著對應(yīng)的 OP 語句參數(shù)能縮小 256。后面無論怎么調(diào)整，都不太可能需要再增加多一個 EXTENDED_ARG 語句。這么一來，調(diào)整的次數(shù)就不會多。

雖然說起來好像就那么兩三段話的事，但是開發(fā)難度會很大。因為需要 patch 的字節(jié)碼類型很多，大約十來種吧。而且邏輯上較為復雜，牽連的地方很多。實際上我沒有實現(xiàn)前述的方案，只是設(shè)計了下而已。如果你要實現(xiàn)它，請在編碼時保持內(nèi)心的平靜，另外多寫測試用例，不然很容易出問題。

以上就是本文的全部內(nèi)容，希望對大家的學習有所幫助，也希望大家多多支持腳本之家。