(पायथन) सबरूटीन्स: प्रक्रियाएं और कार्य - 1


<थ>विवरण <वें>कार्यक्रम <शरीर> <टीडी> <पूर्व> डीईएफ़ परीक्षण (): प्रिंट(i) <टीडी> <पूर्व> डीईएफ़ परीक्षण ():   मैं = 2 प्रिंट(i) <टीडी> <पूर्व> डीईएफ़ परीक्षण ():   वैश्विक i मैं = 2 #मुख्य कार्यक्रम मैं = 15 प्रिंट (मैं)


 

Training problem

स्थानीय और वैश्विक चर

सबरूटीन्स

एक सबरूटीन प्रोग्राम का एक अलग हिस्सा है जिसका एक नाम होता है और यह अपने अलग टास्क को हल करता है। उपनेमका मुख्य कार्यक्रम की शुरुआत में स्थित है और नाम निर्दिष्ट करके मुख्य कार्यक्रम से लॉन्च (बुलाया) जा सकता है।

सबरूटीन्स का उपयोग करने से आप कोड दोहराव से बच सकते हैं, अगर आपको प्रोग्राम में अलग-अलग जगहों पर एक ही कोड लिखने की आवश्यकता है। 
पुस्तकालय जो एक कार्यक्रम में आयात किए जाते हैं (उदाहरण के लिए, गणित पुस्तकालय गणित) में सबरूटीन्स होते हैं जो पहले से ही किसी के द्वारा संकलित किए गए हैं। प्रोग्रामर को यह सोचने की ज़रूरत नहीं है कि वे कौन से एल्गोरिदम लागू करते हैं, लेकिन केवल उन्हें लागू करते हैं, केवल यह सोचते हुए कि वे वास्तव में क्या कर रहे हैं। यह एक बड़ा समय बचाने वाला है। ऐसा एल्गोरिदम लिखने की कोई आवश्यकता नहीं है जो पहले से किसी और के द्वारा लिखा गया हो।

प्रत्येक उपनेमका केवल एक कार्य करना चाहिए,  या तो बस कुछ गणना करें, या कुछ डेटा आउटपुट करें, या कुछ और करें। 

सबरूटीन दो प्रकार के होते हैं - प्रक्रियाएंऔर फ़ंक्शन.

उप-प्रक्रियाएं कुछ क्रियाएं करती हैं, जैसे एक निश्चित रूप में स्क्रीन पर परिणाम प्रदर्शित करना (एक साधारण उदाहरण, <कोड>प्रिंट() कथन एक मानक उप-प्रक्रिया है जो स्क्रीन पर डेटा प्रिंट करता है)।

फंक्शन सबरूटीन्स रिटर्न रिटर्न (नंबर, कैरेक्टर स्ट्रिंग, आदि) जिसे हम मुख्य प्रोग्राम में इस्तेमाल कर सकते हैं।

आइए एक सरल प्रक्रिया लिखने का प्रयास करें:
मान लीजिए हमें स्क्रीन पर "त्रुटि" स्ट्रिंग प्रदर्शित करने की आवश्यकता है हर बार उपयोगकर्ता की गलती के कारण कोड में त्रुटि हो सकती है। उदाहरण के लिए, जब वह गलत डेटा दर्ज करता है।
यह कथन लिखकर किया जा सकता है प्रिंट ("त्रुटि") और अब कल्पना कीजिए कि इस तरह की लाइन को प्रोग्राम में कई जगहों पर डालने की जरूरत है। बेशक, आप इसे हर जगह लिख सकते हैं। लेकिन इस समाधान में दो कमियां हैं।
1) इस स्ट्रिंग को कई बार मेमोरी में स्टोर किया जाएगा।
2) अगर हम त्रुटि होने पर आउटपुट बदलना चाहते हैं, तो हमें इस लाइन को पूरे प्रोग्राम में बदलना होगा, जो काफी असुविधाजनक है

ऐसे मामलों के लिए प्रक्रियाओं की आवश्यकता होती है।
एक प्रक्रिया वाला प्रोग्राम ऐसा दिखाई दे सकता है:
  def PrintError(): # प्रक्रिया विवरण प्रिंट ("त्रुटि") ... PrintError() # निष्पादन के लिए प्रक्रिया शुरू करें। # बस उस प्रक्रिया का नाम निर्दिष्ट करें जिसे हम निष्पादित करना चाहते हैं ... प्रिंट त्रुटि ()
याद रखने की जरूरत है!
<ओल>
  • प्रक्रिया def शब्द से शुरू होती है (अंग्रेजी से - define - परिभाषित करने के लिए)। प्रक्रिया के नाम के बाद, खाली कोष्ठक और एक कोलन लिखा जाता है . पैरामीटर्स को ब्रैकेट्स के अंदर निर्दिष्ट किया जा सकता है (हम इसके बारे में बाद में बात करेंगे)।
  • एक प्रक्रिया में निष्पादित होने वाले सभी बयानों को इंडेंट किया जाता है। 
  • एक प्रक्रिया को निष्पादित करने के लिए, मुख्य कार्यक्रम में आपको इसे नाम से बुलाना होगा और कोष्ठक लिखना याद रखना होगा!
  • आप किसी प्रोग्राम में किसी प्रक्रिया को जितनी बार चाहें उतनी बार कॉल कर सकते हैं।

    • Training problem

    सबरूटीन्स: परिचय

    पैरामीटर और तर्क

    अब कल्पना करते हैं कि उपयोगकर्ता की त्रुटि के जवाब में हमें अलग-अलग संदेशों को प्रदर्शित करने की आवश्यकता है, यह इस बात पर निर्भर करता है कि उसने किस प्रकार की गलती की है।
    इस स्थिति में, आप प्रत्येक त्रुटि के लिए अपनी कार्यविधि लिख सकते हैं:   <पूर्व> डीईएफ़ PrintErrorZero (): प्रिंट ("त्रुटि। शून्य से विभाजन!") <पूर्व> डीईएफ़ PrintErrorInput (): प्रिंट ("इनपुट में त्रुटि!")
    क्या होगा यदि कई और संभावित त्रुटियां हैं? यह समाधान हमें शोभा नहीं देगा!
    हमें यह सीखने की जरूरत है कि प्रक्रिया को कैसे नियंत्रित किया जाए, यह बताकर कि कौन सा त्रुटि संदेश प्रदर्शित करना है।
    ऐसा करने के लिए, हमें उन मापदंडों की आवश्यकता होती है जिन्हें हम प्रक्रिया के नाम के बाद कोष्ठक में लिखेंगे <पूर्व> डीईएफ़ प्रिंट त्रुटि (ओं): प्रिंट("एस")
    इस प्रक्रिया में, s एक पैरामीटर है - एक विशेष चर जो आपको प्रक्रिया को नियंत्रित करने की अनुमति देता है।
     
    पैरामीटर एक वेरिएबल है जो यह निर्धारित करता है कि सबरूटीन कैसे काम करता है। सबरूटीन हेडर में पैरामीटर नाम अल्पविराम से अलग किए गए हैं।


    अब, प्रक्रिया को कॉल करते समय, आपको ब्रैकेट में वास्तविक मान इंगित करना होगा जो हमारी प्रक्रिया के अंदर पैरामीटर (वैरिएबल s) को असाइन किया जाएगा। <पूर्व> PrintError("त्रुटि! शून्य से विभाजन!")
    ऐसे मान को तर्क कहा जाता है।
     
    तर्क पैरामीटर मान है जो कॉल करने पर सबरूटीन को दिया जाता है।

    एक तर्क न केवल एक स्थिर मान हो सकता है, बल्कि एक चर या अंकगणितीय अभिव्यक्ति भी हो सकता है।

    Training problem

    पैरामीटर और तर्क

    स्थानीय और वैश्विक चर

    वेरिएबल्स जो मुख्य प्रोग्राम में पेश किए जाते हैं, उन्हें वैश्विक (या साझा) कहा जाता है।

    आप किसी भी उपनेमका से वैश्विक चरों तक पहुंच सकते हैं। 

    अतिरिक्त चरों को पेश करना अक्सर आवश्यक होता है जो केवल उपनेमका में उपयोग किया जाएगा। ऐसे चरों को स्थानीय (या स्थानीय) कहा जाता है। आप उनके साथ केवल उस सबरूटीन के अंदर काम कर सकते हैं जिसमें वे बनाए गए हैं। बाकी रुटीन उनके बारे में कुछ भी "पता" नहीं करते।

    इस प्रकार, एक चर के दायरे (दायरे) को केवल उपनेमका तक सीमित करना संभव है जहां इसकी वास्तव में आवश्यकता है। प्रोग्रामिंग में, इस तकनीक को एनकैप्सुलेशन  - चर को बाहर से बदलने से छिपाना।

    तीन कार्यक्रमों का विश्लेषण करें: <टेबल क्लास = "टेबल-बॉर्डर्ड टेबल-लिस्ट-टेस्ट टेबल-एसएम टेबल-स्ट्राइप्ड"> <सिर>
    1) इस प्रोग्राम में, वेरिएबल i लोकल है। यदि मुख्य प्रोग्राम में कोई i वेरिएबल नहीं है, तो हमें एक एरर मैसेज मिलेगा। और यदि ऐसा कोई चर है (तो यह एक वैश्विक चर है), तो इसका मान स्क्रीन पर प्रदर्शित होता है।
    2) यहां, भले ही एक वैश्विक चर i है, एक नया स्थानीय चर i 2 के मान के साथ बनाया जाएगा, और 2 उस पर दिखाई देगा स्क्रीन।
    3) इस प्रोग्राम में, एक ग्लोबल वेरिएबल i है जिसका मान 15 है। इसके मान को सबरूटीन के अंदर बदला जा सकता है, इसके लिए यह स्पष्ट रूप से घोषित करना आवश्यक है कि यह वैश्विक है ( वैश्विक कमांड का उपयोग करें।
    प्रक्रिया वैश्विक चर i के साथ काम करेगी और इसे 2 का एक नया मान दिया जाएगा। मान 2 प्रदर्शित किया गया है।