python中goto什么意思_如何在Python中实现goto语句的⽅法Python 默认是没有 goto 语句的，但是有⼀个第三⽅库⽀持在 Python ⾥⾯实现类似于
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() 在执⾏第⼀遍循环时，就会从最内层的 for j in range(2) 跳到函数的return 语句前⾯。
按理说本⽂到此就该完了，但是这个库有⼀个限制，如果嵌套的循环层次太深，就⽆法⼯作。⽐如下⾯这⼏⾏代码：
@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。
本⽂接下来的内容，就是如何打破这个限制。
python-goto 是如何⼯作的
python-goto 这个库，通过 decorator 的⽅式修改了传进来的函数 func 的__code__ 属性，把插⼊的字节码暗桩替换成相关的 JMP 语句。具体的琐碎实现细节，可以参考该项⽬下 goto.py 这个⽂件，⼀共也就不到两百⾏。
本⽂开头的例⼦中，func 函数的字节码可以⽤
import dis
dis.dis(func)
打印出来。
下⾯贴出不带 @with_goto 时的输出(# 号后⾯的内容是我加的)：实际上
# for i in range(2):
# 7 是源代码⾏号(跟⽰例不太对得上，不要太在意细节XD)
# 0/2/4 这些是 offt，在这⾥每条字节码长度都是 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
# 结束循环 j
34 JUMP_ABSOLUTE 24
>> 36 POP_BLOCK
# 结束循环 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 解释器的眼⾥，其实就是d，即访问某个叫 goto 的全局域⾥的对象的 end 属性。该语句会被编译成三条语句：LOAD_GLOBAL、LOAD_ATTR、POP_TOP。这就是插⼊在字节码⾥的暗桩。
在引⼊ @with_goto 之后，这三条语句会被替换成⼀条 JMP 语句外加若⼲条辅助的语句。这样在执⾏到这些字节码时，就会跳到指定的地⽅了，⽐如在上⾯例⼦中跳到 offt 48，也即原来 label .end 的下⼀条字节码。
(关于 Python 字节码的官⽅⽂档并不显眼，藏在 dis 这个模块下。注意它不是按字母表顺序介绍每个字节码的，所以要想查特定的字节码，需要 Ctrl+F ⼀下。)
JMP 语句只需要⼀条，如果要向前跳，就⽤ JUMP_FORWARD；向后跳，就⽤JUMP_ABSOLUTE。但是辅助的语句可能不⽌⼀条，⽐如要想从⼀个 for loop 或者 try block 跳出来，需要加 POP_BLOCK 语句。有多少层循环就需要加多少条 POP_BLOCK，⽐如前⾯的⽰例⾥是两层循环，就是两条 POP_BLOCK。
另外，由于 Python 字节码的长度固定为两个 byte，⼀个 byte ⽤于表⽰字节码的类型，另⼀个⽤于表⽰参数。如果要想放下超过字节码预留的空位的参数，需要⽤ EXTENDED_ARG语句。⽐如
EXTENDED_ARG 7
EXTENDED_ARG 2046
OP x
那么语句 OP 的参数就是 7 << 16 + 2046 << 8 + x。
对于 JUMP_FORWARD，它的参数是 offt。所以当⽬标地址离当前位置的 offt 超过256 时，需要额外⽣成 EXTENDED_ARG。JUMP_ABSOLUTE 也是同样的道理，只是该语句的参数是绝对地址。
所以对于深层嵌套内、需要跳到很远的 goto 语句，就要加不少辅助语句。⽽python-goto 这个库，在替换暗桩时，并不会额外增加语句。如果所需的语句超过暗桩的⼤⼩，会抛出 SyntaxError。
在 Python 3.6 之前，不带参数的语句只需要 1 个字节，同样 6 个字节的地⽅，可以容纳 1 条必需的 JMP 语句和 4 条 POP_BLOCK。除⾮你是在⼀个五层循环⾥⽤ goto，不太会碰到这个限制。但是 Python 3.6 之后，POP_BLOCK 也要⽤ 2 个字节了，顿时连三层循环都 hold 不住了，这个问题就显得尖锐起来。上⾯还没考虑到需要加EXTENDED_ARG 的情况。
如何绕过字节码⼤⼩的限制
那么⼀个显⽽易见的解决⽅案就浮出⽔⾯了：为何不试试在修改字节码的时候，动态改变字节码的⼤⼩，让它有⾜够的位置容纳新增的辅助语句？这样⼀来，就能彻底地解决问题了。
这个就是开头说到的，打破限制的⽅法。
Python 本⾝是允许动态增⼤/缩⼩ __code__ 属性⾥的字节码的。但是有个问题，Python⾥许多字节码依赖特定的位置或者偏移。如果我们挪动了涉及的字节码，需要同步修改这些语句的参数。(包括我们新⽣成的 goto 语句⾥⾯的 JUMP_ABSOLUTE 和
JUMP_FORWARD)
这个听起来简单，似乎只要把参数 patch 成实际修改后的值就好了。然⽽ Python 是通过在字节码前⾯插⼊ EXTENDED_ARG 来实现定长字节码⾥⽀持不定长参数的功能。修改参数的值可能需要动态调整 EXTENDED_ARG 语句的数量；⽽调整 EXTENDED_ARG ⼜反过来影响到各个语句的参数…… 所以这⾥需要⼀个 while True 循环，直到某⼀次调整不会触发 EXTENDED_ARG 语句的变化为⽌。
好在如果我们只单⽅⾯增⼤字节码，就只需要增加 EXTENDED_ARG 语句。⽽每在⼀个地⽅增加完 EXTENDED_ARG 语句，就意味着对应的 OP 语句参数能缩⼩ 256。后⾯⽆论怎么调整，都不太可能需要再增加多⼀个 EXTENDED_ARG 语句。这么⼀来，调整的次数就不会多。
虽然说起来好像就那么两三段话的事，但是开发难度会很⼤。因为需要 patch 的字节码类型很多，⼤约⼗来种吧。⽽且逻辑上较为复杂，牵连的地⽅很多。实际上我没有实现前述的⽅案，只是设计了下⽽已。如果你要实现它，请在编码时保持内⼼的平静，另外多写测试⽤例，不然很容易出问题。
以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持爱蒂⽹。
