Python वेरिएबल्स आरक्षित मेमोरी लोकेशंस होते हैं, जिनका उपयोग प्रोग्राम में मान (values) स्टोर करने के लिए किया जाता है। जब आप एक वेरिएबल बनाते हैं, तो आप मेमोरी में कुछ स्थान आरक्षित करते हैं।
वेरिएबल के डेटा टाइप के आधार पर, Python इंटरप्रेटर मेमोरी आवंटित करता है और यह तय करता है कि उस आरक्षित मेमोरी में क्या स्टोर किया जा सकता है। उदाहरण के लिए, अलग-अलग डेटा टाइप्स जैसे कि पूर्णांक (integers), दशमलव (decimals), या कैरेक्टर (characters) को वेरिएबल्स में स्टोर किया जा सकता है।
कंप्यूटर की मेमोरी में विभिन्न डेटा टाइप्स के आइटम्स को स्टोर किया जाता है। प्रत्येक मेमोरी लोकेशन का एक पता (address) होता है, जो बाइनरी रूप में होता है। कंप्यूटर बाइनरी फॉर्मेट पर काम करता है, इसलिए डेटा भी बाइनरी में स्टोर होता है।
उदाहरण के लिए, नीचे दिए गए चित्र में एक स्ट्रिंग “May” और एक संख्या 18 मेमोरी लोकेशंस में स्टोर की गई हैं:
(मेमोरी डायग्राम)
अ
आप असेंबली भाषा जानते हैं, तो आप इन डेटा आइटम्स और मेमोरी एड्रेस को मशीनी भाषा (machine language) में बदल सकते हैं। हालाँकि, यह सबके लिए आसान नहीं है। Python जैसे उच्च स्तरीय भाषाएँ (high-level languages) इन जटिलताओं को छिपा कर रखती हैं। Python का इन-बिल्ट id() फंक्शन उस स्थान का पता (address) लौटाता है जहाँ डेटा ऑब्जेक्ट स्टोर किया गया है।
>>> "May"
May
>>> id("May")
2167264641264
>>> 18
18
>>> id(18)
140714055169352
मेमोरी में स्टोर किए गए डेटा को बार-बार एक्सेस करने के लिए हमें उसका पता (ID) याद रखने की ज़रूरत होती है, जो मुश्किल हो सकता है। Python जैसी उच्च-स्तरीय भाषाएँ हमें मेमोरी लोकेशन के लिए उपयुक्त नाम या पहचान (label) देती हैं ताकि हम उस डेटा को आसानी से एक्सेस कर सकें।
उदाहरण के लिए, “May” के मेमोरी लोकेशन को हम month नाम दे सकते हैं और 18 के लोकेशन को age नाम से संदर्भित कर सकते हैं। Python में = ऑपरेटर का उपयोग करके आप वेरिएबल्स को ऑब्जेक्ट्स से बाँध सकते हैं:
>>> month = "May" >>> age = 18
यहाँ, डेटा ऑब्जेक्ट “May” और उसका नाम month का id() समान होगा। इसी तरह, age और 18 का id() भी समान होगा:
>>> id(month) 2167264641264 >>> id(age) 140714055169352
वेरिएबल्स को पहचानकर्ता (identifier) कहा जाता है। यह एक प्रतीकात्मक नाम (symbolic name) होता है, जो किसी ऑब्जेक्ट का संदर्भ या पॉइंटर होता है। Python में वेरिएबल्स का उपयोग करके आप आसानी से डेटा को स्टोर और एक्सेस कर सकते हैं, बिना मेमोरी लोकेशन की चिंता किए।
इस प्रकार Python में वेरिएबल्स का उपयोग आसान और प्रभावी होता है, जिससे आप प्रोग्रामिंग में आसानी से डेटा स्टोर और एक्सेस कर सकते हैं।
counter = 100 # इंटीजर वेरिएबल बनाता है miles = 1000.0 # फ्लोटिंग पॉइंट वेरिएबल बनाता है name = "Zara Ali" # स्ट्रिंग वेरिएबल बनाता है
counter = 100 # इंटीजर वेरिएबल miles = 1000.0 # फ्लोटिंग पॉइंट वेरिएबल name = "Zara Ali" # स्ट्रिंग वेरिएबल print(counter) print(miles) print(name)इस कोड का आउटपुट इस प्रकार होगा:
100 1000.0 Zara Aliयहां, 100, 1000.0 और “Zara Ali” वे वैल्यूज हैं जिन्हें क्रमशः counter, miles, और name वेरिएबल्स में असाइन किया गया है।
Python में वेरिएबल को डिलीट करने के लिए आप del स्टेटमेंट का उपयोग कर सकते हैं। इसका सिंटैक्स इस प्रकार है:
del var1[, var2[, var3[...., varN]]]
आप एक या एक से अधिक वेरिएबल्स को एक साथ डिलीट कर सकते हैं। उदाहरण के लिए:
del var del var_a, var_b
उदाहरण: वेरिएबल्स को डिलीट करना
यह उदाहरण दिखाता है कि कैसे वेरिएबल्स को डिलीट किया जाता है और डिलीट किए गए वेरिएबल को दोबारा उपयोग करने पर क्या होता है:
counter = 100 print(counter) # यह 100 प्रिंट करेगा del counter print(counter) # यह एक एरर देगा
आउटपुट:
100
Traceback (most recent call last):
File "main.py", line 7, in
print(counter)
NameError: name 'counter' is not definedजब आप counter वेरिएबल को डिलीट करते हैं और फिर उसे प्रिंट करने की कोशिश करते हैं, तो Python एक NameError देगा क्योंकि वेरिएबल डिलीट हो चुका है।
आप किसी भी Python वेरिएबल का डेटा टाइप जानने के लिए बिल्ट-इन type() फ़ंक्शन का उपयोग कर सकते हैं। उदाहरण के लिए:
x = "Zara" y = 10 z = 10.10 print(type(x)) # <class 'str'> print(type(y)) # <class 'int'> print(type(z)) # <class 'float'>
आउटपुट:
<class 'str'> <class 'int'> <class 'float'>
इस उदाहरण में, x एक स्ट्रिंग (string), y एक इंटीजर (integer), और z एक फ्लोट (float) वैल्यू है।
x = str(10) # x होगा '10'
y = int(10) # y होगा 10
z = float(10) # z होगा 10.0
print("x =", x)
print("y =", y)
print("z =", z)
यह परिणाम उत्पन्न करेगा:
x = 10 y = 10 z = 10.0
age = 20
Age = 30
print("age =", age)
print("Age =", Age)
यह परिणाम उत्पन्न करेगा:
age = 20 Age = 30
a = b = c = 10 print(a, b, c)यह परिणाम देगा:
10 10 10यदि हमारे पास तीन वेरिएबल्स हैं जिनमें अलग-अलग मान हैं:
a = 10 b = 20 c = 30इन अलग-अलग असाइनमेंट स्टेटमेंट्स को एक में संयोजित किया जा सकता है:
a, b, c = 10, 20, 30 print(a, b, c)यह परिणाम देगा:
10 20 30आइए कुछ उदाहरणों को स्क्रिप्ट मोड में आजमाते हैं:
a = b = c = 100 print(a) print(b) print(c)यह परिणाम देगा:
100 100 100यहां, एक इंटीजर ऑब्जेक्ट का निर्माण किया गया है जिसका मान 1 है, और सभी तीन वेरिएबल्स को एक ही मेमोरी लोकेशन पर असाइन किया गया है। आप एक से अधिक ऑब्जेक्ट्स को एक से अधिक वेरिएबल्स पर भी असाइन कर सकते हैं। उदाहरण के लिए:
a, b, c = 1, 2, "Zara Ali" print(a) print(b) print(c)यह परिणाम देगा:
1 2 Zara Ali
counter = 100 _count = 100 name1 = "Zara" name2 = "Nuha" Age = 20 zara_salary = 100000 print(counter) print(_count) print(name1) print(name2) print(Age) print(zara_salary)यह परिणाम देगा:
100 100 Zara Nuha 20 100000उदाहरण निम्नलिखित पायथन वेरिएबल नाम अमान्य हैं:
1counter = 100 $_count = 100 zara-salary = 100000 print(1counter) print($count) print(zara-salary)यह परिणाम देगा:
File "main.py", line 3
1counter = 100
^
SyntaxError: invalid syntax
पायथन लोकल वेरिएबल्स
पायथन लोकल वेरिएबल्स को एक फ़ंक्शन के अंदर परिभाषित किया जाता है। हम वेरिएबल को फ़ंक्शन के बाहर एक्सेस नहीं कर सकते हैं।
एक पायथन फ़ंक्शन एक पुन: प्रयोज्य कोड का एक टुकड़ा है और आप पायथन – फ़ंक्शंस ट्यूटोरियल में इसके बारे में और जानेंगे।
उदाहरण
यहां एक उदाहरण है जो लोकल वेरिएबल्स के उपयोग को प्रदर्शित करता है:
def sum(x, y): sum = x + y return sum print(sum(5, 10))यह परिणाम देगा:
15पायथन ग्लोबल वेरिएबल्स कोई भी वेरिएबल जो एक फ़ंक्शन के बाहर बनाया गया है, किसी भी फ़ंक्शन के अंदर एक्सेस किया जा सकता है और इस प्रकार उनके पास ग्लोबल स्कोप होता है। उदाहरण यहां ग्लोबल वेरिएबल्स का एक उदाहरण है:
x = 5 y = 10 def sum(): sum = x + y return sum print(sum()) 15
में वेरिएबल्स की अवधारणा अलग-अलग तरह से काम करती है। C/C++ में, वेरिएबल एक नामित मेमोरी स्थान होता है। उदाहरण के लिए, अगर a=10 और b=10 है, तो दोनों अलग-अलग मेमोरी लोकेशन्स होते हैं। मान लीजिए कि इनकी मेमोरी एड्रेस क्रमशः 100 और 200 है।
C/C++ में नामित मेमोरी स्थान:
अगर a को कोई दूसरा मान दिया जाता है, जैसे 50, तो एड्रेस 100 पर 10 की जगह 50 ओवरराइट हो जाएगा।
लेकिन Python में वेरिएबल मेमोरी लोकेशन का नाम नहीं होता, बल्कि यह ऑब्जेक्ट को संदर्भित करता है। एक ऑब्जेक्ट मेमोरी में केवल एक बार स्टोर होता है, और विभिन्न वेरिएबल्स वास्तव में उसी ऑब्जेक्ट के लिए अलग-अलग लेबल होते हैं।
Python में वेरिएबल्स:
जब आप a=50 लिखते हैं, तो यह मेमोरी में एक नया int ऑब्जेक्ट 50 बनाता है, जो किसी अन्य लोकेशन पर स्टोर होता है। b अभी भी 10 को रेफर कर रहा होता है।
अगर आप b को कोई नया मान देते हैं, तो ऑब्जेक्ट 10 अनरेफर्ड (unreferred) रह जाता है। Python का गार्बेज कलेक्टर उस ऑब्जेक्ट के लिए इस्तेमाल की गई मेमोरी को रिलीज कर देता है, जिसका कोई रेफरेंस नहीं बचा होता।
उदाहरण:
>>> a = b = 10 >>> a is b True >>> id(a), id(b) (140731955278920, 140731955278920)
यहां a और b दोनों का id समान है, जिससे पता चलता है कि दोनों एक ही ऑब्जेक्ट को संदर्भित कर रहे हैं।
