पायथन वैश्विक और स्थानीय चर के लिए गाइड

प्रोग्रामिंग में एक चर एक महत्वपूर्ण और सर्वव्यापी अवधारणा है। वेरिएबल डेटा स्टोर करने के लिए कंटेनर हैं। चर उपयोगकर्ता के ऑनलाइन गेम इन्वेंट्री में उपयोगकर्ता नाम, ईमेल पते और आइटम सहित कई प्रकार के डेटा संग्रहीत कर सकते हैं।

पायथन में प्रोग्रामिंग करते समय, आप दो प्रकार के चर का सामना करेंगे:वैश्विक और स्थानीय। इस गाइड में, हम इन दो प्रकार के चरों के बीच अंतर पर चर्चा करते हैं कि वे कैसे काम करते हैं, और आप उन्हें अपने कोड में कैसे उपयोग कर सकते हैं।

पायथन वैरिएबल

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

मान लीजिए कि हम एक गेम बना रहे हैं और उपयोगकर्ता का नाम संग्रहीत करना चाहते हैं। हमारे पूरे प्रोग्राम में नाम टाइप करने के बजाय, हम इसे स्टोर करने के लिए एक वेरिएबल का उपयोग कर सकते हैं।

यहां एक वेरिएबल दिया गया है जो गेम के लिए उपयोगकर्ता का नाम संग्रहीत करता है:

name = "Carlton Hernandez"

हमने name . नामक एक वैरिएबल घोषित किया है और इसे "कार्लटन हर्नांडेज़" मान दिया।

अब जब हमने उस वेरिएबल को घोषित कर दिया है, तो हम इसे अपने कोड में हेरफेर कर सकते हैं। उदाहरण के लिए, यदि हम अपने उपयोगकर्ता का नाम बदलना चाहते हैं, तो हम इस कोड का उपयोग करके ऐसा कर सकते हैं:

name = "Carlton Hernandez"
name = "Carlton Lewis Hernandez"

हमारे कोड की पहली पंक्ति पर, हमने "कार्लटन हर्नांडेज़" मान को name को असाइन किया है चर। फिर, हमने "कार्लटन लुईस हर्नांडेज़" मान को name . को सौंपा चर। जब आप किसी चर के लिए एक नया मान निर्दिष्ट करते हैं, तो प्रोग्राम सबसे हाल के मान को अधिलेखित कर देता है, इसे नए के साथ बदल देता है।

81% प्रतिभागियों ने कहा कि बूटकैंप में भाग लेने के बाद उन्हें अपनी तकनीकी नौकरी की संभावनाओं के बारे में अधिक आत्मविश्वास महसूस हुआ। आज ही एक बूटकैंप से मिलान करें।

बूटकैंप शुरू करने से लेकर अपनी पहली नौकरी खोजने तक, औसत बूटकैंप ग्रेड ने करियर संक्रमण में छह महीने से भी कम समय बिताया।

पायथन वैश्विक चर

पायथन में, दो मुख्य प्रकार के चर हैं:स्थानीय और वैश्विक।

वैश्विक चर एक फ़ंक्शन के बाहर घोषित चर हैं। वैश्विक चरों का वैश्विक दायरा होता है। इसका मतलब है कि उन्हें पूरे कार्यक्रम में एक्सेस किया जा सकता है, जिसमें फ़ंक्शन भी शामिल हैं। इस अवधारणा के निम्नलिखित दृश्य प्रतिनिधित्व पर विचार करें।

पायथन में वैश्विक और स्थानीय चर

एक वैश्विक चर पूरे कार्यक्रम में पहुँचा जा सकता है।

यहाँ पायथन में एक वैश्विक चर का एक उदाहरण दिया गया है:

name = "Carlton Hernandez"

एक बार जब हम एक वैश्विक चर घोषित कर देते हैं, तो हम इसे अपने पूरे कोड में उपयोग कर सकते हैं। उदाहरण के लिए, हम एक फ़ंक्शन बना सकते हैं जो हमारे वैश्विक चर name . द्वारा रखे गए मान को प्रिंट करता है निम्नलिखित कोड का उपयोग करना:

def printName():
	print(name)

printName()

हमारा कोड लौटाता है:

"Carlton Hernandez"

यहां, हमने printName() . नामक एक फंक्शन को इनिशियलाइज़ किया है . यह फ़ंक्शन, जब लागू किया जाता है, name . के मान को प्रिंट करता है कंसोल के लिए परिवर्तनीय। जब हमने फंक्शन को इनवाइट किया तो ऊपर यही हुआ।

पायथन स्थानीय चर

दूसरी ओर, स्थानीय चर, किसी फ़ंक्शन के अंदर घोषित चर हैं। इन चरों को local scope . के लिए जाना जाता है . इसका मतलब है कि उन्हें केवल उस फ़ंक्शन के भीतर पहुँचा जा सकता है जिसमें उन्हें घोषित किया गया है। इस दृश्य प्रतिनिधित्व पर फिर से विचार करें जिसे हमने पहले प्रदर्शित किया था जो कि पायथन में चर की अवधारणा को दर्शाता है:

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

एक स्थानीय चर केवल एक विशेष समारोह के भीतर पहुँचा जा सकता है।

निम्नलिखित एक प्रोग्राम का एक उदाहरण है जो स्थानीय चर का उपयोग करता है:

def printName():
	name = "Georgia Anderson"
	print(name)

printName()

हमारा कोड लौटाता है:

"Georgia Anderson"

हमारे कोड में, हमने printName() . नामक एक फ़ंक्शन घोषित किया है . उस फ़ंक्शन के भीतर, हमने name . नामक एक वेरिएबल को परिभाषित किया है . चूंकि हमने इस चर को एक फ़ंक्शन के भीतर घोषित किया है, यह एक स्थानीय चर है।

हमारे कोड के अंत में, हमने printName() . का उपयोग करके अपने फ़ंक्शन को कॉल किया . जवाब में, प्रोग्राम ने printName() को निष्पादित किया समारोह।

name इस उदाहरण में वेरिएबल printName() . के लिए स्थानीय है समारोह। इसलिए, हम उस वेरिएबल को अपने फंक्शन के बाहर एक्सेस नहीं कर सकते। जब हम इस स्थानीय name . को प्रिंट करने का प्रयास करते हैं तो यहां क्या होता है फ़ंक्शन के बाहर चर जिसमें इसे घोषित किया गया है:

def printName():
	name = "Georgia Anderson"
	print(name)

printName()
print(name)

हमारा कोड लौटाता है:

NameError: name 'name' is not defined

हम उस फ़ंक्शन के बाहर एक स्थानीय चर का उपयोग नहीं कर सकते हैं जिसमें हमने वह चर निर्दिष्ट किया है। जब हम अपने मुख्य कार्यक्रम में स्थानीय चर का उपयोग करने का प्रयास करते हैं, तो प्रोग्राम एक त्रुटि लौटाएगा।

वैश्विक और स्थानीय चर का उपयोग करना

एक प्रोग्राम के लिए स्थानीय और वैश्विक चर दोनों के लिए समान चर नाम का उपयोग करना संभव है। ऐसे परिदृश्य में, स्थानीय चर को स्थानीय दायरे में पढ़ा जाएगा, और वैश्विक चर को वैश्विक दायरे में पढ़ा जाएगा।

यहां एक ऐसे प्रोग्राम का उदाहरण दिया गया है जिसमें एक ही नाम के स्थानीय और वैश्विक चर हैं:

score = 5

def calculateScore():
	score = 10
	print("Final Score:", score)

calculateScore()
print("Initial Score:", score)

हमारा कोड लौटाता है:

Final Score: 10
Initial Score: 5

सबसे पहले, हमने वैश्विक चर score . असाइन किया है हमारे कोड में। फिर, हमारे calculateScore() . में फ़ंक्शन, हमने उसी नाम से एक स्थानीय चर बनाया है।

हमारे स्थानीय score . का मान calculateScore() में चर फ़ंक्शन 10 है। इसलिए, जब हम अपने calculateScore() . को कॉल करते हैं फ़ंक्शन, संदेश Final Score: 10 कंसोल पर प्रिंट किया जाता है।

हालांकि, हमारे calculateScore() . के बाहर फ़ंक्शन, score . का मान वेरिएबल 5 है। ऐसा इसलिए है क्योंकि हम score . का मान सेट करते हैं वैश्विक दायरे में परिवर्तनशील 5. इसलिए, जब हम Initial Score: . का प्रिंट आउट लेते हैं , उसके बाद score . का मान आता है चर, प्रोग्राम 5 मान प्रदर्शित करता है।

फ़ंक्शन के अंदर ग्लोबल वैरिएबल असाइन करना

उपरोक्त अनुभागों में, हमने सीखा कि वैश्विक चर एक फ़ंक्शन के बाहर परिभाषित होते हैं (यानी, विश्व स्तर पर), और स्थानीय चर एक फ़ंक्शन (यानी, स्थानीय रूप से) के अंदर परिभाषित होते हैं। हालाँकि, यदि आप global . का उपयोग करते हैं किसी फ़ंक्शन के भीतर एक चर को परिभाषित करने के लिए कीवर्ड (यानी, स्थानीय रूप से), और फिर उस फ़ंक्शन को प्रोग्राम (विश्व स्तर पर) में चलाएं, वह चर एक वैश्विक चर बन जाएगा।

निम्नलिखित उदाहरण पर विचार करें:

def setName():
	global name
	name = "Bianca Peterson"

setName()
print(name)

हमारा कोड लौटाता है:

"Bianca Peterson"

हमारे कोड में, हमने name . का मान निर्दिष्ट किया है स्थानीय रूप से चर, setName() . के अंदर समारोह। हालाँकि, क्योंकि हमने इस चर को परिभाषित करने से पहले वैश्विक कीवर्ड का उपयोग किया था, इसलिए हम name . देने की तैयारी करते हैं परिवर्तनीय वैश्विक दायरा। हालांकि, name वेरिएबल केवल बाद . के वैश्विक वैरिएबल बन जाएगा हम इस फ़ंक्शन को प्रोग्राम में चलाते हैं।

प्रोग्राम चलाने के बाद setName() फ़ंक्शन, किसी भी समय हम name . का उपयोग करते हैं हमारे प्रोग्राम में वेरिएबल, जैसा कि हमने तब किया था जब हमने print() . चलाया था फ़ंक्शन, प्रोग्राम हमारे द्वारा स्थानीय फ़ंक्शन में घोषित मान का उपयोग करेगा। ऐसा इसलिए है क्योंकि name चर अब एक वैश्विक चर है।

याद रखें कि हमने पहले कैसे कहा था कि सीधे . नहीं हो सकता किसी फ़ंक्शन के अंदर वैश्विक चर बदलें? यह सच है। हालाँकि, आप किसी फ़ंक्शन के अंदर वैश्विक चर को अप्रत्यक्ष रूप से बदलने के लिए वैश्विक कीवर्ड का उपयोग कर सकते हैं।

यहां एक प्रोग्राम का उदाहरण दिया गया है, जो किसी फ़ंक्शन में ग्लोबल वेरिएबल के मान को बदलने के लिए ग्लोबल कीवर्ड का उपयोग करता है:

name = "Bianca Peterson"

def setName():
	global name
	name = "Bianca Lucinda Peterson"

setName()
print(name)

हमारा कोड लौटाता है:

"Bianca Lucinda Peterson"

आइए इस कोड को तोड़ दें। सबसे पहले, हमने name . नामक एक वेरिएबल घोषित किया और इसे "बियांका पीटरसन" मान दिया। यह एक वैश्विक चर है। फिर, हमने setName() . नामक एक फ़ंक्शन घोषित किया . कॉल करने पर, setName() फ़ंक्शन name . के मान को बदल देता है चर।

इसके बाद हमने setName() . को कॉल किया फ़ंक्शन, जिसने name . का मान बदल दिया "बियांका लुसिंडा पीटरसन" के लिए। अंत में, हमने name . का मान प्रिंट किया कंसोल को। वैश्विक चर का मान name अब "बियांका लुसिंडा पीटरसन" है।

सामान्यतया, वैश्विक कीवर्ड का संयम से उपयोग किया जाना चाहिए। अक्सर ग्लोबल कीवर्ड का उपयोग करने से प्रोग्राम में वेरिएबल के दायरे को समझना मुश्किल हो सकता है।

निष्कर्ष

वैश्विक चर एक फ़ंक्शन के बाहर घोषित चर हैं। स्थानीय चर एक फ़ंक्शन के अंदर घोषित चर हैं।

जबकि वैश्विक चर को किसी फ़ंक्शन में सीधे नहीं बदला जा सकता है, आप एक ऐसा फ़ंक्शन बनाने के लिए वैश्विक कीवर्ड का उपयोग कर सकते हैं जो वैश्विक चर के मान को बदल देगा। इस मामले में, वैश्विक चर का मान वास्तव में तब तक नहीं बदलेगा जब तक आप उस फ़ंक्शन को नहीं चलाते।

इस ट्यूटोरियल में उदाहरणों के संदर्भ में, स्थानीय और वैश्विक चरों की मूल बातें और वे कैसे काम करते हैं, इस पर चर्चा की गई। अब आप एक पेशेवर प्रोग्रामर की तरह अपने पायथन कोड में स्थानीय और वैश्विक चर का उपयोग शुरू करने के लिए तैयार हैं!