Python Loops Tutorial

For लूप

आप for लूप को भी उसी तरह से समझ सकते हैं जैसे while लूप को। जैसा कि आप उम्मीद करेंगे, "for" घटक उस चीज़ को संदर्भित करता है जिसे आप एक निश्चित संख्या बार करते हैं।

उपरोक्त सभी बातों को ध्यान में रखते हुए, आप for लूप को इस प्रकार परिभाषित कर सकते हैं:

for लूप एक प्रोग्रामिंग अवधारणा है जो लागू होने पर किसी अनुक्रम के आधार पर एक निश्चित संख्या बार किसी कोड के हिस्से को बार‑बार चलाती है।

while लूप के विपरीत, यहाँ कोई सक्रिय शर्त शामिल नहीं होती — आप बस किसी कोड को कुछ बार चलाते हैं। दूसरे शब्दों में, जहाँ while लूप तब तक अपने भीतर के कोड ब्लॉक को चलाता रहता है जब तक शर्त True रहती है, वहीं for लूप अपने भीतर के कोड को केवल एक विशिष्ट संख्या बार चलाता है। यह "बार की संख्या" किसी अनुक्रम या चीज़ों की क्रमबद्ध सूची द्वारा तय होती है।

आप थोड़ी देर में while और for लूप्स के बीच का अंतर और सीखेंगे, पर अभी के लिए, उन टुकड़ों पर ध्यान दें जिनकी आपको for लूप बनाने के लिए ज़रूरत होती है:

• for कीवर्ड
• एक चर
• in कीवर्ड
• range() फ़ंक्शन, जो Python लाइब्रेरी में संख्याओं का अनुक्रम बनाने के लिए एक बिल्ट‑इन फ़ंक्शन है
• वह कोड जिसे आप बार‑बार चलाना चाहते हैं

Python में For लूप्स

# Print "Thank you" 5 times
for number in range(5):
    print("Thank you")

# Thank you
# Thank you
# Thank you
# Thank you
# Thank youसंचालित द्वारा

जैसा कि आप देख सकते हैं, ऊपर वाले सेक्शन में जिन घटकों को आपने देखा था, वे इस छोटे से for लूप उदाहरण में मौजूद हैं: for कीवर्ड, number चर, in कीवर्ड, range() फ़ंक्शन और वह कोड जिसे आप कई बार चलाना चाहते हैं, print("Thank you")।

यह कठिन नहीं है, है ना?

चलिए for लूप का एक और उदाहरण देखते हैं, जहाँ आप नियंत्रण प्रवाह को परिभाषित करने के लिए दो चरों का उपयोग करते हैं:

languages = ['R', 'Python',  'Scala', 'Java', 'Julia']

for index in range(len(languages)):
   print('Current language:', languages[index])

# Current language: R
# Current language: Python
# Current language: Scala
# Current language: Java
# Current language: Juliaसंचालित द्वारा

जैसा कि आप देख सकते हैं, आप लूप को for कीवर्ड से शुरू करते हैं। अगला, आप index और languages चरों, in कीवर्ड, और संख्याओं का अनुक्रम बनाने के लिए range() फ़ंक्शन का उपयोग करते हैं। अतिरिक्त रूप से, आप यह भी देखते हैं कि इस मामले में len() फ़ंक्शन का उपयोग होता है, क्योंकि languages सूची संख्यात्मक नहीं है। वह कोड जिसे आप बार‑बार चलाना चाहते हैं, एक प्रिंट स्टेटमेंट है, यानी print('Current language :', languages[index])।

ऊपर वाले लूप में, आपका आशय यह व्यक्त करना है कि len(languages) की रेंज के हर इंडेक्स के लिए, आप डेटा साइंस प्रोग्रामिंग भाषा को प्रिंट करना चाहते हैं। अब, len(languages) 5 है, तो यह स्टेटमेंट इस प्रकार भी लिखा जा सकता है:

for index in range(5):
    print('Current language:', languages[index])

# Current language: R
# Current language: Python
# Current language: Scala
# Current language: Java
# Current language: Juliaसंचालित द्वारा

और इससे भी आपको वही परिणाम मिलता है!

Python में While बनाम For लूप्स

आइए एक बार फिर सबसे पहले वाले while लूप उदाहरण पर लौटते हैं ताकि हम ठीक‑ठीक निर्धारित कर सकें कि while और for लूप्स में अंतर क्या है। आपने ऊपर पढ़ा कि अंतर उस शर्त में निहित है जो शामिल है या नहीं, लेकिन यह कोड में कैसे दिखता है और आप दोनों के बीच कैसे स्विच कर सकते हैं?

# Take user input
number = 2  

while number < 5 :
    print("Thank you")
    # Increment `number` by 1
    number = number+1

# Thank you
# Thank you
# Thank youसंचालित द्वारा

आप समान कथन "Thank you" को अधिक नियंत्रित ढंग से प्रिंट करने के लिए for लूप का उपयोग कर सकते हैं:

# Print "Thank you" 3 times
for number in range(3) :  
    print("Thank you")

# Thank you
# Thank you
# Thank youसंचालित द्वारा

देखा कि while लूप को समतुल्य for लूप में बदलना कितना आसान था?

यह कैसे काम करता है, आप पूछते हैं? सरल है।

for लूप में, range फ़ंक्शन के अंदर दिया गया पूर्णांक वही रेंज या बार की संख्या है जितनी बार नियंत्रण को लूप करना और for लूप के क्लॉज़ के भीतर का कोड चलाना है।

ध्यान दें कि range() फ़ंक्शन की गिनती 0 से शुरू होती है, 1 से नहीं। इसका मतलब है कि, ऊपर के उदाहरण में, गिनती 0,1,2 होगी, 1,2,3 नहीं। कंप्यूटर की मेमोरी में यही तरीके से गिनती काम करती है। इसलिए, for लूप डिजाइन करते समय हमेशा ध्यान रखें कि आपको रेंज की गिनती 0 से माननी है, 1 से नहीं।

टिप: Python में सूचियों के लिए भी यही बात लागू होती है, उदाहरण के लिए। अगर आप Python लिस्ट्स के बारे में अधिक जानना चाहते हैं, तो DataCamp का 18 Most Common Python List Questions ट्यूटोरियल देखें।

अब, for लूप और while लूप के बीच एक और दिलचस्प अंतर है। for लूप while लूप से तेज़ होता है। इसे समझने के लिए आपको नीचे दिए गए उदाहरण को देखना होगा।

import timeit

# A for loop example
def for_loop():
    for number in range(10000) :  
        # Execute the below code 10000 times
        sum = 3+4
        #print(sum)

timeit.timeit(for_loop)

# 267.0804728891719संचालित द्वारा

import timeit

# A while loop example
def while_loop():
    i =0
    while i<10000:
        sum = 3+4
        #print(sum)
        i+=1

timeit.timeit(while_loop)

# 884.9233417965908संचालित द्वारा

ऊपर दिए गए कोड खंड में, आपके पास लगभग 10000 इटरेशन वाले दो लूप्स हैं। पहली नज़र में दोनों एक जैसे दिखते हैं, जब तक कि आप पर्दे के पीछे न देखें और न समझें कि ये दोनों लूप्स कैसे काम करते हैं। संकेत: timeit() फ़ंक्शन आपको अंतर का संकेत देता है!

याद रखें: सारा Python कोड C कंपाइलर से संकलित होता है, जिसका अर्थ है कि ऊपर दिखा कोड पहले बाइट‑कोड्स में तोड़ा जाता है और फिर आधारभूत C कंपाइलर द्वारा प्रोसेस किया जाता है।

ऊपर दिए गए उदाहरण में for लूप का निष्पादन शुरू होने पर, Python इंटरप्रेटर आधारभूत C कंपाइलर से बात करता है और 10000 आकार का एक लिस्ट ऑब्जेक्ट बनाता है। फिर, यह एक इटेरेटर को कॉल करता है ताकि सूची के 10000 आइटम्स के प्रत्येक इंडेक्स पर पहुँचा जा सके।

दूसरी ओर, while लूप का निष्पादन कोई लिस्ट ऑब्जेक्ट नहीं बनाता। वास्तव में, आधारभूत C कंपाइलर शर्त i<10000 के लिए बूलियन तुलना ऑपरेटर को 9999 बार कॉल करता है।

आप कल्पना कर सकते हैं कि 10000 तत्वों वाली पहले से बनी सूची पर इटरेट करना कंपाइलर के लिए 9999 बार बूलियन ऑपरेशन करने की तुलना में आसान है, इसलिए for लूप का समय प्रदर्शन while लूप से बेहतर होता है। यह निष्पादन समय में स्पष्ट रूप से परिलक्षित होता है: for लूप को पूरा होने में लगने वाला समय while लूप की तुलना में काफी कम है।

अब for लूप आज़माएँ! ध्यान दें कि आपको रेंज 0 से 11 तक देनी है, क्योंकि आप अनुक्रम में केवल 55 तक की संख्याएँ दिखाना चाहते हैं, जो कि अनुक्रम की 11वीं संख्या है।

नेस्टेड लूप्स

जैसा कि आप ऊपर के एक उदाहरण में देख सकते हैं, while लूप के अंदर if‑else शर्त है जो आपको अपने कोड में और शर्तें जोड़ने में सक्षम बनाती है।

ज़रा ठहरिए!

यह आपके लूप को अनुकूलित करने का एकमात्र तरीका नहीं है। आप अपने मौजूदा कोड के अंदर और while लूप्स भी शामिल कर सकते हैं और इसे नेस्टेड लूप कहते हैं। आप ऊपर के उदाहरण को संशोधित करके एक और while लूप इस तरह शामिल कर सकते हैं:

# Take user input
number = 2 

# condition of the while loop
while number < 5 :  
    # condition of the nested while loop    
    while number % 2 == 0: 
        print("The number "+ str(number)+" is even")संचालित द्वारा

ऊपर के उदाहरण में एक और while लूप है जो बाहरी लूप के अंदर "नेस्टेड" है, यह आंतरिक लूप एक और जाँच जोड़ता है कि number % (mod) 2 0 है या नहीं।

दूसरे शब्दों में, यह जाँचता है कि संख्या सम है और फिर "The number is even" कथन प्रिंट करता है।

लेकिन एक पेंच है: अगर आप ध्यान से देखें, तो आप देखेंगे कि पिछले कोड की तरह इस बार number=number+1 कथन गायब है। चूँकि आप कहीं भी number चर को बढ़ा नहीं रहे हैं, इसलिए हर बार चर का मान वही रहता है और कोड एक अनंत लूप में चला जाता है। इसका मतलब है कि, एक बार जब यह लूप में प्रवेश करता है, तो यह कभी बाहर नहीं निकलता और कथन को अनंत बार प्रिंट करता है क्योंकि number हमेशा 2 पर सेट रहता है। यह संख्या, बेशक, 5 से कम और एक सम संख्या है।

अब देखते हैं कि नेस्टेड for लूप कैसा दिखेगा:

# Print the below statement 3 times
for number in range(3) :  
    print("-------------------------------------------")
    print("I am outer loop iteration "+str(number))
    # Inner loop
    for another_number in range(5):  
        print("****************************")
        print("I am inner loop iteration "+str(another_number))संचालित द्वारा

-------------------------------------------
I am outer loop iteration 0
****************************
I am inner loop iteration 0
****************************
I am inner loop iteration 1
****************************
I am inner loop iteration 2
****************************
I am inner loop iteration 3
****************************
I am inner loop iteration 4
-------------------------------------------
I am outer loop iteration 1
****************************
I am inner loop iteration 0
****************************
I am inner loop iteration 1
****************************
I am inner loop iteration 2
****************************
I am inner loop iteration 3
****************************
I am inner loop iteration 4
-------------------------------------------
I am outer loop iteration 2
****************************
I am inner loop iteration 0
****************************
I am inner loop iteration 1
****************************
I am inner loop iteration 2
****************************
I am inner loop iteration 3
****************************
I am inner loop iteration 4संचालित द्वारा

ऊपर का कोड पहले वाले for लूप उदाहरण का संशोधित रूप है। ध्यान दें कि बाहरी लूप के अंदर दूसरा for लूप कैसे उपयोग किया गया है।

आगे बढ़ें और कोड चलाएँ।

आप पाएँगे कि नियंत्रण सबसे पहले for लूप में प्रवेश करता है और number चर का मान 0 से आरंभ होता है। पहला प्रिंट स्टेटमेंट प्रिंट होता है, और फिर नियंत्रण दूसरे for लूप में प्रवेश करता है, जहाँ another_number चर का मान 0 से आरंभ होता है। दूसरे for लूप में पहला प्रिंट स्टेटमेंट एक बार प्रिंट होता है।

अब, नियंत्रण फिर से आंतरिक for लूप में लौटता है और another_number का मान फिर अगले पूर्णांक पर सेट होता है तथा print() फ़ंक्शन के अंदर का कथन प्रिंट होता है।

उपरोक्त प्रक्रिया तब तक चलती रहती है जब तक कि नियंत्रण range() फ़ंक्शन के अंत तक न पहुँच जाए, जो इस मामले में 5 है, और फिर नियंत्रण सबसे बाहरी लूप पर लौटता है, number चर को अगले पूर्णांक पर आरंभ करता है, print() फ़ंक्शन के अंदर का कथन प्रिंट करता है, आंतरिक लूप पर जाता है और फिर ऊपर बताये गए सभी चरणों को तब तक दोहराता है जब तक कि range() फ़ंक्शन पार न हो जाए।

यह यात्रा, जहाँ नियंत्रण सबसे बाहरी लूप से आंतरिक लूप तक जाता है और फिर वापस बाहरी for लूप पर आता है, तब तक जारी रहती है जब तक नियंत्रण पूरी रेंज को कवर नहीं कर लेता, जो आपके मामले में 3 बार है।

अब जब आपने नेस्टेड लूप्स पर कुछ व्याख्याएँ पढ़ ली हैं, तो अब आपकी बारी है! नेस्टेड for लूप का उपयोग करके निम्नलिखित पैटर्न बनाने के लिए एक Python प्रोग्राम लिखें:

# Initialize the first five rows
n = _

# Start the loop to print the first five rows
for i in range(_):
    for j in range(i):
        print('* ', end="")
    print('')

# Start the loop to print the remaining rows in decreasing order of stars
for i in range(n,0,-1):
    for j in range(_):
        print('* ', end="")
    print('')

break और continue कीवर्ड्स: अनंत लूप बनाना

आप किसी भी लूप में break और continue का उपयोग कर सकते हैं। ये कीवर्ड्स केवल जानबूझकर बनाए गए अनंत लूप्स को तोड़ने तक सीमित नहीं हैं, लेकिन इन्हें सावधानी से उपयोग करना चाहिए। दोनों कीवर्ड्स दूसरों के लिए —और कुछ महीनों बाद स्वयं आपके लिए भी जब आप अपने कोड पर नज़र डालेंगे— लूप में नियंत्रण प्रवाह और शर्त कहाँ समाप्त होती है, यह समझना कठिन बना देते हैं। इसके अलावा, आपको break और continue कीवर्ड्स का उपयोग करने की ज़रूरत नहीं है: जैसा कि आपने अब तक देखा है, आप इनके बिना भी ठीक काम कर रहे थे!

हालाँकि, कुछ मामलों में, अब तक देखे गए पारंपरिक for और while लूप्स की बजाय जानबूझकर अनंत लूप लिखना अधिक स्पष्ट हो सकता है। बेशक, उन मामलों में इन कीवर्ड्स का उपयोग प्रोत्साहित किया जाता है!

Python में While लूप्स को ब्रेक और कंटिन्यू करना

सौभाग्य से, ऊपर वाले अनंत लूप की स्थिति से बाहर निकलने का एक तरीका है और वह है break कीवर्ड का उपयोग करना।

# Take user input
number = 2 

# Condition of the while loop
while number < 5 :  
    # condition of the nested while loop
    while number % 2 == 0:  
        print("The number "+str(number)+" is even")
        break

    number+=1संचालित द्वारा

जब आप ऊपर का कोड चलाते हैं तो यह अब अनंत लूप में नहीं जाता।

"यह क्या जादू है!" आप चिल्लाते हैं — मैं कहता हूँ शांत रहिए, यह कोई जादू नहीं।

जब नियंत्रण break कीवर्ड से टकराता है तो वह समझ जाता है कि उसे लूप (इस मामले में अंदरूनी लूप) से बाहर निकलना है और अगली पंक्ति के कोड को चलाना है। इस प्रकार यह अंदरूनी while लूप से बाहर निकलता है और बाहरी लूप में आगे बढ़ता है तथा जब तक बाहरी while लूप की शर्त सच रहती है, अपना सामान्य काम करता रहता है।

आपको यह ध्यान में रखना चाहिए कि break कीवर्ड के बाद कोड की एक पंक्ति मौजूद होनी चाहिए, वरना इसका कोई असर नहीं होगा। ऊपर के उदाहरण में break कीवर्ड के बाद की पंक्ति को हटाकर कोड चलाने की कोशिश करें।

अगर आप break स्टेटमेंट के बाद continue कीवर्ड डाल दें तो क्या होगा? आप नीचे दिए गए कोड का अनुसरण कर सकते हैं:

number = 2 

while number < 5 :
    while number % 2 == 0: 
        print("The number "+str(number)+" is even")
        break

    continue

    number+=1संचालित द्वारा

ऊपर का कोड break कीवर्ड वाले उदाहरण का थोड़ा संशोधित रूप है।

जब आप ऊपर का कोड चलाते हैं तो आपको फिर से एक अनंत लूप मिलेगा। बाल न नोचें, ज़रा ध्यान से देखें। आप देखेंगे कि break के बाद continue कीवर्ड है। continue कीवर्ड क्या करता है कि यह नियंत्रण को बाहरीतम लूप पर वापस भेज देता है, वह भी उस से पहले कि number चर को बढ़ाया जाए, और इसी वजह से कोड अनंत लूप में चला जाता है।

For लूप्स को ब्रेक और कंटिन्यू करना

अगर आप ऊपर वाले उदाहरण में आंतरिक for लूप को पूरी रेंज के लिए चलाना नहीं चाहते तो क्या करें? आप while लूप के मामले की तरह ही break स्टेटमेंट का उपयोग कर सकते हैं।

# Print the below statement 3 times
for number in range(3) : 
    print("-------------------------------------------")
    print("I am outer loop iteration "+str(number))
    for another_number in range(3):
        print("****************************")
        print("I am inner loop iteration "+str(another_number))
        breakसंचालित द्वारा

ऊपर के उदाहरण में, आंतरिक लूप के बाद break कीवर्ड नियंत्रण को आंतरिक लूप से बाहर निकलने का निर्देश देता है, जिसके बाद नियंत्रण बाहरी लूप पर लौट आता है।

नीचे दिया गया कोड उदाहरण चलाएँ:

# Print the below statement 3 times
for number in range(3) :  
    print("-------------------------------------------")
    print("I am outer loop iteration "+str(number))
    continue
    for another_number in range(3):
        print("****************************")
        print("I am inner loop iteration "+str(another_number))
        breakसंचालित द्वारा

ऊपर दिए गए कोड में केवल सबसे बाहरी लूप ही चलता है और नियंत्रण आंतरिक लूप को छूता भी नहीं।

"क्यों?" आप पूछते हैं।

कोड को ध्यान से देखें। सबसे बाहरी लूप के दूसरे प्रिंट स्टेटमेंट के तुरंत बाद एक continue कीवर्ड है। यह क्या करता है कि यह नियंत्रण को वापस बाहरी for लूप पर जाकर फिर से शुरू करने का निर्देश देता है और इसी वजह से नियंत्रण कभी आंतरिक लूप तक पहुँचता ही नहीं।

while लूप के विपरीत, for लूप में break कीवर्ड के बाद किसी अतिरिक्त कोड की आवश्यकता नहीं होती। for लूप के अंदर अकेला break भी ठीक से काम करेगा।

range() बनाम xrange()

ये दोनों फ़ंक्शंस एक‑दूसरे के समान हैं, लेकिन यदि आप Python 3 का उपयोग कर रहे हैं, तो आपके पास केवल range() फ़ंक्शन उपलब्ध होगा। Python 3.x में xrange() फ़ंक्शन का नाम range() कर दिया गया है। इसका मतलब है कि यदि आप Python 3 के साथ xrange() का उपयोग करने की कोशिश करेंगे, तो आपको NameError: name 'xrange' is not defined त्रुटि मिलेगी।

यह समझने के लिए कि ये दोनों फ़ंक्शंस कैसे समान हैं, निम्नलिखित उदाहरण पर विचार करें:

# Print the below statement 3 times
for number in range(5,10,2) :  
    print("I am number : "+str(number))

# I am number : 5
# I am number : 7
# I am number : 9संचालित द्वारा

ऊपर का कोड चलाकर आप देखेंगे कि number चर का मान 2 के फैक्टर से स्किप होता है, और ऐसा range() फ़ंक्शन में दिए गए पैरामीटर्स की वजह से होता है।

इस फ़ंक्शन में पहला पैरामीटर start पैरामीटर है। यह वह बिंदु है जहाँ से नियंत्रण गिनती शुरू करता है। दूसरा पैरामीटर stop पैरामीटर है जो वह बिंदु है जहाँ नियंत्रण को रुकना होता है और अंतिम पैरामीटर step है, जो यह परिभाषित करता है कि गिनती करते समय नियंत्रण को किस फैक्टर से छलाँग लगानी है।

तो, ऊपर के मामले में, नियंत्रण 5 से शुरू होता है, फिर 9 तक लूप को पार करता है और हर गिनती में 2 जोड़ता चलता है। यानी 5, 5+2=7, 7+2=9।

आपने सीखा कि range() फ़ंक्शन का उपयोग यह परिभाषित करने के लिए किया जाता है कि आपका कोड कितनी बार लूप करेगा। अब, Python 2.x में, आपको ऐसा करने का एक और तरीका भी मिलता है और वह है xrange() फ़ंक्शन। नीचे दिया गया कोड चलाएँ:

# Print the below statement 3 times
for number in xrange(10) :  
    print("I am number : "+str(number))संचालित द्वारा

I am number : 0
I am number : 1
I am number : 2
I am number : 3
I am number : 4
I am number : 5
I am number : 6
I am number : 7
I am number : 8
I am number : 9संचालित द्वारा

ऊपर के कोड के आउटपुट और xrange() के बिना कोड के आउटपुट में आपने क्या अंतर देखा? कोई अंतर नहीं?

बिल्कुल सही। आपको कोड के आउटपुट में कोई अंतर नहीं दिखेगा।

तो फिर आपको xrange() फ़ंक्शन का उपयोग क्यों करना चाहिए? आप इस ट्यूटोरियल में थोड़ी देर बाद इस पर आएँगे। पहले नीचे दिया गया कोड चलाएँ:

print(xrange(10))
print(range(10))संचालित द्वारा

xrange(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]संचालित द्वारा

आप देख सकते हैं कि ऊपर के कोड के आउटपुट में दोनों प्रिंट स्टेटमेंट्स के आउटपुट में अंतर है। जिस प्रिंट स्टेटमेंट में xrange() है, उसमें आपको xrange() फ़ंक्शन ऑब्जेक्ट प्रिंट होता दिखता है। यह range() वाले प्रिंट स्टेटमेंट से अलग है: वहाँ आपको 0 से 9 तक के पूर्णांकों की एक सूची मिलती है।

यही ठीक‑ठीक range() और xrange() फ़ंक्शंस के बीच का अंतर है।

जब आप range() परिभाषित करते हैं, तो पूरी रेंज की एक सूची RAM में संग्रहीत होती है और आपको प्रस्तुत की जाती है। हालाँकि, जब आप xrange() परिभाषित करते हैं, तो सूची मेमोरी में संग्रहीत नहीं होती। इसके बजाय, xrange() आपको ज़रूरत पड़ने पर पूरी रेंज में पूर्णांकों को जेनरेट करता है। इस तरह, xrange() संसाधन‑सीमित सिस्टम में मेमोरी बचाने में मदद करता है।

अपनी Python कौशल निखारें!

बधाई हो, आप इस ट्यूटोरियल के अंत तक पहुँच गए हैं। अब जब आपने Python में लूप्स का उपयोग करना सीख लिया है, तो आगे बढ़ें और अभ्यास करें। जितना अधिक अभ्यास करेंगे, उतने बेहतर बनेंगे!