विषय-सूची
प्रोग्राम सीखने की प्रक्रिया में, अक्सर ऐसे प्रोग्राम बनाना आवश्यक होता है जो वास्तविक जीवन में लागू करना इतना आसान नहीं होता है। आखिरकार, समय-समय पर आपको कुछ शर्तों के तहत ही निर्देशों का पालन करना होता है। कार्यक्रम में इसे लागू करने में सक्षम होने के लिए, सभी भाषाओं में नियंत्रण कथन होते हैं। उनकी मदद से, आप कोड निष्पादन के प्रवाह को नियंत्रित कर सकते हैं, लूप बना सकते हैं या कुछ क्रियाओं को तभी कर सकते हैं जब कोई निश्चित स्थिति सही हो।
आज हम इफ स्टेटमेंट के बारे में बात करेंगे, जो एक निश्चित स्थिति के लिए वर्तमान स्थिति की जाँच करता है, और इस जानकारी के आधार पर आगे की कार्रवाई के बारे में निर्णय लेता है।
कंट्रोल स्टेटमेंट के प्रकार
सामान्य तौर पर, if एकमात्र कथन नहीं है जो किसी प्रोग्राम के प्रवाह को नियंत्रित करता है। साथ ही वह स्वयं ऑपरेटरों की एक बड़ी श्रृंखला का एक घटक हो सकता है।
लूप और स्टेटमेंट भी हैं जो इसके निष्पादन की प्रक्रिया को नियंत्रित करते हैं। आज हम केवल सशर्त ऑपरेटर और उन जंजीरों के बारे में बात करेंगे जिनमें वह भाग ले सकता है।
प्रोग्रामिंग में ब्रांचिंग जैसी कोई चीज होती है। यह ठीक यही है जिसका अर्थ है आदेशों का एक क्रम जो केवल एक निश्चित स्थिति के सत्य होने पर ही निष्पादित किया जाता है। मानदंड स्वयं भिन्न हो सकते हैं:
- एक चर की एक निश्चित मूल्य की समानता।
- एक विशिष्ट क्रिया करना।
- आवेदन स्थिति (ढह गया या नहीं)।
स्पेक्ट्रम बहुत बड़ा हो सकता है। सशर्त बयान कई प्रकार में आते हैं:
- एक शाखा के साथ। यही है, एक एकल जांच की जाती है, जिसके परिणामस्वरूप कुछ क्रियाएं की जाती हैं।
- दो या दो से अधिक शाखाओं के साथ। यदि मानदंड 1 सत्य है, तो मानदंड 2 की जांच करें। यदि यह सत्य है, तो 3 जांचें। और इसलिए, जितनी आवश्यकता हो उतनी जांच करें।
- कई शर्तों के साथ। यहाँ सब कुछ सरल है। दुभाषिया कई स्थितियों या उनमें से एक के लिए जाँच करता है।
अगर बयान
इफ स्टेटमेंट की संरचना सभी भाषाओं में समान है। हालाँकि, पायथन में, इसका सिंटैक्स अन्य सभी से कुछ अलग है:
अगर शर्त:
<входящее выражение 1>
<входящее выражение 2>
<не входящее выражение>
सबसे पहले, ऑपरेटर को खुद घोषित किया जाता है, जिसके बाद वह जिस स्थिति में काम करना शुरू करता है, उसे लिखा जाता है। शर्त सही या गलत हो सकती है।
इसके बाद कमांड के साथ एक ब्लॉक होता है। यदि यह तुरंत मिलने वाले मानदंड का पालन करता है, तो आदेशों के संबंधित अनुक्रम को if ब्लॉक कहा जाता है। इसमें आप जितने भी कमांड्स इस्तेमाल कर सकते हैं।
सावधान! सभी के भीतर इंडेंटेशन if ब्लॉक कमांड एक ही आकार का होना चाहिए। ब्लॉक की सीमाएं इंडेंट द्वारा निर्धारित की जाती हैं।
भाषा प्रलेखन के अनुसार, इंडेंटेशन 4 रिक्त स्थान है।
यह ऑपरेटर कैसे काम करता है? जब दुभाषिया इफ शब्द देखता है, तो यह तुरंत उपयोगकर्ता द्वारा निर्दिष्ट मानदंडों के खिलाफ अभिव्यक्ति की जांच करता है। यदि ऐसा है, तो वह निर्देशों की तलाश और उनका पालन करना शुरू कर देता है। अन्यथा, इस ब्लॉक के सभी आदेश छोड़ दिए जाते हैं।
यदि कंडीशन के बाद स्टेटमेंट इंडेंट नहीं किया जाता है, तो इसे if ब्लॉक नहीं माना जाता है। हमारी स्थिति में, यह रेखा है
यह ऑपरेटर कैसे काम करता है, इसके उदाहरण के लिए यहां एक कोड स्निपेट दिया गया है।
संख्या = इंट (इनपुट ("एक नंबर दर्ज करें:"))
अगर संख्या> 10:
प्रिंट ("संख्या 10 से अधिक है")
यह प्रोग्राम उपयोगकर्ता को एक संख्या के लिए संकेत देता है और जांचता है कि क्या यह 10 से अधिक है। यदि ऐसा है, तो यह उचित जानकारी देता है। उदाहरण के लिए, यदि उपयोगकर्ता नंबर 5 में प्रवेश करता है, तो प्रोग्राम बस समाप्त हो जाएगा, और बस।
लेकिन अगर आप संख्या 100 निर्दिष्ट करते हैं, तो दुभाषिया समझ जाएगा कि यह दस से अधिक है, और इसकी रिपोर्ट करें।
सावधान! हमारे मामले में, यदि स्थिति गलत है, तो प्रोग्राम बंद हो जाता है, क्योंकि निर्देश के बाद कोई आदेश नहीं दिया जाता है।
उपरोक्त कोड में केवल एक कमांड है। लेकिन उनमें से कई और भी हैं। केवल आवश्यकता इंडेंट करने की है।
अब आइए आदेशों के इस क्रम का विश्लेषण करें।
संख्या = इंट (इनपुट ("एक नंबर लिखें:"))
अगर संख्या> 10:
प्रिंट ("पहली पंक्ति")
प्रिंट ("दूसरी पंक्ति")
प्रिंट ("तीसरी पंक्ति")
प्रिंट ("वह पंक्ति जिसे निष्पादित किया गया है, दर्ज की गई संख्या की परवाह किए बिना")
प्रिंट ("आवेदन समाप्त करें")
यह अनुमान लगाने का प्रयास करें कि यदि आप मान 2, 5, 10, 15, 50 दर्ज करते हैं तो आउटपुट क्या होगा।
जैसा कि आप देख सकते हैं, यदि उपयोगकर्ता द्वारा दर्ज की गई संख्या दस से अधिक है, तो तीन लाइनें आउटपुट हैं + एक "हर बार चलाएं ..." और एक "अंत" पाठ के साथ, और यदि दस से कम है, तो केवल एक, के साथ एक अलग पाठ। सत्य होने पर केवल 3,4,5 पंक्तियाँ निष्पादित की जाएंगी। हालाँकि, अंतिम दो पंक्तियाँ लिखी जाएंगी चाहे उपयोगकर्ता कितनी भी संख्या निर्दिष्ट करे।
यदि आप सीधे कंसोल में स्टेटमेंट का उपयोग करते हैं, तो परिणाम अलग होगा। दुभाषिया तुरंत मल्टी-लाइन मोड चालू कर देता है, यदि सत्यापन मानदंड निर्दिष्ट करने के बाद, एंटर दबाएं।
मान लीजिए कि हमने आदेशों का निम्नलिखित क्रम लिखा है।
>>>
>>> एन = 100
>>> अगर एन> 10:
...
उसके बाद, हम देखेंगे कि >>> को इलिप्सिस से बदल दिया गया है। इसका मतलब है कि मल्टीलाइन इनपुट मोड सक्षम है। सरल शब्दों में, यदि आप एंटर दबाते हैं, तो आपको निर्देश के दूसरे चरण के इनपुट में स्थानांतरित कर दिया जाएगा।
और इस ब्लॉक से बाहर निकलने के लिए, आपको ब्लॉक में एक और निर्माण जोड़ना होगा if.
>>>
>>> एन = 100
>>> अगर एन> 10:
... प्रिंट ("एनवी 10")
...
यदि शर्त सत्य नहीं है, तो कार्यक्रम समाप्त हो जाता है। यह एक समस्या है, क्योंकि उपयोगकर्ता ऐसे प्रोग्राम को विफलता के कारण बंद होने के रूप में देख सकता है। इसलिए यूजर को फीडबैक देना जरूरी है। इसके लिए एक लिंक का उपयोग किया जाता है यदि नहीं तो.
एक्सप्रेशन ऑपरेटर यदि नहीं तो
यह ऑपरेटर आपको एक लिंक लागू करने की अनुमति देता है: यदि अभिव्यक्ति एक निश्चित नियम से मेल खाती है, तो इन क्रियाओं को करें, और यदि नहीं, तो अन्य। यही है, यह आपको कार्यक्रम के प्रवाह को दो सड़कों में विभाजित करने की अनुमति देता है। वाक्यविन्यास सहज है:
अगर शर्त:
#अगर ब्लॉक
कथन 1
कथन 2
इत्यादि
अन्य:
# और ब्लॉक
कथन 3
कथन 4
और इसी तरह:
आइए बताते हैं कि यह ऑपरेटर कैसे काम करता है। सबसे पहले, मानक विवरण को थ्रेड में निष्पादित किया जाता है यू, जाँच कर रहा है कि क्या यह मेल खाता है शर्त "सही या गलत"। आगे की कार्रवाई चेक के परिणामों पर निर्भर करती है। यदि सत्य है, तो निर्देश जो शर्त के बाद निर्देशों के क्रम में है, सीधे निष्पादित किया जाता है। यू, अगर यह झूठा है, तो अन्य.
इस तरह आप त्रुटियों को संभाल सकते हैं। उदाहरण के लिए, उपयोगकर्ता को एक त्रिज्या दर्ज करने की आवश्यकता है। जाहिर है, यह केवल एक प्लस चिह्न वाली संख्या हो सकती है, या यह एक शून्य मान है। यदि यह 0 से कम है, तो आपको एक सकारात्मक संख्या दर्ज करने के लिए एक संदेश जारी करना होगा।
यहां वह कोड है जो इस कार्य को लागू करता है। लेकिन यहां एक गलती है। अनुमान लगाने की कोशिश करें कि कौन सा।
त्रिज्या = इंट (इनपुट ("त्रिज्या दर्ज करें:"))
यदि त्रिज्या> = 0:
प्रिंट ("परिधि =", 2 * 3.14 * त्रिज्या)
प्रिंट ("क्षेत्र =", 3.14 * त्रिज्या ** 2)
अन्य:
प्रिंट ("कृपया एक सकारात्मक संख्या दर्ज करें")
इंडेंटेशन बेमेल त्रुटि। अगर और अन्य उनके बिना या उनमें से समान संख्या के साथ स्थित होना चाहिए (इस पर निर्भर करता है कि वे नेस्टेड हैं या नहीं)।
आइए एक और उपयोग का मामला दें (जहां ऑपरेटर संरेखण के साथ सब कुछ सही होगा) - एक एप्लिकेशन तत्व जो पासवर्ड की जांच करता है।
पासवर्ड = इनपुट ("पासवर्ड दर्ज करें:")
अगर पासवर्ड == «sshh»:
प्रिंट ("आपका स्वागत है")
अन्य:
प्रिंट ("प्रवेश निषेध")
यदि पासवर्ड sshh है तो यह निर्देश व्यक्ति को आगे छोड़ देता है। यदि अक्षरों और संख्याओं का कोई अन्य संयोजन है, तो यह "प्रवेश निषेध" संदेश प्रदर्शित करता है।
बयान-अभिव्यक्ति अगर-एलिफ-अन्य
केवल यदि कई शर्तें सत्य नहीं हैं, तो ब्लॉक में दिए गए कथन को निष्पादित किया जाता है। अन्य. यह अभिव्यक्ति इस तरह काम करती है।
अगर शर्त_1:
#अगर ब्लॉक
कथन
कथन
अधिक कथन
एलिफ कंडीशन_2:
#पहला एलिफ ब्लॉक
कथन
कथन
अधिक कथन
एलिफ कंडीशन_3:
#दूसरा एलिफ ब्लॉक
कथन
कथन
अधिक कथन
...
अन्य
कथन
कथन
अधिक कथन
आप कितनी भी अतिरिक्त शर्तें निर्दिष्ट कर सकते हैं.
नेस्टेड स्टेटमेंट
कई शर्तों को लागू करने का एक और तरीका है कि अगर ब्लॉक में अतिरिक्त स्थिति की जाँच की जाए।
ऑपरेटर if एक और कंडीशन ब्लॉक के अंदर
gre_score = int (इनपुट ("अपनी वर्तमान क्रेडिट सीमा दर्ज करें"))
per_grad = int (इनपुट ("अपनी क्रेडिट रेटिंग दर्ज करें:"))
अगर प्रति_ग्रेड> 70:
# बाहरी अगर ब्लॉक
अगर ग्रे_स्कोर> 150:
# आंतरिक अगर ब्लॉक
प्रिंट ("बधाई हो, आपको ऋण मिला है")
अन्य:
प्रिंट ("क्षमा करें, आप ऋण के लिए पात्र नहीं हैं")
यह प्रोग्राम क्रेडिट रेटिंग जांच करता है। यदि यह 70 से कम है, तो प्रोग्राम रिपोर्ट करता है कि उपयोगकर्ता क्रेडिट के लिए पात्र नहीं है। यदि यह अधिक है, तो यह देखने के लिए दूसरी जांच की जाती है कि क्या वर्तमान क्रेडिट सीमा 150 से अधिक है। यदि हां, तो एक संदेश प्रदर्शित होता है कि ऋण जारी किया गया है।
यदि दोनों मान गलत हैं, तो एक संदेश प्रदर्शित होता है कि उपयोगकर्ता के पास ऋण प्राप्त करने की संभावना नहीं है।
अब उस प्रोग्राम को थोड़ा रीवर्क करते हैं।
gre_score = int (इनपुट ("वर्तमान सीमा दर्ज करें:"))
per_grad = int (इनपुट ("क्रेडिट स्कोर दर्ज करें:"))
अगर प्रति_ग्रेड> 70:
अगर ग्रे_स्कोर> 150:
प्रिंट ("बधाई हो, आपको ऋण मिला है")
अन्य:
प्रिंट ("आपकी क्रेडिट सीमा कम है")
अन्य:
प्रिंट ("क्षमा करें, आप क्रेडिट के लिए पात्र नहीं हैं")
कोड ही बहुत समान है, लेकिन नेस्टेड if यदि स्थिति गलत हो जाती है तो एक एल्गोरिदम भी प्रदान करता है। यही है, कार्ड की सीमा अपर्याप्त है, लेकिन क्रेडिट इतिहास अच्छा है, संदेश "आपके पास कम क्रेडिट रेटिंग है" प्रदर्शित होता है।
एक शर्त के अंदर अगर-और बयान अन्य
आइए एक और प्रोग्राम बनाते हैं जो टेस्ट स्कोर के आधार पर एक छात्र के ग्रेड को निर्धारित करता है।
स्कोर = इंट (इनपुट ("अपना स्कोर दर्ज करें:"))
अगर स्कोर>= 90:
प्रिंट ("बढ़िया! आपका ग्रेड ए है")
अन्य:
अगर स्कोर>= 80:
प्रिंट ("बढ़िया! आपका ग्रेड बी है")
अन्य:
अगर स्कोर>= 70:
प्रिंट ("अच्छा! आपका ग्रेड सी है")
अन्य:
अगर स्कोर>= 60:
प्रिंट ("आपका ग्रेड डी है। यह सामग्री को दोहराने लायक है।")
अन्य:
प्रिंट ("आप परीक्षा में असफल रहे")
एप्लिकेशन पहले यह देखने के लिए जांच करता है कि स्कोर 90 से अधिक या उसके बराबर है या नहीं। यदि हां, तो यह ए ग्रेड देता है। यदि यह स्थिति गलत है, तो बाद की जाँच की जाती है। हम देखते हैं कि पहली नज़र में एल्गोरिथ्म लगभग समान है। तो अंदर चेक करने के बजाय अन्य संयोजन का उपयोग करना बेहतर है अगर-एलिफ-अन्य.
तो ऑपरेटर if एक बहुत ही महत्वपूर्ण कार्य करता है - यह सुनिश्चित करता है कि कोड के कुछ टुकड़े केवल तभी निष्पादित किए जाते हैं जब इसकी आवश्यकता हो। इसके बिना प्रोग्रामिंग की कल्पना करना असंभव है, क्योंकि सबसे सरल एल्गोरिदम को भी कांटे की आवश्यकता होती है जैसे "यदि आप बाईं ओर जाते हैं, तो आप इसे पाएंगे, और यदि आप दाईं ओर जाते हैं, तो आपको यह और वह करने की आवश्यकता है।"