क्या पायथन में एक लेबल / गोटो है?

Question

क्या gotoपायथन में कोई या कोई समकक्ष है जो कोड की एक विशिष्ट रेखा पर कूदने में सक्षम है?

Comments

लेबल बहुत अस्पष्ट है - क्या आप जो खोज रहे हैं उसके बारे में अधिक विशिष्ट हो सकते हैं?

— दाना

आयात गोटो

— विम

मेरे एक मित्र ने gotoपायथन में अमल किया, जब वह कुछ फोरट्रान कोड का अनुवाद पायथन में कर रहा था। वह इसके लिए खुद से नफरत करता था।

— कोडी पियर्सल

github.com/cdjc/goto (यह एंट्रियन कार्यान्वयन की तुलना में बहुत तेज़ है)

— cdjc

"लेबल बहुत अस्पष्ट है", कोई भी लेबल बुद्धिमान नहीं है, संरचित एक मशीन की तरह काम कर रहा है

— डेटिनहॉक

Answer 1

नहीं, पायथन लेबल और गोटो का समर्थन नहीं करता है, यदि ऐसा है तो आप उसके बाद हैं। यह (अत्यधिक) संरचित प्रोग्रामिंग भाषा है।

Comments

@rejinacm फ़ंक्शन?

— अनवेकटेक

Answer 2

पायथन आपको कुछ चीजों को करने की क्षमता प्रदान करता है जो आप प्रथम श्रेणी के कार्यों का उपयोग करके एक गोटो के साथ कर सकते हैं। उदाहरण के लिए:

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.

दी, कि गोटो के लिए सबसे अच्छा तरीका नहीं है। लेकिन यह जानने के बिना कि आप गोटो के साथ क्या करने की कोशिश कर रहे हैं, विशिष्ट सलाह देना कठिन है।

@ 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

यदि आप किसी अन्य प्रोग्रामिंग भाषा से आते हैं तो इस तरह से सामान का उपयोग करना थोड़ा अजीब लग सकता है। लेकिन मेरा तर्क है कि यदि आप अपवादों का उपयोग करना पसंद करते हैं, तो पायथन आपके लिए भाषा नहीं है। :-)

Comments

इसका विवेकपूर्ण उपयोग करें। पायथन में अपवाद अधिकांश अन्य भाषाओं की तुलना में तेज़ हैं। लेकिन अगर आप उनके साथ पागल हो जाते हैं, तब भी वे धीमे हैं।

— जेसन बेकर

बस एक सूचना: loopfuncआम तौर पर इनपुट की आवश्यकता होती है और लागू करने के लिए कुछ और प्रयास करने होते हैं, लेकिन मुझे लगता है कि ज्यादातर मामलों में यह सबसे अच्छा तरीका है।

— कोन साइक

Answer 3

मैंने हाल ही में एक फंक्शन डेकोरेटर लिखा है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 का दुरुपयोग करके, जैसा कि दूसरे लड़के ने किया था। आपको हालांकि बायोटेक के साथ गड़बड़ करना होगा।

Comments

महान सज्जाकार आपने बनाया! बहुत बढ़िया कि आप किस तरह से बाइटकोड के साथ

— फीका पड़

मुझे लगता है, इस प्रश्न के लिए यह स्वीकृत उत्तर होना चाहिए। यह कई नेस्टेड छोरों के लिए उपयोगी हो सकता है, क्यों नहीं?

— PiMathCLanguage

क्या यह केवल समर्थन .beginऔर .endलेबल करता है?

— अलेक्सेज मागुरा

Answer 4

मुझे यह आधिकारिक अजगर डिजाइन और इतिहास FAQ में मिला ।

कोई गोटो क्यों नहीं है?

आप "संरचित गोटो" प्रदान करने के लिए अपवादों का उपयोग कर सकते हैं जो फ़ंक्शन कॉल में भी काम करता है। कई लोग महसूस करते हैं कि अपवाद सी, फोरट्रान और अन्य भाषाओं के "गो" या "गोटो" निर्माणों के सभी उचित उपयोगों का आसानी से अनुकरण कर सकते हैं। उदाहरण के लिए:

class label(Exception): pass  # declare a label

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

यह आपको लूप के बीच में कूदने की अनुमति नहीं देता है, लेकिन आमतौर पर इसे गोटो का दुरुपयोग माना जाता है। किफायत से इस्तेमाल करो।

यह बहुत अच्छा है कि आधिकारिक एफएक्यू में भी इसका उल्लेख किया गया है, और यह एक अच्छा समाधान नमूना प्रदान किया गया है। मैं वास्तव में अजगर को पसंद करता हूं क्योंकि उसका समुदाय gotoइस तरह से भी इलाज कर रहा है;)

Comments

गाली देना gotoएक प्रमुख प्रोग्रामिंग फॉक्स पैस है, लेकिन यह सुनिश्चित करने के लिए कि आईएमओ का दुरुपयोग करने के अपवाद gotoकेवल थोड़े बेहतर हैं और फिर भी उन पर भारी असर पड़ना चाहिए। मैं नहीं बल्कि पायथन रचनाकारों gotoको कुछ अवसरों के लिए भाषा में शामिल करना चाहिए जहां यह वास्तव में इसे अस्वीकार करने की तुलना में उपयोगी है क्योंकि "यह बुरा है, दोस्तों" और फिर समान कार्यक्षमता (और समान कोड स्पैगेट्रीफिकेशन) प्राप्त करने के लिए अपवादों का दुरुपयोग करने की सलाह देते हैं।

— Abion47

Answer 5

टिप्पणियों से सुझाव का उपयोग करते हुए @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लूप पायथन सिंटैक्स के बाद अस्पष्ट का उपयोग करता है । देखें कि छोरों के लिए अजगर 'और ’का उपयोग क्यों करता है?

Comments

मैंने आपके अन्य ब्लॉक इंडेंट को ठीक कर दिया, जिसके कारण एक दिलचस्प खोज हुई :

— ब्रैडेन बेस्ट

@ B1KMusic: इंडेंट सही है। यह एक विशेष पायथन सिंटैक्स है। लूप के बादelse निष्पादित किया गया है यदि breakसामना नहीं किया गया है। प्रभाव यह है कि आंतरिक और बाहरी दोनों छोरों को should_terminate_the_loopसमाप्त करता है।

— 16

मुझे यह निर्दिष्ट करना चाहिए कि मैंने संपादन करने के बाद केवल उस खोज को बनाया है। इससे पहले, मुझे लगा कि मैंने दुभाषिया में एक बग की खोज की है, इसलिए मैंने परीक्षण मामलों का एक गुच्छा बनाया और यह समझने के लिए कुछ शोध किया कि क्या चल रहा था। उसके लिए माफ़ करना।

— ब्रैडेन बेस्ट

अब जब मैं समझ गया कि क्या चल रहा है, तो मैं मानता हूं, यह कुछ गूढ़ कूट है जो अधिक पारंपरिक तरीकों

— ब्रैडेन बेस्ट

@ B1KMusic: अपने अज्ञान को हल करने के लिए कोड डुप्लिकेटिंग एक अच्छा समाधान नहीं है। हाँ। return @ जैसन बेकर द्वारा सुझाया गया , गहरी नेस्टेड छोरों को तोड़ने का एक अच्छा विकल्प है।

— 16

Answer 6

एक कार्यशील संस्करण बनाया गया है: 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"

कहने की आवश्यकता नहीं। हाँ, यह मज़ेदार है, लेकिन इसका उपयोग न करें।

Comments

मुझे 3 ब्रेक का उपयोग करने से बेहतर लगता है ... निश्चित रूप से इसे लिखने के अन्य तरीके भी हैं।

— निक

@ रिटर्न के साथ फंक्शन का उपयोग ज्यादा बेहतर लगता है।

— एरिक Eastný

Answer 7

2007 में PEP 3136 के लिए लेबल breakऔर continueप्रस्तावित किए गए थे , लेकिन इसे अस्वीकार कर दिया गया था। प्रस्ताव का प्रेरणा अनुभाग पायथन में लेबल की नकल के लिए कई सामान्य (यदि अयोग्य हो) तरीकों को दिखाता है ।break

Answer 8

यह तकनीकी रूप से संभव है कि कुछ कार्यों के साथ अजगर को 'गोटो' जैसा बयान दिया जाए। हम "डिस" और "नए" मॉड्यूल का उपयोग करेंगे, दोनों अजगर बाइट कोड को स्कैन और संशोधित करने के लिए बहुत उपयोगी हैं।

कार्यान्वयन के पीछे मुख्य विचार पहले कोड के एक ब्लॉक को "गोटो" और "लेबल" स्टेटमेंट का उपयोग करके चिह्नित करना है। "गोटो" कार्यों को चिह्नित करने के उद्देश्य से एक विशेष "@गो" डेकोरेटर का उपयोग किया जाएगा। बाद में हम इन कोड को इन दो कथनों के लिए स्कैन करते हैं और अंतर्निहित बाइट कोड के लिए आवश्यक संशोधन लागू करते हैं। यह सब स्रोत कोड संकलन समय पर होता है।

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

आशा है कि यह प्रश्न का उत्तर देगा।

Answer 9

आप अनुकरण करने के लिए उपयोगकर्ता-परिभाषित अपवाद का उपयोग कर सकते हैं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()

Comments

बहुत बढ़िया विधि लेकिन क्या हम स्ट्रेट अपवाद m विधि को म्यूट कर सकते हैं

— अनाम

@ कौन सा अपवाद? आप python3 का उपयोग करते हैं?

— xavierskip

Answer 10

अजगर 2 और 3

pip3 install goto-statement

3.6 और PyPy के माध्यम से पायथन 2.6 पर परीक्षण किया गया।

लिंक: गोटो-स्टेटमेंट

---

foo.py

from goto import with_goto

@with_goto
def bar():

    label .bar_begin

    ...

    goto .bar_begin

Answer 11

मैं कुछ इसी तरह की चीज की तलाश में था

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

Answer 12

वहां है अभी। के लिए जाओ

मुझे लगता है कि यह आपके लिए उपयोगी हो सकता है।

Answer 13

मैं एक ही जवाब चाहता था और मैं उपयोग नहीं करना चाहता था 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)

Answer 14

मेरे पास गोट्स करने का अपना तरीका है। मैं अलग अजगर लिपियों का उपयोग करता हूं।

अगर मुझे लूप चाहिए:

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

( नोट: यह तकनीक केवल पायथन 2.x संस्करणों पर काम करती है)

Answer 15

आगे गोटो के लिए, आप बस जोड़ सकते हैं:

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

हालांकि यह केवल सरल परिदृश्यों के लिए मदद करता है (यानी घोंसले के शिकार आपको एक गड़बड़ में मिलेगा)

Answer 16

एक अजगर गोटो समतुल्य के बदले में मैं अपने कोड के त्वरित परीक्षणों के लिए निम्नलिखित कथन में ब्रेक स्टेटमेंट का उपयोग करता हूं। यह मानता है कि आपके पास संरचित कोड आधार है। परीक्षण चर को आपके फ़ंक्शन के प्रारंभ में आरंभीकृत किया जाता है और मैं अभी "नेड टेस्ट: ब्रेक" ब्लॉक को नेस्टेड के अंत में ब्लॉक करता हूं अगर-तब ब्लॉक या लूप जिसे मैं परीक्षण करना चाहता हूं, कोड के अंत में रिटर्न चर को संशोधित करना मैं परीक्षण कर रहा हूँ ब्लॉक या लूप चर को प्रतिबिंबित करने के लिए।

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

Answer 17

हालांकि goto/labelपायथन में कोई भी कोड समान नहीं है , फिर भी आप goto/labelलूप का उपयोग करने की ऐसी कार्यक्षमता प्राप्त कर सकते हैं ।

नीचे दिखाए गए कोड का नमूना लेते हैं जहां goto/labelअजगर के अलावा किसी अन्य भाषा में इस्तेमाल किया जा सकता है।

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नीचे दिखाए गए लूप का उपयोग करके अजगर में प्राप्त की जा सकती है ।

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...')

Answer 18

नहीं, गोटो स्टेटमेंट को लागू करने का कोई वैकल्पिक तरीका नहीं है

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