파이썬에 레이블 / 고토가 있습니까?

파이썬에 레이블 / 고토가 있습니까?

---

거기에 goto파이썬 또는 이와 동등한 코드의 특정 라인으로 이동 할 수 있도록은?

---

아니요, 파이썬은 레이블과 이동을 지원하지 않습니다. 그것은 (높은) 구조화 된 프로그래밍 언어입니다.

---

파이썬은 일류 함수를 사용하여 goto로 할 수있는 일을 할 수있는 기능을 제공합니다. 예를 들면 다음과 같습니다.

void somefunc(int a)
{
    if (a == 1)
        goto label1;
    if (a == 2)
        goto label2;

    label1:
        ...
    label2:
        ...
}

파이썬에서 다음과 같이 할 수 있습니다 :

def func1():
    ...

def func2():
    ...

funcmap = {1 : func1, 2 : func2}

def somefunc(a):
    funcmap[a]()  #Ugly!  But it works.

물론, 그것은 goto를 대체하는 가장 좋은 방법은 아닙니다. 그러나 goto로 무엇을하려고하는지 정확히 알지 못하면 구체적인 조언을하기가 어렵습니다.

@ 아스코 볼 :

최선의 방법은 함수로 묶거나 예외를 사용하는 것입니다. 기능의 경우 :

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

다른 프로그래밍 언어에서 온 경우 예외를 사용하여 이와 같은 작업을 수행하는 것은 약간 어색 할 수 있습니다. 그러나 예외를 사용하는 것을 싫어하면 파이썬이 당신의 언어가 아니라고 주장합니다. :-)

---

최근 에 파이썬에서 가능하게 하는 함수 데코레이터 를 작성했습니다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

왜 그런 식으로 뭔가를하고 싶은지 잘 모르겠습니다. 즉, 나는 그것에 대해 너무 심각하지 않습니다. 그러나 나는 이런 종류의 메타 프로그래밍이 적어도 CPython과 PyPy에서 파이썬에서 실제로 가능하며 다른 사람이 했던 것처럼 디버거 API를 잘못 사용함으로써 만이 가능하다는 것을 지적하고 싶습니다 . 그래도 바이트 코드를 엉망으로 만들어야합니다.

---

나는 공식적인 파이썬 디자인 및 역사 FAQ 에서 이것을 발견했다 .

왜 고토가 없습니까?

예외를 사용하여 함수 호출에서도 작동하는 "구조화 된 이동"을 제공 할 수 있습니다. 많은 사람들은 예외가 C, Fortran 및 기타 언어의 "go"또는 "goto"구문을 합리적으로 사용하는 것을 편리하게 모방 할 수 있다고 생각합니다. 예를 들면 다음과 같습니다.

class label(Exception): pass  # declare a label

try:
    ...
    if condition: raise label()  # goto label
    ...
except label:  # where to goto
    pass
... 

이것은 당신이 루프의 한가운데로 뛰어들 수는 없지만, 어쨌든 goto의 남용으로 간주됩니다. 드물게 사용하십시오.

공식 FAQ에 언급되어 있으며 훌륭한 솔루션 샘플이 제공되어 매우 기쁩니다. 나는 커뮤니티가 이것 goto처럼 취급하기 때문에 파이썬을 정말로 좋아 합니다.)

---

의견에서의 제안을 사용하여 @ascobol의 질문에 대답하려면 @bobince:

for i in range(5000):
    for j in range(3000):
        if should_terminate_the_loop:
           break
    else: 
        continue # no break encountered
    break

else블록 의 들여 쓰기 가 정확합니다. else루프 파이썬 구문 후에 코드가 모호하게 사용 됩니다. 파이썬이 for 및 while 루프 후에 왜 'else'를 사용합니까?를 참조하십시오 .

---

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"

말할 필요없이. 예, 재미 있지만 사용하지 마십시오.

---

레이블 break과는 continue제안 된 PEP 3136 2007 년에 다시 있지만 거부되었습니다. 제안 의 동기 부여 섹션은 break파이썬으로 라벨이 붙어 있는 모방을위한 몇 가지 일반적인 방법을 보여줍니다 .

---

일부 작업으로 파이썬에 'goto'와 같은 문장을 추가하는 것은 기술적으로 가능합니다. "dis"및 "new"모듈을 사용하여 파이썬 바이트 코드를 스캔하고 수정하는 데 매우 유용합니다.

구현의 주요 아이디어는 먼저 "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()

이것이 질문에 대답하기를 바랍니다.

---

사용자 정의 예외 를 사용 하여 에뮬레이션 할 수 있습니다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()

---

나는 비슷한 것을 찾고 있었다

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

---

There is now. goto

I think this might be useful for what you are looking for.

---

I wanted the same answer and I didnt want to use goto. So I used the following example (from 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)

---

I have my own way of doing gotos. I use separate python scripts.

If I want to loop:

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")

(NOTE: This technique only works on Python 2.x versions)

---

For a forward Goto, you could just add:

while True:
  if some condition:
    break
  #... extra code
  break # force code to exit. Needed at end of while loop
#... continues here

This only helps for simple scenarios though (i.e. nesting these would get you into a mess)

---

In lieu of a python goto equivalent I use the break statement in the following fashion for quick tests of my code. This assumes you have structured code base. The test variable is initialized at the start of your function and I just move the "If test: break" block to the end of the nested if-then block or loop I want to test, modifying the return variable at the end of the code to reflect the block or loop variable I'm testing.

def x:
  test = True
  If y:
     # some code
     If test:
            break
  return something

---

no there is an alternative way to implement goto statement

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

Tested on Python 2.6 through 3.6 and PyPy.

Link: goto-statement

---

foo.py

from goto import with_goto

@with_goto
def bar(start, stop):

    label .bar_begin

    ...

    goto .bar_begin

참고URL : https://stackoverflow.com/questions/438844/is-there-a-label-goto-in-python