Gibt es ein Label / Goto in Python?

Python bietet Ihnen die Fähigkeit zu tun, einige der Dinge, die Sie tun könnten, mit ein goto mit first-class-Funktionen. Zum Beispiel:

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

    label1:
        ...
    label2:
        ...
}

Kann man in python so:

def func1():
    ...

def func2():
    ...

funcmap = {1 : func1, 2 : func2}

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

Zugegeben, das ist nicht der beste Weg, um Ersatz für goto. Aber ohne genau zu wissen was Sie zu tun versuchen, mit goto, es ist schwer zu geben, spezifische Beratung.

@ascobol:

Ihre beste Wette ist, um entweder schließen Sie es in eine Funktion, oder verwenden Sie eine Ausnahme. Für die Funktion:

def loopfunc():
    while 1:
        while 1:
            if condition:
                return

Für die Ausnahme:

try:
    while 1:
        while 1:
            raise BreakoutException #Not a real exception, invent your own
except BreakoutException:
    pass

Mit Ausnahmen zu tun Sachen wie diese kann sich ein wenig umständlich, wenn Sie kommen aus einer anderen Programmiersprache. Aber ich würde argumentieren, dass, wenn Sie nicht mögen, mit Ausnahmen, die Python ist nicht die Sprache für Sie. 🙂

InformationsquelleAutor der Antwort Jason Baker

Antwort auf die @ascobol's Frage mit @bobince's Vorschlag aus den Kommentaren:

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

Den Einzug der else block korrekt ist. Der code verwendet obskuren else nach einer Schleife Python-syntax. Sehen Warum funktioniert die python verwenden 'else' nach for-und while-Schleifen?

InformationsquelleAutor der Antwort jfs

Einer funktionierenden version gemacht wurde: http://entrian.com/goto/.

Hinweis: Es wurde angeboten, als ein April-Scherz. (funktioniert aber)

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

Unnötig zu sagen. Ja, es ist lustig, aber verwenden Sie es nicht.

InformationsquelleAutor der Antwort harmv

Ist es technisch möglich, hinzufügen einer 'gehe zu' like-Anweisung verwendet, um python mit etwas Arbeit. Wir verwenden das "dis" und "neue" Module, die beide sehr nützlich für das Scannen und ändern von python byte-code.

Die Haupt-Idee hinter der Umsetzung ist zunächst markieren Sie einen block von code mithilfe von "goto" und "label" - Aussagen. Eine Besondere "@goto" Dekorator wird verwendet für den Zweck der Kennzeichnung "goto" - Funktionen. Danach Scannen wir den code für diese beiden Anweisungen und wenden Sie die erforderlichen änderungen an den zugrunde liegenden byte-code. Dies alles geschieht unter source code compile-Zeit.

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

Hoffe, das beantwortet die Frage.

InformationsquelleAutor der Antwort Rabih Kodeih

können Sie Benutzer-definierte Ausnahmen zu emulieren goto

Beispiel:

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

InformationsquelleAutor der Antwort xavierskip

Es jetzt ist. springen

Ich denke, das könnte nützlich sein für das, was Sie suchen.

InformationsquelleAutor der Antwort ancho

In Python goto-Anweisung wird unterstützt mit goto .<label_name> und label .<label_name>. Für mehr info gehen Sie bitte über diesen link.

def func():
    resp = call_something()
    if resp != 0: # Failure case
        goto .failure_handler

    ....
    ....
    resp = ....
    if resp != 0: # Failure case
        goto .failure_handler

    ....
    ....    

    label .failure_handler
    cleanup
    return -1   

In der Regel alle über den Planeten, Menschen empfehlen, vermeiden die Verwendung von goto-Anweisung. Aber ein Fehler Behandlung in einer Funktion behandelt werden kann auch mit nur goto-Anweisung. Auch ich dont bevorzugen die Verwendung von goto anderen als Fehler-handler.

InformationsquelleAutor der Antwort rashok