अंक तय करना

Python में लूप के दो तरीके हैं। while लूप अनिश्चित (बिना गिने) इटरेशन के लिए हैं, और for लूप निश्चित (गिने हुए) इटरेशन के लिए। कीवर्ड break, continue और else लूप के व्यवहार को अपने हिसाब से बदलने में मदद करते हैं। range() और enumerate() लूप गिनने और इंडेक्स करने में मदद करते हैं।

while लूप

while लूप तब तक चलते रहते हैं जब तक कि loop expression या "टेस्ट" का किसी boolean context में परिणाम True रहता है, और जब उसका परिणाम False हो जाता है तो वे रुक जाते हैं:

# Lists are considered "truthy" in a boolean context if they
# contain one or more values, and "falsy" if they are empty.

>>> placeholders = ["spam", "ham", "eggs", "green_spam", "green_ham", "green_eggs"]

>>> while placeholders:
...     print(placeholders.pop(0))
...
'spam'
'ham'
'eggs'
'green_spam'
'green_ham'
'green_eggs'

for लूप

Python में बुनियादी for loop को for each कहना ज़्यादा ठीक रहता है, जो किसी भी इटरेबल ऑब्जेक्ट की वैल्यू पर एक-एक करके चलता है और तब रुक जाता है जब next() को कॉल करने पर कोई वैल्यू नहीं लौटती:

>>> word_list = ["bird", "chicken", "barrel", "bongo"]

>>> for word in word_list:
...    if word.startswith("b"):
...        print(f"{word.title()} starts with a B.")
...    else:
...        print(f"{word.title()} doesn't start with a B.")
...
'Bird starts with a B.'
'Chicken doesn\'t start with a B.'
'Barrel starts with a B.'
'Bongo starts with a B.'

सीक्वेंस ऑब्जेक्ट range()

जब कोई खास iterable नहीं दिया गया हो, तो लूप काउंटर के तौर पर range() नाम का खास सीक्वेंस इस्तेमाल किया जाता है। range() को एक int देना ज़रूरी है जिससे पहले सीक्वेंस stop हो जाए, और यह चाहें तो start और step पैरामीटर भी ले सकता है। अगर start संख्या नहीं दी गई हो, तो सीक्वेंस 0 से शुरू होगा। range() ऑब्जेक्ट लेज़ी होते हैं (वैल्यू माँगने पर ही बनाई जाती हैं), इन पर सभी सामान्य सीक्वेंस ऑपरेशन लागू होते हैं, और सीक्वेंस चाहे कितना भी लंबा हो, ये तय मात्रा में ही मेमोरी लेते हैं।

# Here we use range to produce some numbers, rather than creating a list of them in memory.
# The values will start with 1 and stop *before* 7

>>> for number in range(1, 7):
...    if number % 2 == 0:
...       print(f"{number} is even.")
...    else:
...       print(f"{number} is odd.")
'1 is odd.'
'2 is even.'
'3 is odd.'
'4 is even.'
'5 is odd.'
'6 is even.'

# range() can also take a *step* parameter.
# Here we use range to produce only the "odd" numbers, starting with 3 and stopping *before* 15.

>>> for number in range(3, 15, 2):
...    if number % 2 == 0:
...       print(f"{number} is even.")
...    else:
...       print(f"{number} is odd.")
...
'3 is odd.'
'5 is odd.'
'7 is odd.'
'9 is odd.'
'11 is odd.'
'13 is odd.'

enumerate() के साथ वैल्यू और इंडेक्स

अगर वैल्यू और उनके इंडेक्स दोनों चाहिए, तो बिल्ट-इन enumerate(<iterable>) (index, value) जोड़े लौटाता है:

>>> word_list = ["bird", "chicken", "barrel", "apple"]

# *index* and *word* are the loop variables.
# Loop variables can be any valid python name.

>>> for index, word in enumerate(word_list):
...    if word.startswith("b"):
...        print(f"{word.title()} (at index {index}) starts with a B.")
...    else:
...        print(f"{word.title()} (at index {index}) doesn't start with a B.")
...
'Bird (at index 0) starts with a B.'
'Chicken (at index 1) doesn\'t start with a B.'
'Barrel (at index 2) starts with a B.'
'Apple (at index 3) doesn\'t start with a B.'


# The same method can be used as a "lookup" for pairing items between two lists.
# Of course, if the lengths or indexes don't line up, this doesn't work.

>>> word_list = ["cat", "chicken", "barrel", "apple", "spinach"]
>>> category_list = ["mammal", "bird", "thing", "fruit", "vegetable"]

>>> for index, word in enumerate(word_list):
...    print(f"{word.title()} is in category: {category_list[index]}.")
...
'Cat is in category: mammal.'
'Chicken is in category: bird.'
'Barrel is in category: thing.'
'Apple is in category: fruit.'
'Spinach is in category: vegetable.'

लूप के व्यवहार में बदलाव

continue कीवर्ड की मदद से सीधे अगले इटरेशन पर पहुँचा जा सकता है:

word_list = ["bird", "chicken", "barrel", "bongo", "sliver", "apple", "bear"]

# This will skip *bird*, at index 0
for index, word in enumerate(word_list):
    if index == 0:
        continue
    if word.startswith("b"):
        print(f"{word.title()} (at index {index}) starts with a b.")

'Barrel (at index 2) starts with a b.'
'Bongo (at index 3) starts with a b.'
'Bear (at index 6) starts with a b.'

break कीवर्ड (जैसा कि C से जुड़ी कई भाषाओं में होता है) इटरेशन रोक देता है और सबसे अंदर वाले loop से बाहर निकल आता है:

>>>  word_list = ["bird", "chicken", "barrel", "bongo", "sliver", "apple"]

>>> for index, word in enumerate(word_list):
...    if word.startswith("b"):
...        print(f"{word.title()} (at index {index}) starts with a B.")
...    elif word == "sliver":
...       break
...    else:
...       print(f"{word.title()} doesn't start with a B.")
... print("loop broken.")
...
'Bird (at index 0) starts with a B.'
'Chicken doesn\'t start with a B.'
'Barrel (at index 2) starts with a B.'
'Bongo (at index 3) starts with a B.'
'loop broken.'