पाइथन में वेरिएबल्स: ये क्या हैं और इनके प्रकार क्या हैं

पाइथन में डेटा को कैसे संग्रहित करें ताकि उस तक पहुँचना आसान और सुखद हो।

यदि आप पाइथन में किसी भी कार्यक्रम को खोलते हैं, तो आप संभवतः बहुत सारी समानताएँ देखेंगे:

x = 4
name = 'Victoria'
coin_flipping_result = ['Eagle', 'Heads', 'Heads', 'Eagle']

ये सभी — वेरिएबल्स हैं। प्रोग्रामर वेरिएबल्स का उपयोग करते हैं ताकि वे कंप्यूटर की मेमोरी में डेटा संग्रहीत कर सकें और उसके साथ विभिन्न ऑपरेशन कर सकें। हमारी कहानी यहीं से शुरु होती है।

पाइथन में वेरिएबल क्या है

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

• नाम, या पहचानकर्ता, यह नाम होता है जिसे प्रोग्रामर द्वारा वेरिएबल को संदर्भित करने के लिए गढ़ा गया है। ऊपर दिए गए उदाहरणों में ये x, name और coin_flipping_result हैं।
• मान, यह वह जानकारी होती है जो कंप्यूटर की मेमोरी में संग्रहित होती है और जिसके साथ प्रोग्राम काम करता है। ऊपर दिए गए उदाहरणों में ये 4, ‘विक्टोरिया’ और [‘ईगल’, ‘हेड्स’, ‘हेड्स’, ‘ईगल’] हैं। ये हमेशा किसी न किसी डेटा प्रकार के सदस्य होते हैं।
• पता, यह कंप्यूटर मेमोरी की सेल का नंबर होता है जिसमें वेरिएबल का मान संग्रहित होता है।

एक ज्वलंत उदाहरण लें। कल्पना कीजिए कि एक बड़ा औद्योगिक गोदाम, जो अलमारियों से भरा हुआ है, जिन पर बक्से रखे हुए हैं। गोदाम — यह कंप्यूटर की सामान्य मेमोरी है। मान लीजिए, तीसरी अलमारी के दूसरे शेल्फ पर, छठे सेल में कोई बक्सा रखा हुआ है। यदि आप उसमें कुछ डालें और उस पर एक लेबल चिपका दें — बक्सा एक वेरिएबल होगा। उसमें जो कुछ भी होता है वह उसका मान होता है; तीसरी अलमारी, दूसरी शेल्फ, पांचवीं सेल — यह उसका पता होता है, और लेबल — यह उसका नाम होता है।

वेरिएबल्स के नाम कैसे देते हैं

पाइथन भाषा में वेरिएबल बनाते समय, प्रोग्रामर नामकरण के कुछ नियमों के अनुसार नाम देते हैं:

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

कुछ उदाहरण दें।

वेरिएबल्स के नाम दे सकते हैं: x, X, xyz, _x_y_z, XYZ, xyz_123, _123, x1Y2z2। वेरिएबल्स के नाम नहीं दे सकते: १, १x, x y z, x&y।

पाइथन मामले के प्रति सचेत है। इस प्रकार, name और Name को अलग-अलग वेरिएबल्स माना जाएगा।

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

print('Hello, world!')
>>> Hello, world!
print = 14
print('Hello, world')
>>> TypeError: 'int' object is not callable

हम थोड़ी देर में समझाएंगे कि ऐसा क्यों होता है।

वेरिएबल नेमिंग स्टाइल्स 

Python सिंटैक्स विभिन्न नामकरण शैलियों के उपयोग की अनुमति देता है:

1. lowercase — सभी अक्षर छोटे;
2. lower_case_with_underscores — सभी अक्षर छोटे, शब्दों के बीच में अंडरस्कोर;
3. UPPERCASE — सभी अक्षर बड़े;
4. UPPER_CASE_WITH_UNDERSCORES — सभी अक्षर बड़े, शब्दों के बीच में अंडरस्कोर;
5. CamelCase — प्रत्येक शब्द की शुरुआत एक बड़े अक्षर से होती है;
6. mixedCase — प्रथम शब्द को छोड़कर प्रत्येक शब्द की शुरुआत एक बड़े अक्षर से होती है;
7. Camel_Case_With_Underscores — प्रत्येक शब्द की शुरुआत एक बड़े अक्षर से होती है, शब्दों के बीच में अंडरस्कोर (यह असुंदर है, कभी भी ऐसा न करें)। तथापि, Python डेवलपर्स में PEP 8 मानक स्वीकार किया गया है – जो एक गाइड है जिसमें कोड को स्वरूपित करने की सिफारिशें दी गई हैं। अर्थात समुदाय ने स्वयं वेरिएबल्स को नाम देने के लिए अतिरिक्त प्रतिबंध स्थापित किए हैं:

• lowercase का प्रयोग करें, जरूरत पड़ने पर शब्दों को अंडरस्कोर्स से विभाजित करें, यदि यह पठनीयता में सुधार के लिए ज़रूरी हो;
• यदि किसी तैयार प्रोजेक्ट में mixedCase प्रचलित है, तो उसी शैली में लिखें – ताकि पिछली संगतता बनी रहे;
• नाम न दें l (छोटा L), O (बड़ा o) और I (बड़ा i) – कुछ फॉन्ट्स में वे शून्य और एक से अप्रभेद्य हैं। PEP 8 की सलाह का पालन करें ताकि आपका कोड समझने में आसान और आसानी से अनुरक्षणीय बना रहे।

Python में वेरिएबल घोषित करना और उसे मान असाइन करना

Python एक डायनामिक टाइपिंग भाषा है। इसका मतलब है कि मानों को वेरिएबल्स को संकलन के समय नहीं, बल्कि प्रोग्राम निष्पादन के समय प्रत्येक पंक्ति में असाइन किया जाता है।

इसलिए Python में वेरिएबल को अलग से घोषित करने की जरूरत नहीं है — बस उसे इनिशियलाइज करना पर्याप्त है, अर्थात् मान असाइन करना। इसके लिए बराबर का चिह्न = का उपयोग किया जाता है।

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

x = 4
print(x)
# Output: 4
x = 'Word'
print(x)
# Output: Word

स्टैटिक टाइपिंग भाषाओं में, जैसे कि C++ और Java, यह कृत्य संभव नहीं होता: कॉम्पाइलर एक त्रुटि के बारे में सूचित करेगा — क्योंकि वेरिएबल मूल रूप से एक पूर्णांक संग्रहीत करता था, न कि एक स्ट्रिंग। लेकिन Python में यह संभव है, क्योंकि वेरिएबल डेटा पर सीधे नहीं, बल्कि उनके मेमोरी पते पर रेफर करते हैं।

वेरिएबल इनिशियलाइजेशन कैसे काम करता है

 Python में, सभी डेटा ऑब्जेक्ट के रूप में प्रस्तुत किए जाते हैं। प्रत्येक की अपनी एक पहचानकर्ता होती है – मेमोरी का वह क्षेत्र का पता, जहां यह स्थित होता है।

इस पहचानकर्ता को id() फ़ंक्शन की मदद से जाना जा सकता है:

x = 4
print(id(x))
# 2056817043856

जब हमने x को इनिशियल किया, प्रोग्राम ने एक ऑब्जेक्ट का निर्माण किया जिसमें संख्या 4 थी, जो int डेटा प्रकार के ब्रांच का होता है।

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

y = 4
print(id(y))
# 2056817043856

यह इस प्रकार होता है: एक ऑब्जेक्ट, एक पता, लेकिन उस पर रेफर करने वाले दो वेरिएबल होते हैं।

किसी भी मोमेंट में हम वेरिएबल को नया मान असाइन कर सकते हैं। उसके बाद वह दूसरे ऑब्जेक्ट की ओर संकेत करने लगेगा:

x = 1.2
y = 'String'

अब x और y दूसरे ऑब्जेक्टों की ओर संकेत करते हैं, जिनके पते अलग हैं। और चूंकि अब कोई दूसरा वेरिएबल 2056817043856 पते पर मौजूद ऑब्जेक्ट पर संकेत नहीं करता है, इसलिए उसे स्वचालित रूप से कचरा संग्रहक द्वारा हटा दिया जाएगा।

मल्टीपल वैल्यू असाइनमेंट

जब आपको कई वेरिएबल्स को एक ही मान असाइन करना होता है, तो आप निम्नलिखित स्ट्रक्चर का उपयोग करके एक ही लाइन में ऐसा कर सकते हैं:

x = y = z = 4

इसकी जाँच करें:

print(x, y, z)
# Output: 4 4 4

विभिन्न मान असाइन करने के लिए भी एक तरीका है:

x, y, z = 1, 'Traveler', ['List', 'with', 'Strings']
print(x, y, z)
# Output: 1 Traveler ['List', 'with', 'Strings']

वेरिएबल्स का इम्पोर्ट

यदि किसी वेरिएबल को दूसरी फाइल से इम्पोर्ट करने की आवश्यकता हो, तो निम्नलिखित संरचना का उपयोग करें: from <फाइल नाम> import <वेरिएबल नाम>।

उदाहरण के लिए, हमारे पास variables1.py नामक एक फाइल है:

name = 'Victoria'
age = 23
city = 'Delhi'

variables2.py फाइल में name वेरिएबल का उपयोग करें:

from variables1 import name
print(name)
# Output: Victoria

इस स्थिति में, अन्य वेरिएबल्स के लिए पहुंच नहीं होती है:

from variables1 import name
print(age)
# Error: NameError: name 'age' is not defined

कई वेरिएबल्स को इम्पोर्ट करने के लिए, उन्हें कमा के माध्यम से सूचीबद्ध करें:

from variables1 import name, age
print(name, age)
# Output: Victoria 23

सभी ऑब्जेक्टों को इंपोर्ट करने के लिए import के बाद एक तारांकन (*) डालें:

from variables1 import *
print(name, age, city)
# Output: Victoria 23 Delhi

वेरिएबल्स को डिलीट करना

वेरिएबल को डिलीट करने के लिए del कुंजीशब्द का उपयोग करें:

x = 4
del x
print(x)
# Error: NameError: name 'x' is not defined

पायथन में वेरिएबल्स के प्रकार

Python में सभी वेरिएबल्स विशिष्ट विजिबिलिटी स्कोप्स में मौजूद होते हैं। Python में तीन प्रकार के होते हैं:

• लोकल — एक फ़ंक्शन के अंदर;
• ग्लोबल — पूरे प्रोग्राम (py-फ़ाइल) के अंदर;
• नॉनलोकल — दो सटे हुए फ़ंक्शन्स (इनर और आउटर) के अंदर। वेरिएबल्स जो एक विशेष स्कोप के अंतर्गत आते हैं, उस स्कोप के नेमस्पेस का निर्माण करते हैं।

स्थानीय चर

 कोई भी चर जो फ़ंक्शन के अंदर घोषित किए गए हैं, वे केवल उसी फ़ंक्शन में रहते हैं। उदाहरण के लिए:

def local_namespace():
    x = 4
    x = x ** 2
    return x
print(local_namespace())
>>> 16

हम x के साथ, सामान्यतया, प्रबंध कर सकते हैं: मान बदलना, संचालन करना, वापस लौटाना – लेकिन केवल जब तक हम इसे फ़ंक्शन local_namespace() के अंदर करें।

अगर हम x से कहीं और प्रोग्राम के अन्य भाग में संपर्क करना चाहें, तो इंटरप्रेटर उसे नहीं देख पाएगा:

def local_namespace():
    x = 4
    x = x ** 2
    return x
print(x)
>>> NameError: name 'x' is not defined

और इसके विपरीत: फ़ंक्शन केवल उन्हीं चरों को प्रबंधित कर सकता है जो उसके अंदर हैं:

x = 4
def local_namespace():
    x = x ** 2
    return x
print(local_namespace())
>>> UnboundLocalError: local variable 'x' referenced before assignment

तथापि, फ़ंक्शन ग्लोबल दृष्टि क्षेत्र से चरों को पढ़ सकता है — बस उन्हें बदलने का अधिकार नहीं है।

x = 4
def local_namespace():
    y = x ** 2
    return y
print(x)
print(local_namespace())
>>> 4
>>> 16

अंत में, एक ही प्रोग्राम के भीतर कई चरों के साथ एक ही नाम हो सकता है। इसके लिए उन्हें विभिन्न नामस्थानों में होना चाहिए:

x = 0
def local_namespace():
    x = 4
    x = x ** 2
    return x
print(x)
print(local_namespace())
>>> 0
>>> 16

ग्लोबल चर

 कोई भी चर जो फ़ंक्शंस के बाहर घोषित किया गया है, ग्लोबल है। वह पूरे py-फ़ाइल के नामस्थान में मौजूद होता है।

जैसा कि हमने ऊपर दिखाया, इसे फ़ंक्शन के अंदर से संपर्क किया जा सकता है, लेकिन बदला नहीं जा सकता। इसे ठीक करने के लिए, global कीवर्ड मौजूद है:

x = 4
def local_namespace():
    global x
    x = x ** 2
    return x
print(local_namespace())
>>> 16

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

def local_namespace():
    global x
    x = 4
    return x
print(local_namespace())
print(x)
>>> 4
>>> 4

नॉनलोकल चर

 नॉनलोकल चर का प्रयोग होता है जब एक फ़ंक्शन दूसरे में निहित होता है, और केवल इन दो फ़ंक्शंस के नामस्थान को शामिल करते हैं।

इन्हें nonlocal कीवर्ड के साथ बनाया जाता है।

def nonlocal_namespace():
    x = 4
    def local_namespace():
        nonlocal x
        x = x ** 2
        return x
    return local_namespace()
print(nonlocal_namespace())
>>> 16

इसी तरह, ग्लोबल दृष्टि क्षेत्र में हम नॉनलोकल चर से संपर्क नहीं कर सकते:

def nonlocal_namespace():
    x = 4
    def local_namespace():
        nonlocal x
        x = x ** 2
        return x
    return local_namespace()
print(x)
>>> NameError: name 'x' is not defined

चर की मौजूदगी की जांच 

पायथन में globals() और locals() फ़ंक्शंस होते हैं। वे ग्लोबल और लोकल सिम्बलों की तालिका के साथ एक डिक्शनरी

लौटाते हैं। उनमें, चरों के बारे में डेटा भी शामिल होता है।

इन डिक्शनरियों में कुंजी एक चर के नाम के साथ एक स्ट्रिंग होती है — इस तरह से आप उसकी मौजूदगी की जांच कर सकते हैं:

name = 'Victoria'
if 'name' in globals():
    print(True)
# Output: True

इसी तरह से इस डिक्शनरी से चर के नाम से उसकी मान प्राप्त कर सकते हैं:

name = 'Victoria'
if 'name' in globals():
    print(globals().get('name'))
# Output: Victoria

यही बात लोकल दृष्टि क्षेत्र में की जा सकती है:

def local_namespace():
    name = 'Victoria'
    if 'name' in locals():
        print(locals().get('name'))
local_namespace()
# Output: Victoria

चर की अधिकतम संभव मान

 पायथन में, बड़ी संख्याओं को संग्रहीत करने के लिए कोई विशेष डेटा प्रकार नहीं है। सभी पूर्णांक int कक्षा के हैं, सभी प्लविंग कॉमा नंबर्स float कक्षा के हैं।

इसके अलावा, इन कक्षाओं में कोई सीमा नहीं है। किसी भी प्रकार का चर कितना भी बड़ा मान ले सकता है, जब तक कंप्यूटर की मेमोरी पर्याप्त हो।

प्रिंटिंग सिंगल और मल्टीपल वेरिएबल्स

प्रिंटिंग के लिए Python में print() फ़ंक्शन का उपयोग किया जाता है। आप एकल वेरिएबल या कई वेरिएबल्स को कॉमा से अलग करके प्रिंट कर सकते हैं:

name, age, city = 'Victoria', 23, 'Delhi'
print(name)
print(name, age, city)
# Output:
# Victoria
# Victoria 23 Delhi

Python में वेरिएबल्स को प्रिंट करने के लिए फॉर्मैटिंग का भी विकल्प है। इसके लिए कई तरीके हैं लेकिन सबसे सुविधाजनक तरीका f-स्ट्रिंग्स है। प्रिंट फ़ंक्शन में एक स्ट्रिंग पास करें जिसके सामने f लेटर हो। वेरिएबल्स को ब्रेसिज़ में रखा जाता है: {वेरिएबल नाम}।

name, age, city = 'Victoria', 23, 'Delhi'
print(f'Name: {name}. Age: {age}. City: {city}.')
# Output: Name: Victoria. Age: 23. City: Delhi.

अंतिम निष्कर्ष

• Python में वेरिएबल्स का निर्माण नाम और मान से होता है। वे स्वयं के मान को नहीं बल्कि मैमोरी में उसके एड्रेस की लिंक को स्टोर करते हैं।
• उनके नामकरण के लिए अंक (प्रथम चरित्र के रूप में नहीं हो सकते), लैटिन अक्षर, और अंडरस्कोर का उपयोग किया जाता है।
• Python में अलग से वेरिएबल की घोषणा नहीं करनी पड़ती – उन्हें सीधे मान असाइन किया जाता है। एक ही पंक्ति में कई वेरिएबल्स बनाई जा सकती हैं।
• वे एक विशिष्ट स्कोप के अंदर मौजूद होते हैं। वेरिएबल्स ग्लोबल (सम्पूर्ण प्रोग्राम के भीतर), लोकल (एक फंक्शन के भीतर), और नॉन-लोकल (दो डवली नेस्टेड फंक्शन के बीच) हो सकते हैं।
• Python में वेरिएबल्स के आकार पर कोई सीमा नहीं है – वे उतने बड़े हो सकते हैं जितनी मैमोरी डिवाइस में उपलब्ध हो।
• उन्हें अन्य फाइलों से इम्पोर्ट किया जा सकता है, हटाया जा सकता है, उनके मौजूद होने की जाँच की जा सकती है, और फॉर्मेटेड स्ट्रिंग में प्रिंट किया जा सकता है।