Python Language
लूप्स

परिचय

वाक्य - विन्यास

• जबकि <बूलियन अभिव्यक्ति>:
• <चर> <iterable> में:
• <चर> सीमा में (<संख्या>):
• <चर> सीमा में (<start_number>, <end_number>):
• <चर> सीमा में (<start_number>, <end_number>, <step_size>):
• i, <वेरिएंट> इन्यूमरेट में (<iterable>): # इंडेक्स के साथ
• जिप में <variable1>, <variable2> के लिए (<iterable1>, <iterable2>):

पैरामीटर

सूचियों में परिवर्तन

एक सूची आप उपयोग कर सकते हैं के माध्यम से पुनरावृति करने के लिए for :

for x in ['one', 'two', 'three', 'four']:
    print(x)

यह सूची के तत्वों को प्रिंट करेगा:

one
two
three
four

range फ़ंक्शन उन संख्याओं को उत्पन्न करता है जो अक्सर लूप के लिए उपयोग किए जाते हैं।

for x in range(1, 6):
    print(x)

परिणाम एक विशेष श्रेणी अनुक्रम प्रकार होगा अजगर में = = 3 और अजगर में एक सूची <= 2। लूप के लिए उपयोग करके दोनों को लूप किया जा सकता है।

1
2
3
4
5

यदि आप किसी सूची के दोनों तत्वों को लूप करना चाहते हैं और साथ ही तत्वों के लिए एक इंडेक्स है, तो आप पायथन enumerate फ़ंक्शन का उपयोग कर सकते हैं:

for index, item in enumerate(['one', 'two', 'three', 'four']):
    print(index, '::', item)

enumerate tuples उत्पन्न करेगा, जो index (एक पूर्णांक) और item (सूची से वास्तविक मूल्य) में अनपैक्ड है। ऊपर का लूप छपेगा

(0, '::', 'one')
(1, '::', 'two')
(2, '::', 'three')
(3, '::', 'four')

map और lambda का उपयोग करके मान हेरफेर के साथ एक सूची से अधिक सूची में, यानी सूची में प्रत्येक तत्व पर लैम्ब्डा फ़ंक्शन लागू करें:

x = map(lambda e :  e.upper(), ['one', 'two', 'three', 'four'])
print(x)

आउटपुट:

['ONE', 'TWO', 'THREE', 'FOUR'] # Python 2.x

नायब: पायथन 3.x map सूची के बजाय एक पुनरावृत्तिकर्ता को लौटाता है ताकि आप मामले में आपको एक सूची की आवश्यकता हो जो आपको परिणाम print(list(x)) डाली जाए (देखें http://www.riptutorial.com/python/ उदाहरण / 8186 / map-- http://www.riptutorial.com/python/topic/809/incompatibilities-moving-from-python-2-to-python-3 में )।

छोरों के लिए

लूप के for आइटम्स के संग्रह पर पुनरावृति, जैसे कि list या dict , और संग्रह से प्रत्येक तत्व के साथ कोड का एक ब्लॉक चलाना।

for i in [0, 1, 2, 3, 4]:
    print(i)

लूप के for उपरोक्त संख्याओं की सूची पर आधारित है।

प्रत्येक पुनरावृत्ति सूची के अगले तत्व के लिए i का मान निर्धारित करता है। तो पहले यह 0 होगा, फिर 1 , फिर 2 , आदि। आउटपुट निम्नानुसार होगा:

0  
1
2
3
4

range एक फ़ंक्शन है जो एक पुनरावृत्त रूप में संख्याओं की एक श्रृंखला लौटाता है, इस प्रकार इसका उपयोग लूप के for किया जा सकता है:

for i in range(5):
    print(i)

लूप के for पहले जैसा ही परिणाम देता है। ध्यान दें कि 5 प्रिंट नहीं किया गया है क्योंकि यहां की रेंज 0 से गिने जाने वाले पहले पांच नंबर हैं।

Iterable वस्तुओं और पुनरावृत्तियों

लूप के for किसी भी चलने योग्य वस्तु पर पुनरावृति हो सकती है जो एक वस्तु है जो __getitem__ या __iter__ फ़ंक्शन को परिभाषित करती है। __iter__ फ़ंक्शन एक __iter__ लौटाता है, जो एक next फ़ंक्शन के साथ एक ऑब्जेक्ट है जिसका उपयोग __iter__ के अगले तत्व तक पहुंचने के लिए किया जाता है।

ब्रेक और जारी रखें लूप्स में

break बयान

जब एक break स्टेटमेंट एक लूप के अंदर निष्पादित होता है, तो नियंत्रण प्रवाह "लूप" को तुरंत लूप से बाहर कर देता है:

i = 0
while i < 7:
    print(i)
    if i == 4:
        print("Breaking from loop")
        break
    i += 1

break स्टेटमेंट के निष्पादित होने के बाद लूप सशर्त का मूल्यांकन नहीं किया जाएगा। ध्यान दें कि break स्टेटमेंट को केवल छोरों के अंदर , वाक्यात्मक रूप से अनुमति दी जाती है । किसी फ़ंक्शन के अंदर एक break स्टेटमेंट का उपयोग उस फ़ंक्शन को छोरों को समाप्त करने के लिए नहीं किया जा सकता है।

break स्टेटमेंट मिलने पर नंबर 4 तक निम्नलिखित अंकों को निष्पादित करना और लूप बंद हो जाता है:

0
1
2
3
4
Breaking from loop

break स्टेटमेंट का उपयोग लूप के for भी किया जा सकता है, पायथन द्वारा प्रदान किया गया अन्य लूपिंग निर्माण:

for i in (0, 1, 2, 3, 4):
    print(i)
    if i == 2:
        break

इस लूप को छोड़कर अब प्रिंट होता है:

0
1
2

ध्यान दें कि लूप समाप्त होने के बाद से 3 और 4 प्रिंट नहीं किए गए हैं।

यदि एक लूप में कोई else क्लॉज है , तो यह break स्टेटमेंट के माध्यम से लूप समाप्त होने पर निष्पादित नहीं होता है।

continue बयान

एक continue बयान शेष लूप के अगले पुनरावृत्ति पर छोड़ देगा जो वर्तमान ब्लॉक के बाकी हिस्सों को दरकिनार करेगा लेकिन लूप को continue । break साथ, continue केवल लूप के अंदर दिखाई दे सकता है:

for i in (0, 1, 2, 3, 4, 5):
    if i == 2 or i == 4:
        continue
    print(i)

0
1
3
5

ध्यान दें कि 2 और 4 मुद्रित नहीं कर रहे हैं, इस वजह से है continue बजाय पर जारी रखने के लिए की अगले चरण के लिए चला जाता print(i) जब i == 2 या i == 4 ।

स्थिर फंदा

break और continue केवल लूप के एक ही स्तर पर काम करते हैं। निम्न उदाहरण केवल भीतरी से बाहर टूट जाएगा for पाश, नहीं बाहरी while पाश:

while True:
    for i in range(1,5):
        if i == 2:
            break    # Will only break out of the inner loop!

पायथन में एक ही बार में कई स्तरों के लूप को तोड़ने की क्षमता नहीं होती है - यदि यह व्यवहार वांछित है, तो एक या एक से अधिक लूपों को एक फ़ंक्शन में रिफैक्ट करने और return साथ break जगह जाने का तरीका हो सकता है।

एक break रूप में एक फ़ंक्शन के भीतर से return उपयोग करें

return स्टेटमेंट एक फ़ंक्शन से निकलता है, इसके बाद आने वाले कोड को निष्पादित किए बिना।

यदि आपके पास किसी फ़ंक्शन के अंदर एक लूप है, तो उस लूप के अंदर से return का उपयोग break बराबर है क्योंकि लूप के बाकी कोड को निष्पादित नहीं किया जाता है ( ध्यान दें कि लूप के बाद किसी भी कोड को निष्पादित नहीं किया जाता है ):

def break_loop():
    for i in range(1, 5):
        if (i == 2):
            return(i)
        print(i)
    return(5)

यदि आपके पास नेस्टेड लूप हैं, तो return स्टेटमेंट सभी लूप को तोड़ देगा:

def break_all():
    for j in range(1, 5):
        for i in range(1,4):
            if i*j == 6:
                return(i)
            print(i*j)

उत्पादन होगा:

1 # 1*1
2 # 1*2
3 # 1*3
4 # 1*4
2 # 2*1
4 # 2*2
# return because 2*3 = 6, the remaining iterations of both loops are not executed

"और" खंड के साथ लूप्स

के for और while यौगिक कथनों (छोरों) वैकल्पिक रूप से एक else खंड (व्यवहार में, यह उपयोग काफी दुर्लभ है) हो सकता है।

else खंड केवल एक के बाद निष्पादित करता है for पूरा करने पुनरावृत्ति द्वारा पाश समाप्त, या एक के बाद while इसकी सशर्त अभिव्यक्ति द्वारा पाश समाप्त झूठी हो रहा है।

for i in range(3):
    print(i)
else:
    print('done')

i = 0
while i < 3:
    print(i)
    i += 1
else:
    print('done')

उत्पादन:

 0
 1
 2
 done

यदि क्लॉज किसी अन्य तरीके से ( break स्टेटमेंट के माध्यम से या अपवाद को बढ़ाकर) समाप्त हो जाता है, तो else खंड निष्पादित नहीं होता है:

for i in range(2):
    print(i)
    if i == 1:
        break
else:
    print('done')

उत्पादन:

0
1

अधिकांश अन्य प्रोग्रामिंग भाषाओं यह वैकल्पिक कमी else छोरों के खंड। कीवर्ड के उपयोग else विशेष रूप से अक्सर भ्रमित माना जाता है।

इस तरह के एक खंड दिनांकों मूल अवधारणा डोनाल्ड नुथ को लेने और का अर्थ else अगर हम के मामले में एक पाश पुनर्लेखन कीवर्ड स्पष्ट हो जाता है if बयान और goto संरचित प्रोग्रामिंग पहले या एक निचले स्तर विधानसभा भाषा से पहले दिन से बयान।

उदाहरण के लिए:

while loop_condition():
    ...
    if break_condition():
        break
    ...

के बराबर है:

# pseudocode

<<start>>:
if loop_condition():
    ...
    if break_condition():
        goto <<end>>
    ...
    goto <<start>>

<<end>>:

अगर हम उनमें से प्रत्येक के लिए एक else खंड संलग्न करते हैं तो ये बराबर बने रहते हैं।

उदाहरण के लिए:

while loop_condition():
    ...
    if break_condition():
        break
    ...
else:
    print('done')

के बराबर है:

# pseudocode

<<start>>:
if loop_condition():
    ...
    if break_condition():
        goto <<end>>
    ...
    goto <<start>>
else:
    print('done')

<<end>>:

एक for एक साथ पाश else खंड उसी तरह समझा जा सकता है। वैचारिक रूप से, एक लूप की स्थिति है जो तब तक सही रहती है जब तक चलने योग्य वस्तु या अनुक्रम में अभी भी कुछ शेष तत्व हैं।

कोई इस अजीब निर्माण का उपयोग क्यों करेगा?

के लिए मुख्य उपयोग मामला for...else निर्माण उदाहरण के लिए खोज का संक्षिप्त कार्यान्वयन है:

a = [1, 2, 3, 4]
for i in a:
    if type(i) is not int:
        print(i)
        break
else:
    print("no exception") 

इस निर्माण में else को कम भ्रमित करने के लिए कोई इसे " यदि नहीं तोड़ा " या " नहीं मिला तो " के रूप में सोच सकता है।

इस पर कुछ चर्चाएँ [अजगर-विचारों] के सारांश में मिल सकती हैं ... और धागे , क्यों लूप्स के बाद 'और' का उपयोग करता है? , और लूप स्टेटमेंट्स पर एल्स क्लाज

शब्दकोशों पर बयानबाजी

निम्नलिखित शब्दकोष को ध्यान में रखते हुए:

 d = {"a": 1, "b": 2, "c": 3}

इसकी कुंजियों के माध्यम से पुनरावृत्ति करने के लिए, आप इसका उपयोग कर सकते हैं:

for key in d:
    print(key)

आउटपुट:

"a"
"b"
"c"

यह इसके बराबर है:

for key in d.keys():
    print(key)

या अजगर 2 में:

for key in d.iterkeys():
    print(key)

अपने मूल्यों के माध्यम से पुनरावृत्ति करने के लिए, उपयोग करें:

for value in d.values():
    print(value)

आउटपुट:

1
2
3

अपनी कुंजियों और मूल्यों के माध्यम से पुनरावृत्ति करने के लिए, उपयोग करें:

for key, value in d.items():
    print(key, "::", value)

आउटपुट:

a :: 1
b :: 2
c :: 3

ध्यान दें कि पायथन 2 में, .keys() , .values() और .items() एक list ऑब्जेक्ट लौटाते हैं। यदि आपको परिणाम को गर्त करने की आवश्यकता है, तो आप समतुल्य .iterkeys() , .itervalues() और .iteritems() उपयोग कर सकते हैं।

.keys() और .iterkeys() , .values() और .itervalues() , .items() और .iteritems() बीच अंतर यह है कि iter* विधियाँ जनरेटर हैं। इस प्रकार, शब्दकोश के भीतर तत्वों का मूल्यांकन एक-एक करके किया जाता है क्योंकि उनका मूल्यांकन किया जाता है। जब कोई list ऑब्जेक्ट वापस किया जाता है, तो सभी तत्व सूची में पैक किए जाते हैं और फिर आगे के मूल्यांकन के लिए वापस आ जाते हैं।

यह भी ध्यान दें कि पायथन 3 में, उपरोक्त तरीके से मुद्रित वस्तुओं का ऑर्डर किसी भी आदेश का पालन नहीं करता है।

घुमाव के दौरान

एक while जब तक पाश शर्त है पाश कारण पाश बयान निष्पादित करने के लिए होगा falsey । निम्न कोड लूप स्टेटमेंट्स को कुल 4 बार निष्पादित करेगा।

i = 0 
while i < 4:
    #loop statements
    i = i + 1

जबकि उपरोक्त लूप को आसानी से लूप के for अधिक सुरुचिपूर्ण में अनुवाद किया जा सकता है, while लूप यह जांचने के लिए उपयोगी है कि क्या कुछ शर्त पूरी हुई है। निम्नलिखित लूप तब तक निष्पादित होता रहेगा जब तक myObject तैयार नहीं हो जाता।

myObject = anObject()
while myObject.isNotReady():
    myObject.tryToGetReady()

while लूप नंबर (जटिल या वास्तविक) या True का उपयोग करके किसी शर्त के बिना भी चल सकते हैं:

import cmath

complex_num = cmath.sqrt(-1)
while complex_num:      # You can also replace complex_num with any number, True or a value of any type
    print(complex_num)   # Prints 1j forever

यदि स्थिति हमेशा सही होती है जबकि लूप हमेशा के लिए चलेगा (अनंत लूप) अगर यह ब्रेक या रिटर्न स्टेटमेंट या अपवाद से समाप्त नहीं होता है।

while True:
    print "Infinite loop"
# Infinite loop
# Infinite loop
# Infinite loop
# ...

दर्रा बयान

pass एक शून्य कथन है, जब पायथन सिंटैक्स (जैसे कि एक के for या while लूप के शरीर के भीतर) द्वारा एक बयान की आवश्यकता होती है, लेकिन प्रोग्रामर द्वारा कोई कार्रवाई आवश्यक या वांछित नहीं है। यह कोड के लिए प्लेसहोल्डर के रूप में उपयोगी हो सकता है जिसे लिखा जाना बाकी है।

for x in range(10):
    pass #we don't want to do anything, or are not ready to do anything here, so we'll pass

इस उदाहरण में, कुछ भी नहीं होगा। लूप के for त्रुटि के बिना पूरा हो जाएगा, लेकिन कोई आदेश या कोड कार्रवाई नहीं होगी। pass हमें सभी आदेशों और कार्रवाई को पूरी तरह से कार्यान्वित किए बिना सफलतापूर्वक अपना कोड चलाने की अनुमति देता है।

इसी तरह, pass में इस्तेमाल किया जा सकता while छोरों, साथ ही चयन और कार्यशील परिभाषाएँ आदि में

while x == y:
    pass

किसी सूची के अलग-अलग हिस्से को अलग-अलग चरण के आकार के साथ बदलना

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

यहां एक सरल सूची दी गई है जिसका उपयोग पूरे उदाहरणों में किया जाएगा:

lst = ['alpha', 'bravo', 'charlie', 'delta', 'echo']

पूरी सूची में बदलाव

पुनरावृत्ति करने के लिए सूची में प्रत्येक तत्व पर, एक for नीचे की तरह पाश इस्तेमाल किया जा सकता:

for s in lst:
    print s[:1] # print the first letter

for पाश प्रदान करती है के प्रत्येक तत्व के लिए रों lst । यह प्रिंट करेगा:

a
b
c
d
e

अक्सर आपको उस तत्व के तत्व और सूचकांक दोनों की आवश्यकता होती है। enumerate कीवर्ड वह कार्य करता है।

for idx, s in enumerate(lst):
    print("%s has an index of %d" % (s, idx))

सूचकांक idx प्रत्येक पुनरावृत्ति के लिए शून्य और वेतन वृद्धि के साथ शुरू होगा, जबकि s में तत्व शामिल होगा। पिछले स्निपेट का उत्पादन होगा:

alpha has an index of 0
bravo has an index of 1
charlie has an index of 2
delta has an index of 3
echo has an index of 4

उप-सूची में Iterate

यदि हम एक सीमा पर चलना चाहते हैं (यह याद करते हुए कि पायथन शून्य-आधारित अनुक्रमण का उपयोग करता है), range खोजशब्द का उपयोग करें।

for i in range(2,4):
    print("lst at %d contains %s" % (i, lst[i]))

यह आउटपुट होगा:

lst at 2 contains charlie
lst at 3 contains delta

सूची भी कटा हुआ हो सकता है। निम्नलिखित टुकड़ा अंकन 2. के एक कदम दो के साथ अंत करने के लिए इंडेक्स को 1 पर तत्व से चला जाता है for छोरों एक ही परिणाम दे।

for s in lst[1::2]:
    print(s)

for i in range(1, len(lst), 2):
    print(lst[i])

उपरोक्त स्निपेट आउटपुट:

bravo
delta

अनुक्रमण और स्लाइसिंग स्वयं का एक विषय है।

"आधा लूप" करते-करते

अन्य भाषाओं के विपरीत, पायथन में एक ऐसा नहीं है, जब तक या एक करते समय निर्माण नहीं होता है (यह स्थिति का परीक्षण करने से पहले कोड को एक बार निष्पादित करने की अनुमति देगा)। हालाँकि, आप एक ही उद्देश्य को प्राप्त करने के लिए एक break साथ while True को जोड़ सकते हैं।

a = 10
while True:
    a = a-1
    print(a)
    if a<7:
        break
print('Done.')

यह प्रिंट करेगा:

9
8
7
6
Done.

लूपिंग और अनपैकिंग

यदि आप उदाहरण के लिए टुपल्स की सूची पर लूप करना चाहते हैं:

collection = [('a', 'b', 'c'), ('x', 'y', 'z'), ('1', '2', '3')]

ऐसा कुछ करने के बजाय:

for item in collection:
    i1 = item[0]
    i2 = item[1]
    i3 = item[2]
    # logic

या इस तरह का कुछ:

for item in collection:
    i1, i2, i3 = item
    # logic

आप बस यह कर सकते हैं:

for i1, i2, i3 in collection:
    # logic

यह केवल ट्यूपल्स नहीं बल्कि अधिकांश प्रकार के पुनरावृत्तियों के लिए भी काम करेगा।