नियंत्रण प्रवाह

अब तक आपने जो भी प्रोग्राम लिखे हैं, वे हर बार उसी तरह चलते हैं: ऊपर से नीचे, एक समय में एक लाइन। यह सरल स्क्रिप्ट के लिए काम करता है, लेकिन वास्तविक प्रोग्रामों को निर्णय लेने और काम दोहराने की आवश्यकता होती है। एक क्विज़ को जाँचना होता है कि उत्तर सही है या नहीं। एक गेम को तब तक चलते रहना चाहिए जब तक खिलाड़ी जीत या हार नहीं जाता। यह अध्याय बताता है कि आप अपने प्रोग्राम को कैसे शाखाबद्ध और दोहरा सकते हैं।

तुलनाएँ

निर्णय लेने से पहले, आपको चीजों की तुलना करनी होती है। तुलना ऑपरेटर True या False लौटाते हैं। शुरुआत में सही करने के लिए सबसे महत्वपूर्ण: = एक मान को असाइन करता है, == जाँचता है कि दो मान बराबर हैं या नहीं। इन्हें मिलाना शुरुआती लोगों की सबसे आम गलतियों में से एक है।

python

5 > 3     # True
5 < 3     # False
5 == 5    # True   (ध्यान दें: डबल equals; = असाइनमेंट है, == तुलना है)
5 != 3    # True   ("बराबर नहीं है")
5 >= 5    # True   ("इससे बड़ा या बराबर")
5 <= 4    # False  ("इससे छोटा या बराबर")

= बनाम == का अंतर लगभग सभी को शुरुआत में परेशान करता है। असाइनमेंट (=) एक मान संग्रहीत करता है; तुलना (==) जाँचती है कि दो मान समान हैं या नहीं।

आप स्ट्रिंग्स की भी तुलना कर सकते हैं। Python उन्हें वर्णानुक्रम में तुलना करता है:

python

"apple" == "apple"   # True
"apple" < "banana"   # True  (a, b से पहले आता है)
"apple" == "Apple"   # False (केस-सेंसिटिव)

शर्तों को संयोजित करना

and, or, और not तुलनाओं को संयोजित करते हैं। and के लिए दोनों पक्षों का सत्य होना आवश्यक है। or के लिए कम से कम एक पक्ष की आवश्यकता होती है। not परिणाम को पलट देता है। ये आपको वास्तविक दुनिया की शर्तें व्यक्त करने देते हैं जैसे "स्कोर पास हो रहा है AND उपयोगकर्ता सक्रिय है"।

python

age   = 25
score = 88

age >= 18 and score >= 80    # True  (दोनों सत्य होने चाहिए)
age < 18 or score >= 80      # True  (कम से कम एक सत्य होना चाहिए)
not age >= 18                # False (परिणाम पलटता है)

and के लिए दोनों पक्षों की आवश्यकता होती है। or के लिए कम से कम एक पक्ष की आवश्यकता होती है। not उलटा करता है।

Truthy और falsy

Python में हर मान की एक बूलियन व्याख्या होती है, भले ही वह True या False न हो। खाली स्ट्रिंग, शून्य, खाली सूचियाँ, और None एक शर्त में False की तरह व्यवहार करते हैं। बाकी सब कुछ True की तरह व्यवहार करता है। इसका मतलब है कि if results: यह जाँचता है कि सूची खाली नहीं है, बिना if len(results) > 0: लिखे।

python

# ये सभी एक शर्त में False की तरह व्यवहार करते हैं:
False, 0, 0.0, "", [], {}, (), None

# बाकी सब कुछ True की तरह व्यवहार करता है

इसका मतलब है कि if results: "यदि सूची खाली नहीं है" कहने का एक स्वाभाविक तरीका है, और if name: जाँचता है कि स्ट्रिंग में कोई सामग्री है या नहीं।

if / elif / else

if स्टेटमेंट कोड के एक ब्लॉक को केवल तभी चलाता है जब इसकी शर्त True हो। elif और शर्तें जोड़ता है यदि पहली false थी। else उन सभी को पकड़ता है जो किसी भी शर्त से मेल नहीं खाते। Python ब्रेसेस के बजाय इंडेंटेशन का उपयोग करता है यह परिभाषित करने के लिए कि प्रत्येक ब्लॉक के अंदर क्या है।

python

score = 87

if score >= 90:
    print("A grade")
elif score >= 80:
    print("B grade")
elif score >= 70:
    print("C grade")
else:
    print("Below C")

नियम:

if आवश्यक है और हमेशा पहले आता है
elif ("else if" का संक्षिप्त रूप) वैकल्पिक है और आप जितने चाहें उतने रख सकते हैं
else वैकल्पिक है, उन सभी को संभालता है जो मेल नहीं खाते, और अंत में आता है
Python प्रत्येक ब्लॉक के अंदर क्या है यह चिह्नित करने के लिए इंडेंटेशन (4 स्पेस) का उपयोग करता है; कोई ब्रेसेस नहीं हैं

इंडेंटेशन वैकल्पिक या सजावटी नहीं है। Python इसका उपयोग संरचना परिभाषित करने के लिए करता है। असंगत इंडेंटेशन एक सिंटैक्स त्रुटि है।

एक-लाइन शर्तें

सरल हाँ/नहीं असाइनमेंट के लिए, Python का एक संक्षिप्त एक-लाइन रूप है जिसे टर्नरी एक्सप्रेशन कहा जाता है: value_if_true if condition else value_if_false। इसका उपयोग केवल तब करें जब तर्क वास्तव में सरल हो और एक वाक्य की तरह पढ़ा जाए।

python

label = "pass" if score >= 50 else "fail"

यह एक टर्नरी एक्सप्रेशन है; यह एक वाक्य की तरह पढ़ा जाता है। इसका उपयोग तब करें जब तर्क वास्तव में सरल हो। elif से जुड़ी किसी भी चीज़ के लिए, पूर्ण संस्करण लिखें।

while लूप

एक while लूप अपने ब्लॉक को तब तक दोहराता है जब तक उसकी शर्त True हो। इसका उपयोग तब करें जब आप पहले से नहीं जानते कि लूप कितनी बार चलना चाहिए, उदाहरण के लिए मान्य इनपुट की प्रतीक्षा करना या किसी कार्य के सफल होने तक पुनः प्रयास करना।

python

lives = 3

while lives > 0:
    print(f"Lives remaining: {lives}")
    lives -= 1

print("Game over")

while तब सबसे अच्छा होता है जब आप पहले से नहीं जानते कि लूप कितनी बार चलेगा। जब आप जानते हैं, या जब आप एक संग्रह पर पुनरावृत्ति कर रहे हैं, तो for साफ़ होता है।

break और continue

break लूप को तुरंत बाहर निकाल देता है, चाहे कितनी भी पुनरावृत्तियाँ शेष हों। continue वर्तमान पुनरावृत्ति के शेष भाग को छोड़ देता है और शर्त जाँच पर वापस कूदता है। दोनों केवल उस सबसे आंतरिक लूप को प्रभावित करते हैं जिसके अंदर वे हैं।

break लूप को तुरंत बाहर निकालता है:

python

target = 5
num    = 0

while True:
    num += 1
    if num == target:
        print(f"Found {target}")
        break   # लूप रोकें

break के साथ while True: एक मान्य और सामान्य पैटर्न है जब बाहर निकलने की शर्त जटिल हो या लूप बॉडी के अंत में होनी चाहिए।

continue वर्तमान पुनरावृत्ति के शेष भाग को छोड़ देता है और शर्त जाँच पर वापस जाता है:

python

num = 0

while num < 10:
    num += 1
    if num % 2 == 0:
        continue    # सम संख्याएँ छोड़ें
    print(num)      # केवल विषम संख्याएँ प्रिंट होती हैं: 1, 3, 5, 7, 9

for लूप

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

python

players = ["आरव", "प्रिया", "रोहन"]

for player in players:
    print(f"Hello, {player}!")

for लूप स्ट्रिंग्स पर भी काम करते हैं (वर्ण दर वर्ण पुनरावृत्ति) और किसी भी अन्य अनुक्रम प्रकार पर।

range()

range() आपके लूप पर जाने के लिए संख्याओं का एक अनुक्रम उत्पन्न करता है। range(5) आपको 0, 1, 2, 3, 4 देता है। आप शुरुआत, अंत, और स्टेप आकार को नियंत्रित कर सकते हैं। जब आपको एक विशिष्ट संख्या में लूप चलाने की आवश्यकता हो तो इसका उपयोग करें।

python

for i in range(5):
    print(i)    # 0, 1, 2, 3, 4

range() के तीन रूप हैं:

कॉल	यह क्या उत्पन्न करता है
`range(5)`	`0, 1, 2, 3, 4`
`range(2, 6)`	`2, 3, 4, 5`
`range(0, 10, 2)`	`0, 2, 4, 6, 8` (2 का स्टेप)
`range(5, 0, -1)`	`5, 4, 3, 2, 1` (उल्टी गिनती)

range() एक सूची नहीं बनाता। यह एक समय में एक संख्या उत्पन्न करता है, जो बहुत बड़ी श्रेणियों के लिए भी कुशल है।

enumerate()

enumerate() लूप के दौरान आपको इंडेक्स और मान दोनों देता है, इसलिए आपको अलग से एक काउंटर ट्रैक करने की आवश्यकता नहीं है। i, player भाग प्रत्येक पुनरावृत्ति पर स्वचालित रूप से मानों की एक जोड़ी प्राप्त करता है।

python

players = ["आरव", "प्रिया", "रोहन"]

for i, player in enumerate(players):
    print(f"{i + 1}. {player}")
# 1. आरव
# 2. प्रिया
# 3. रोहन

i, player सिंटैक्स को अनपैकिंग कहा जाता है। Python स्वचालित रूप से (index, value) जोड़ी को दो नामों में विभाजित करता है।

डिफ़ॉल्ट रूप से enumerate() 0 से शुरू होता है। इसे बदलने के लिए एक शुरुआती मान पास करें:

python

for i, player in enumerate(players, start=1):
    print(f"{i}. {player}")    # 1 से शुरू होता है

नेस्टेड लूप

आप एक लूप को दूसरे लूप के अंदर रख सकते हैं। आंतरिक लूप बाहरी लूप की प्रत्येक एक पुनरावृत्ति के लिए पूरी तरह से चलता है। इस तरह आप ग्रिड, संयोजन, या किसी भी डेटा को दो स्तरों की संरचना के साथ संसाधित करते हैं।

python

rows = [1, 2, 3]
cols = ["A", "B"]

for row in rows:
    for col in cols:
        print(f"{col}{row}", end=" ")
    print()   # प्रत्येक पंक्ति के बाद नई पंक्ति
# A1 B1
# A2 B2
# A3 B3

नेस्टेड लूप के अंदर break और continue केवल सबसे आंतरिक लूप को प्रभावित करते हैं।

Loop-else

Python लूप में एक else क्लॉज हो सकता है जो केवल तभी चलता है जब लूप break से टकराए बिना समाप्त हो। इसका आमतौर पर उपयोग नहीं किया जाता है, लेकिन यह "एक सूची खोजें, और यदि कुछ नहीं मिला, तो यह करें" लिखने का सबसे साफ़ तरीका है।

python

target = "विकास"
names  = ["आरव", "प्रिया", "रोहन"]

for name in names:
    if name == target:
        print(f"Found {target}")
        break
else:
    print(f"{target} not in list")   # चलता है क्योंकि break कभी नहीं फायर हुआ

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

छँटाई

sorted() एक नई छँटी हुई सूची लौटाता है और मूल को अपरिवर्तित छोड़ देता है। .sort() सूची को इन-प्लेस छाँटता है और None लौटाता है। key= तर्क आपको कच्चे मान के अलावा किसी अन्य चीज़ से छाँटने देता है। उदाहरण के लिए, केस-असंवेदनशील रूप से नाम छाँटना या उनके स्कोर द्वारा खिलाड़ी टपल्स छाँटना।

python

scores = [87, 42, 96, 55, 71]

ranked = sorted(scores)           # [42, 55, 71, 87, 96] (नई सूची)
scores.sort()                     # मूल सूची को छाँटता है, None लौटाता है
scores.sort(reverse=True)         # [96, 87, 71, 55, 42]

दोनों एक key= तर्क स्वीकार करते हैं: तुलना से पहले प्रत्येक आइटम पर लागू एक फ़ंक्शन:

python

names = ["रोहन", "आरव", "प्रिया"]
sorted(names, key=str.lower)       # केस-असंवेदनशील छँटाई

players = [("आरव", 87), ("प्रिया", 96), ("रोहन", 55)]
sorted(players, key=lambda p: p[1])   # स्कोर के अनुसार छँटाई

lambda क्या है?

lambda p: p[1] एक एक-लाइन फ़ंक्शन है। यह एक प्लेयर टपल लेता है और स्कोर लौटाता है। लैम्ब्डा फ़ंक्शन Lambda, comprehensions, and zip अध्याय में कवर किए गए हैं।

सरल मामलों के लिए, sorted() का उपयोग करें। उन सूचियों के लिए जिन्हें आप इन-प्लेस संशोधित करना चाहते हैं, .sort() का उपयोग करें।

व्यवहार में

स्कोर्स के माध्यम से लूप करें, कुल जमा करें, पास होने वाले ग्रेड गिनें, और एक सारांश प्रिंट करें:

python

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

नियंत्रण प्रवाह ​

तुलनाएँ ​

शर्तों को संयोजित करना ​

Truthy और falsy ​

if / elif / else ​

एक-लाइन शर्तें ​

while लूप ​

break और continue ​

for लूप ​

range() ​

enumerate() ​

नेस्टेड लूप ​

Loop-else ​

छँटाई ​

व्यवहार में ​

नियंत्रण प्रवाह

तुलनाएँ

शर्तों को संयोजित करना

Truthy और falsy

if / elif / else

एक-लाइन शर्तें

while लूप

break और continue

for लूप

range()

enumerate()

नेस्टेड लूप

Loop-else

छँटाई

व्यवहार में