नियंत्रण प्रवाह
अब तक आपने जो भी प्रोग्राम लिखा है, वह हर बार एक ही तरीके से चलता है: ऊपर से नीचे, एक बार में एक पंक्ति। यह सरल स्क्रिप्ट के लिए काम करता है, लेकिन वास्तविक प्रोग्राम को निर्णय लेने और काम दोहराने की आवश्यकता होती है। एक क्विज को यह जांचना होता है कि उत्तर सही है या नहीं। एक गेम को तब तक चलते रहना होता है जब तक खिलाड़ी जीत या हार न जाए। यह अध्याय आपके प्रोग्राम को शाखा देने और दोहराने का तरीका बताता है।
तुलना
इससे पहले कि आप कोई निर्णय ले सकें, आपको चीजों की तुलना करनी होती है। तुलना operators True या False return करते हैं। जल्दी सही होने वाला सबसे महत्वपूर्ण: = एक मान assign करता है, == यह जांचता है कि क्या दो मान बराबर हैं। इन्हें मिलाना शुरुआती लोगों की सबसे आम गलतियों में से एक है।
5 > 3 # True
5 < 3 # False
5 == 5 # True (note: double equals; = is assignment, == is comparison)
5 != 3 # True ("not equal to")
5 >= 5 # True ("greater than or equal to")
5 <= 4 # False ("less than or equal to")= vs == का अंतर लगभग सभी को जल्दी में confuse करता है। Assignment (=) एक मान store करता है; comparison (==) जांचता है कि क्या दो मान same हैं।
आप strings की भी तुलना कर सकते हैं। Python उन्हें alphabetically, character-by-character compare करता है, जिसे Strings अध्याय अधिक विस्तार से cover करता है:
"apple" == "apple" # True
"apple" < "banana" # True (a comes before b)
"apple" == "Apple" # False (case-sensitive)
= एक मान store करता है, == जांचता है कि क्या दो मान बराबर हैं। मैं अभी भी थका हुआ होने पर उस एक को double-check करने के लिए slow down करता हूं, इसलिए आप अच्छी कंपनी में हैं अगर यह आपको confuse करता है। Comparisons `True` या `False` return करती हैं, और वे strings पर भी काम करती हैं, alphabetically। शर्तों को combine करना
and, or, और not comparisons को combine करते हैं। and को दोनों sides को true होना चाहिए। or को कम से कम एक side को true होना चाहिए। not result को flip करता है। ये आपको वास्तविक दुनिया की शर्तों को व्यक्त करने देते हैं जैसे "score passing है AND user active है"।
age = 25
score = 88
age >= 18 and score >= 80 # True (both must be true)
age < 18 or score >= 80 # True (at least one must be true)
not age >= 18 # False (flips the result)and को दोनों sides चाहिए। or को कम से कम एक side चाहिए। not invert करता है।
and को दोनों sides true चाहिए, or को कम से कम एक, not answer को flip करता है। यह अधिकांश वास्तविक conditions cover करता है जिसे आप लिखेंगे, जैसे "score passing है and user active है"। Python जवाब know करने के moment को moment रुक जाता है। Truthy और falsy
Python में हर value का एक boolean interpretation है, भले ही यह True या False न हो। Empty strings, zero, empty lists, और None सभी condition में False की तरह behave करते हैं। बाकी सब True की तरह behave करते हैं। इसका मतलब है if results: जांचता है कि क्या एक list non-empty है बिना if len(results) > 0: लिखे।
# ये सभी condition में False की तरह behave करते हैं:
False, 0, 0.0, "", [], {}, (), None
# बाकी सब True की तरह behave करता हैइसका मतलब है if results: एक natural तरीका है "अगर list non-empty है" कहने का, और if name: जांचता है कि क्या एक string के पास कोई content है।
if / elif / else
if statement एक block of code को केवल चलाता है जब इसकी condition True हो। elif अधिक conditions add करता है अगर पहली false थी तो check करने के लिए। else सब कुछ catch करता है जो किसी condition से match नहीं हुआ। Python बर्स नहीं, indentation का use करता है यह define करने के लिए कि क्या हर block के अंदर belongs है।
score = 87
if score >= 90:
print("A grade")
elif score >= 80:
print("B grade")
elif score >= 70:
print("C grade")
else:
print("Below C")नियम:
ifrequired है और हमेशा पहली आती हैelif(short for "else if") optional है और आपको जितनी चाहे उतनी चाहिएelseoptional है, सब कुछ handle करता है जो match नहीं हुआ, और last आता है- Python indentation (4 spaces) use करता है यह mark करने के लिए कि क्या हर block के अंदर belongs है; कोई braces नहीं हैं
Indentation optional या cosmetic नहीं है। Python इसे structure define करने के लिए use करता है। Inconsistent indentation एक syntax error है।
if अपना block चलाता है जब condition true है, elif अधिक cases check करता है, else बाकी catch करता है। केवल पहली match चलती है। चीज़ जिसने मुझे जल्दी में confused किया: indentation है जो Python को बताता है कि हर block कहां start और end होता है, इसलिए इसे consistent रखें। One-line conditions
simple yes/no assignments के लिए, Python के पास एक compact one-line form है जिसे ternary expression कहते हैं: value_if_true if condition else value_if_false। इसे केवल तभी use करें जब logic छोटा हो और एक sentence की तरह पढ़ता हो।
label = "pass" if score >= 50 else "fail"यह एक ternary expression है; यह एक sentence की तरह पढ़ता है। इसे use करें जब logic छोटा हो। कुछ भी involving elif के लिए, full version लिखें।
value_if_true if condition else value_if_false एक ही line पर दो values में से एक pick करता है। यह तidy little choices के लिए lovely है जैसे "pass" if score >= 50 else "fail"। जिस moment logic उससे अधिक grow करता है, एक normal `if` block पर वापस जाएं, यह better पढ़ेगा। while loops
एक while लूप अपने block को repeat करता है जब तक इसकी condition True है। इसे use करें जब आप advance में नहीं जानते कि लूप कितनी बार चलना चाहिए, उदाहरण के लिए valid input के लिए wait करना या जब तक एक job success न हो तब तक retry करना।
lives = 3
while lives > 0:
print(f"Lives remaining: {lives}")
lives -= 1
print("Game over")while best है जब आप advance में नहीं जानते कि लूप कितनी बार चलेगा। जब आप जानते हो, या जब आप एक collection iterate कर रहे हो, for cleaner है।
while अपने block को तब तक चलाते रहता है जब तक condition true रहता है। इसे reach करें जब आप नहीं जानते कि आपको कितने rounds की जरूरत है, जैसे valid input के लिए wait करना। सुनिश्चित करें कि loop के अंदर कुछ exit की ओर move करता है, या यह forever चलेगा, एक गलती जो मैंने एक से अधिक बार की है। break और continue
break लूप को immediately exit करता है, कितने भी iterations remain हों। continue current iteration के rest को skip करता है और condition check में वापस jump करता है। दोनों केवल innermost loop को affect करते हैं जो वे अंदर हैं।
break लूप को immediately exit करता है:
target = 5
num = 0
while True:
num += 1
if num == target:
print(f"Found {target}")
break # stop the loopwhile True: एक break के साथ एक valid और common pattern है जब exit condition complex है या loop body के end में happen करने की जरूरत है।
continue current iteration के rest को skip करता है और condition check में वापस जाता है:
num = 0
while num < 10:
num += 1
if num % 2 == 0:
continue # skip even numbers
print(num) # only odd numbers print: 1, 3, 5, 7, 9break लूप से right away jump करता है, continue इस round के rest को skip करता है और condition check में वापस जाता है। दोनों केवल loop को touch करते हैं जो वे directly अंदर हैं। `while True:` एक `break` के साथ odd read करता है at first, लेकिन यह एक normal तरीका है जब तक कुछ happen न हो loop करने का। for loops
एक for लूप एक sequence को एक बार में एक item चलता है: एक list, एक string, संख्याओं की एक range। variable जिसे आप for के बाद name देते हैं, वह हर बार में एक item receive करता है। आप एक counter manage नहीं करते या length को खुद check नहीं करते।
players = ["राज", "प्रिया", "अमित"]
for player in players:
print(f"नमस्ते, {player}!")for लूप strings पर भी काम करते हैं (character-by-character iterate करते हुए) और किसी भी दूसरे sequence type पर।
for item in sequence हर item को एक-एक करके चलता है, और आप कभी एक counter या एक length को खुद touch नहीं करते। यह lists, strings, ranges, बहुत सारी चीजों पर काम करता है। दूसरी भाषाओं से आते हुए, index को manage न करना मुझे at first अजीब लगा, फिर यह एक gift की तरह लगा। range()
range() आपके लिए numbers की एक sequence generate करता है loop करने के लिए। range(5) आपको 0, 1, 2, 3, 4 देता है। आप start, end, और step size को control कर सकते हैं। इसे use करें जब आप एक लूप को एक specific number of times चलाना चाहते हैं।
for i in range(5):
print(i) # 0, 1, 2, 3, 4range() के तीन forms हैं:
| Call | What it produces |
|---|---|
range(5) | 0, 1, 2, 3, 4 |
range(2, 6) | 2, 3, 4, 5 |
range(0, 10, 2) | 0, 2, 4, 6, 8 (step of 2) |
range(5, 0, -1) | 5, 4, 3, 2, 1 (counting down) |
range() एक list create नहीं करता। यह एक बार में numbers produce करता है, जो बहुत बड़े ranges के लिए भी efficient है।
range(5) आपको `0, 1, 2, 3, 4` देता है, और आप एक start, stop, और step set कर सकते हैं। इसे reach करें जब आप एक लूप को एक set number of times चलाना चाहते हैं। यह एक list build नहीं करता, यह आपको एक बार में एक number hand करता है। enumerate()
enumerate() आपको loop करते हुए index और value दोनों देता है, इसलिए आपको एक counter separately track नहीं करना होता। i, player part automatically हर iteration पर एक pair of values receive करता है।
players = ["राज", "प्रिया", "अमित"]
for i, player in enumerate(players):
print(f"{i + 1}. {player}")
# 1. राज
# 2. प्रिया
# 3. अमितi, player syntax को unpacking कहते हैं। Python (index, value) pair को दो names में automatically split करता है।
By default enumerate() 0 से start करता है। एक start value pass करें वह change करने के लिए:
for i, player in enumerate(players, start=1):
print(f"{i}. {player}") # starts at 1enumerate() आपको position और value together hand करता है, इसलिए कोई separate counter नहीं जिसे sync में रखना होता है। `i, player` part दोनों को at once catch करता है। `start=1` pass करें जब आप एक list को number कर रहे हों किसी को read करने के लिए। नीडेड loops
आप एक loop को दूसरे loop के अंदर रख सकते हैं। inner loop पूरी तरह से outer loop के हर single iteration के लिए चलता है। यही है कि आप grids, combinations, या दो levels की structure के साथ कोई भी data को process कैसे करते हैं।
rows = [1, 2, 3]
cols = ["A", "B"]
for row in rows:
for col in cols:
print(f"{col}{row}", end=" ")
print() # newline after each row
# A1 B1
# A2 B2
# A3 B3एक nested लूप के अंदर break और continue केवल innermost लूप को affect करते हैं।
लूप-else
Python लूप के पास एक else clause हो सकता है जो केवल तभी चलता है अगर लूप break को hit किए बिना finish हुआ। यह commonly use नहीं है, लेकिन यह "एक list search करें, और अगर कुछ नहीं मिला, यह करो" लिखने का cleanest तरीका है।
target = "राज"
names = ["प्रिया", "अमित", "सुनीता"]
for name in names:
if name == target:
print(f"Found {target}")
break
else:
print(f"{target} not in list") # runs because break never firedअगर break चलता है, else को skip किया जाता है। अगर लूप sequence को exhaust करता है, else चलता है। यह एक niche pattern है लेकिन एक flag variable से cleaner है।
सॉर्टिंग
sorted() एक नई sorted list return करता है और original को unchanged रखता है। .sort() list को in place sort करता है और None return करता है। key= argument आपको raw value के अलावा कुछ और से sort करने देता है। उदाहरण के लिए, names को case-insensitively sort करना या player tuples को उनके score से sort करना।
scores = [87, 42, 96, 55, 71]
ranked = sorted(scores) # [42, 55, 71, 87, 96] (new list)
scores.sort() # sorts the original list, returns None
scores.sort(reverse=True) # [96, 87, 71, 55, 42]दोनों एक key= argument accept करते हैं: एक function comparison से पहले हर item पर apply किया जाता है:
names = ["सुनीता", "राज", "प्रिया"]
sorted(names, key=str.lower) # case-insensitive sort
players = [("राज", 87), ("प्रिया", 96), ("अमित", 55)]
sorted(players, key=lambda p: p[1]) # sort by scorelambda p: p[1] एक one-line function है: यह एक player tuple लेता है और score return करता है। Lambdas को Lambdas और comprehensions अध्याय में full treatment मिलता है।
सरल cases के लिए, sorted() का use करें। Lists के लिए जहां आप in place modify करना चाहते हैं, .sort() का use करें।
वास्तविक practice में
scores के through loop करें, एक total को accumulate करें, passing grades को count करें, और एक summary print करें:
raw_scores = [87, 42, 96, 55, 71, 63]
total = 0
passing = 0
for score in raw_scores:
total += score
if score >= 60:
passing += 1
average = total / len(raw_scores)
print(f"Average: {average:.1f}")
print(f"Passing: {passing}/{len(raw_scores)}")
print(f"Top score: {sorted(raw_scores, reverse=True)[0]}")