在Python中是否有goto或任何等价的东西能够跳转到特定的代码行?
Python为您提供了使用第一类函数可以用goto完成的一些事情的能力。例如:
void somefunc(int a)
{
if (a == 1)
goto label1;
if (a == 2)
goto label2;
label1:
...
label2:
...
}
在Python中可以这样做:
def func1():
...
def func2():
...
funcmap = {1 : func1, 2 : func2}
def somefunc(a):
funcmap[a]() #Ugly! But it works.
当然，这并不是代替goto的最佳方式。但是如果你不知道你想用去做什么，就很难给出具体的建议。
@ascobol:
最好的方法是将其包含在函数中或使用异常。对于函数:
def loopfunc():
while 1:
while 1:
if condition:
return
对于例外情况:
try:
while 1:
while 1:
raise BreakoutException #Not a real exception, invent your own
except BreakoutException:
pass
如果您来自另一种编程语言，使用异常来做这样的事情可能会感觉有点尴尬。但我认为，如果您不喜欢使用异常，Python并不适合您。: -)
使用评论中@bobince的建议来回答@ascobol的问题:
for i in range(5000):
for j in range(3000):
if should_terminate_the_loop:
break
else:
continue # no break encountered
break
else块的缩进是正确的。代码在循环Python语法后使用模糊的else。参见为什么python在for和while循环之后使用'else' ?
早在2007年，PEP 3136就提出了中断和继续的标签，但被拒绝了。提案的动机部分说明了在Python中模仿带标签的break的几种常见方法(虽然不太优雅)。
你可以使用用户定义异常来模拟goto
例子:
class goto1(Exception):
pass
class goto2(Exception):
pass
class goto3(Exception):
pass
def loop():
print 'start'
num = input()
try:
if num<=0:
raise goto1
elif num<=2:
raise goto2
elif num<=4:
raise goto3
elif num<=6:
raise goto1
else:
print 'end'
return 0
except goto1 as e:
print 'goto1'
loop()
except goto2 as e:
print 'goto2'
loop()
except goto3 as e:
print 'goto3'
loop()
通过一些工作，在python中添加类似“goto”的语句在技术上是可行的。我们将使用"dis"和"new"模块，这两个模块对于扫描和修改python字节代码都非常有用。
实现背后的主要思想是首先将代码块标记为使用“goto”和“label”语句。一个特殊的“@goto”装饰器将用于标记“goto”函数。然后，我们扫描这两个语句的代码，并对底层字节代码应用必要的修改。这一切都发生在源代码编译时。
import dis, new
def goto(fn):
"""
A function decorator to add the goto command for a function.
Specify labels like so:
label .foo
Goto labels like so:
goto .foo
Note: you can write a goto statement before the correspnding label statement
"""
labels = {}
gotos = {}
globalName = None
index = 0
end = len(fn.func_code.co_code)
i = 0
# scan through the byte codes to find the labels and gotos
while i < end:
op = ord(fn.func_code.co_code[i])
i += 1
name = dis.opname[op]
if op > dis.HAVE_ARGUMENT:
b1 = ord(fn.func_code.co_code[i])
b2 = ord(fn.func_code.co_code[i+1])
num = b2 * 256 + b1
if name == 'LOAD_GLOBAL':
globalName = fn.func_code.co_names[num]
index = i - 1
i += 2
continue
if name == 'LOAD_ATTR':
if globalName == 'label':
labels[fn.func_code.co_names[num]] = index
elif globalName == 'goto':
gotos[fn.func_code.co_names[num]] = index
name = None
i += 2
# no-op the labels
ilist = list(fn.func_code.co_code)
for label,index in labels.items():
ilist[index:index+7] = [chr(dis.opmap['NOP'])]*7
# change gotos to jumps
for label,index in gotos.items():
if label not in labels:
raise Exception("Missing label: %s"%label)
target = labels[label] + 7 # skip NOPs
ilist[index] = chr(dis.opmap['JUMP_ABSOLUTE'])
ilist[index + 1] = chr(target & 255)
ilist[index + 2] = chr(target >> 8)
# create new function from existing function
c = fn.func_code
newcode = new.code(c.co_argcount,
c.co_nlocals,
c.co_stacksize,
c.co_flags,
''.join(ilist),
c.co_consts,
c.co_names,
c.co_varnames,
c.co_filename,
c.co_name,
c.co_firstlineno,
c.co_lnotab)
newfn = new.function(newcode,fn.func_globals)
return newfn
if __name__ == '__main__':
@goto
def test1():
print 'Hello'
goto .the_end
print 'world'
label .the_end
print 'the end'
test1()
希望这回答了问题。
一个工作版本已经完成:http://entrian.com/goto/。
注:这是一个愚人节玩笑。(工作)
# Example 1: Breaking out from a deeply nested loop:
from goto import goto, label
for i in range(1, 10):
for j in range(1, 20):
for k in range(1, 30):
print i, j, k
if k == 3:
goto .end
label .end
print "Finished\n"
不用说。是的，它很有趣，但不要使用它。
我想要同样的答案，我不想使用goto。所以我使用了下面的例子(来自learnpythonthehardway)
def sample():
print "This room is full of gold how much do you want?"
choice = raw_input("> ")
how_much = int(choice)
if "0" in choice or "1" in choice:
check(how_much)
else:
print "Enter a number with 0 or 1"
sample()
def check(n):
if n < 150:
print "You are not greedy, you win"
exit(0)
else:
print "You are nuts!"
exit(0)
我最近写了一个函数装饰器，在Python中启用goto，就像这样:
from goto import with_goto
@with_goto
def range(start, stop):
i = start
result = []
label .begin
if i == stop:
goto .end
result.append(i)
i += 1
goto .begin
label .end
return result
我不知道为什么有人想做这样的事情。也就是说，我并不是很认真。但我想指出的是，这种元编程在Python中实际上是可能的，至少在CPython和PyPy中是可能的，而不仅仅是像其他人那样误用调试器API。不过，您必须修改字节码。
我在找一些类似的东西
for a in xrange(1,10):
A_LOOP
for b in xrange(1,5):
for c in xrange(1,5):
for d in xrange(1,5):
# do some stuff
if(condition(e)):
goto B_LOOP;
所以我的方法是使用一个布尔值来帮助打破嵌套的for循环:
for a in xrange(1,10):
get_out = False
for b in xrange(1,5):
if(get_out): break
for c in xrange(1,5):
if(get_out): break
for d in xrange(1,5):
# do some stuff
if(condition(e)):
get_out = True
break
我在官方的python设计和历史FAQ中找到了这个。
为什么没有goto? 您可以使用异常来提供一个甚至可以工作的“结构化goto” 跨函数调用。许多人认为异常可以方便地实现 模拟C语言中“go”或“goto”结构的所有合理使用， Fortran和其他语言。例如:
class label(Exception): pass # declare a label
try:
...
if condition: raise label() # goto label
...
except label: # where to goto
pass
...
这并不允许你跳到循环的中间，但那是 通常被认为是对goto的滥用。很少使用。
在官方常见问题解答中甚至提到了这一点，并且提供了一个很好的解决方案示例，这非常好。我真的很喜欢python，因为它的社区甚至是这样对待goto的;)
我有自己的做法。 我使用单独的python脚本。
如果我想要循环:
file1.py
print("test test")
execfile("file2.py")
a = a + 1
file2.py
print(a)
if a == 10:
execfile("file3.py")
else:
execfile("file1.py")
file3.py
print(a + " equals 10")
(注意:此技术仅适用于Python 2。x版本)
对于一个向前的后藤，你可以添加:
while True:
if some condition:
break
#... extra code
break # force code to exit. Needed at end of while loop
#... continues here
但这只适用于简单的场景(即嵌套这些会让你陷入混乱)
为了代替python的goto等效，我以以下方式使用break语句快速测试我的代码。这里假设您有结构化的代码库。测试变量在函数开始时初始化，我只是将“If test: break”块移动到我想测试的嵌套If -then块或循环的末尾，在代码末尾修改返回变量以反映我正在测试的块或循环变量。
def x:
test = True
If y:
# some code
If test:
break
return something
不，有另一种方法来实现goto语句
class id:
def data1(self):
name=[]
age=[]
n=1
while n>0:
print("1. for enter data")
print("2. update list")
print("3. show data")
print("choose what you want to do ?")
ch=int(input("enter your choice"))
if ch==1:
n=int(input("how many elemet you want to enter="))
for i in range(n):
name.append(input("NAME "))
age.append(int(input("age ")))
elif ch==2:
name.append(input("NAME "))
age.append(int(input("age ")))
elif ch==3:
try:
if name==None:
print("empty list")
else:
print("name \t age")
for i in range(n):
print(name[i]," \t ",age[i])
break
except:
print("list is empty")
print("do want to continue y or n")
ch1=input()
if ch1=="y":
n=n+1
else:
print("name \t age")
for i in range(n):
print(name[i]," \t ",age[i])
n=-1
p1=id()
p1.data1()
Python 2和3
pip3 install goto-statement
在Python 2.6到3.6和PyPy上测试。
链接:转向语句
foo.py
from goto import with_goto
@with_goto
def bar():
label .bar_begin
...
goto .bar_begin
虽然在Python中没有任何等同于goto/label的代码，但您仍然可以使用循环来获得goto/label的这种功能。
让我们以下面所示的代码示例为例，其中goto/label可以在python以外的任意语言中使用。
String str1 = 'BACK'
label1:
print('Hello, this program contains goto code\n')
print('Now type BACK if you want the program to go back to the above line of code. Or press the ENTER key if you want the program to continue with further lines of code')
str1 = input()
if str1 == 'BACK'
{
GoTo label1
}
print('Program will continue\nBla bla bla...\nBla bla bla...\nBla bla bla...')
现在，通过使用下面所示的while循环，可以在python中实现上述代码示例的相同功能。
str1 = 'BACK'
while str1 == 'BACK':
print('Hello, this is a python program containing python equivalent code for goto code\n')
print('Now type BACK if you want the program to go back to the above line of code. Or press the ENTER key if you want the program to continue with further lines of code')
str1 = input()
print('Program will continue\nBla bla bla...\nBla bla bla...\nBla bla bla...')
我认为while循环是“goto_Statement”的替代。因为3.6之后，goto循环不再工作了。我还写了一个while循环的例子。
str1 = "stop"
while str1 == "back":
var1 = int(input(" Enter Ist Number: "))
var2 = int(input(" Enter 2nd Number: "))
var3 = print(""" What is your next operation
For Addition Press And Enter : 'A'
For Muliplt Press And Enter : 'M'
For Division Press And Enter : 'D'
For Subtaction Press And Enter : 'S' """)
var4 = str(input("For operation press any number : "))
if(var1 == 45) and (var2 == 3):
print("555")
elif(var1 == 56) and (var2 == 9):
print("77")
elif(var1 == 56) and (var2 == 6):
print("4")
else:
if(var4 == "A" or "a"):
print(var1 + var2)
if(var4 == "M" or "m"):
print(var1 * var2)
if(var4 == "D" or "d"):
print(var1 / var2)
if(var4 == "S" or "s"):
print(var1 - var2)
print("if you want to continue then type 'stop'")
str1 = input()
print("Strt again")
你可以使用python中的嵌套方法来实现
def func1():
print("inside func1")
def inline():
print("im inside")
inline()
func1()
在执行“goto”时，首先必须问“goto”是什么。虽然看起来很明显，但大多数人都没有考虑goto与函数栈之间的关系。
如果在函数内部执行“goto”，实际上就放弃了函数调用堆栈。这被认为是一种糟糕的做法，因为函数栈的设计期望在委托一个中间任务之后，您将继续您离开的地方。这就是为什么goto用于异常，而异常可以用来模拟goto，我将对此进行解释。
Finite state machines are probably the best use case for goto, which most of the time are implemented in a kludgy way with loops and switch statements, but I believe that "top level" gotos, are the cleanest, most semantic way to implement finite state machines. In this case, you want to make sure, if you have more variables, they are globals, and don't require encapsulation. Make sure you first model your variable state space(which may be different from execution state, ie the finite state machine).
我相信有合理的设计理由使用goto，异常处理是特殊情况下，混合goto和函数是有意义的。然而，在大多数情况下，您希望将自己限制在“顶级”goto，因此永远不要在函数中调用goto，而只在全局作用域中调用。
在现代语言中模拟顶级goto最简单的方法是实现顶级goto只需要全局变量和空调用堆栈。因此，为了保持调用堆栈为空，每当调用新函数时都返回。下面是一个输出前n个斐波那契数的例子:
a = 0
b = 1
n = 100
def A():
global a, b
a = a + b
n -= 1
print(a)
return B() if n > 0 else 0
def B():
global a, b
b = a + b
n -= 1
print(b)
return A() if n > 0 else 0
A()
虽然这个示例可能比循环实现更详细，但它也更强大和灵活，并且不需要特殊情况。它让你有一个完整的有限状态机。您还可以使用goto运行器对此进行修改。
def goto(target):
while(target) target = target()
def A():
global a, b
a = a + b
print(a)
return B
def B():
global a, b
b = a + b
print(b)
return A
goto(A)
为了强制执行“返回”部分，您可以编写一个goto函数，在完成时抛出一个异常。
def goto(target):
target()
throw ArgumentError("goto finished.")
def A():
global a, b
a = a + b
print(a)
goto(B)
def B()
global a, b
b = a + b
print(b)
goto(A)
goto(A)
因此，您可以看到，这在很大程度上是过度思考的，而调用一个函数然后抛出一个错误的helper函数就是您所需要的。您可以将它进一步包装在一个“start”函数中，这样错误就会被捕获，但我认为这并不是严格必要的。虽然其中一些实现可能会耗尽调用堆栈，但第一个运行器示例将其保持为空，如果编译器可以进行尾部调用优化，这也会有所帮助。
我用函数解决了这个问题。我唯一做的就是改变函数的标签。下面是一个非常基本的代码:
def goto_holiday(): #label: holiday
print("I went to holiday :)")
def goto_work(): #label: work
print("I went to work")
salary=5000
if salary>6000:
goto_holiday()
else:
goto_work()
