Python में अंडरस्कोर(_) की भूमिका ट्यूटोरियल

कई Python डेवलपर्स को Python में अंडरस्कोर(_) की खूबियों के बारे में जानकारी नहीं होती। यह उपयोगकर्ताओं को Python कोड उत्पादक ढंग से लिखने में मदद करता है।

अंडरस्कोर(_) Python में एक खास कैरेक्टर है।

यदि आप Python प्रोग्रामर हैं, तो आप निम्न सिंटैक्स से संभवतः परिचित होंगे:

• for _ in range(100)

• __init__(self)

• _ = 2

विभिन्न परिस्थितियों में इसका अलग अर्थ होता है। आइए सभी को देखें।

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

1. इंटरप्रेटर में उपयोग

Python इंटरप्रेटर में आखिरी अभिव्यक्ति का मान अपने आप "_" नामक एक विशेष वेरिएबल में संग्रहीत करता है। यदि आप चाहें तो इस मान को किसी अन्य वेरिएबल को भी असाइन कर सकते हैं।

आप इसे सामान्य वेरिएबल की तरह उपयोग कर सकते हैं। उदाहरण देखें

>>> 5 + 4
9
>>> _     # stores the result of the above expression
9
>>> _ + 6
15
>>> _
15
>>> a = _  # assigning the value of _ to another variable
>>> a
15

2. मानों को अनदेखा करना

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

अनदेखा करने का अर्थ है मानों को विशेष वेरिएबल अंडरस्कोर(_) को असाइन करना। हम मानों को अंडरस्कोर(_) को इस कारण दे रहे हैं कि उन्हें आगे के कोड में उपयोग नहीं करना है।

उदाहरण देखें

## ignoring a value
a, _, b = (1, 2, 3) # a = 1, b = 3
print(a, b)

## ignoring multiple values
## *(variable) used to assign multiple value to a variable as list while unpacking
## it's called "Extended Unpacking", only available in Python 3.x
a, *_, b = (7, 6, 5, 4, 3, 2, 1)
print(a, b)

1 3
7 1

3. लूपिंग में उपयोग

आप लूपिंग में अंडरस्कोर(_) को वेरिएबल के रूप में उपयोग कर सकते हैं। आइडिया पाने के लिए नीचे दिए उदाहरण देखें।

## lopping ten times using _
for _ in range(5):
    print(_)

## iterating over a list using _
## you can use _ same as a variable
languages = ["Python", "JS", "PHP", "Java"]
for _ in languages:
    print(_)

_ = 5
while _ < 10:
    print(_, end = ' ') # default value of 'end' id '\n' in python. we're changing it to space
    _ += 1

0
1
2
3
4
Python
JS
PHP
Java
5 6 7 8 9

4. संख्याओं के अंकों को अलग करना

यदि आपके पास बहुत लंबी अंकों वाली संख्या है, तो बेहतर समझ के लिए आप अंकों के समूहों को अपनी सुविधा अनुसार अलग कर सकते हैं।

उदा.: million = 1_000_000

आगे, आप संख्याओं के बाइनरी, ऑक्टल या हेक्स भागों को अलग करने के लिए भी अंडरस्कोर(_) का उपयोग कर सकते हैं।

उदा.: binary = 0b_0010, octa = 0o_64, hexa = 0x_23_ab

परिणाम देखने के लिए ऊपर दिए सभी उदाहरण चलाएँ।

## different number systems
## you can also check whether they are correct or not by coverting them into integer using "int" method
million = 1_000_000
binary = 0b_0010
octa = 0o_64
hexa = 0x_23_ab

print(million)
print(binary)
print(octa)
print(hexa)

1000000
2
52
9131

5. अंडरस्कोर(_) का उपयोग करके नामकरण

अंडरस्कोर(_) का उपयोग वेरिएबल, फंक्शन, क्लास आदि के नामकरण में किया जा सकता है।

• सिंगल प्री अंडरस्कोर:– _variable

• सिंगल पोस्ट अंडरस्कोर:– variable_

• डबल प्री अंडरस्कोर्स:– __variable

• डबल प्री और पोस्ट अंडरस्कोर्स:– __variable__

5.1. _single_pre_underscore

_name

सिंगल प्री अंडरस्कोर आंतरिक उपयोग के लिए होता है। इसी कारण हममें से अधिकांश इसका उपयोग नहीं करते।

निम्न उदाहरण देखें।

class Test:

    def __init__(self):
        self.name = "datacamp"
        self._num = 7

obj = Test()
print(obj.name)
print(obj._num)

datacamp
7

सिंगल प्री अंडरस्कोर आपको सिंगल प्री अंडरस्कोर वेरिएबल तक पहुँचने से नहीं रोकता।

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

आइए निम्न कोड को my_funtions फाइल में लिखें।

## filename:- my_functions.py

def func():
    return "datacamp"

def _private_func():
    return 7

अब, यदि आप my_functions.py से सभी मेथड और नामों को import करते हैं, तो Python उन नामों को इम्पोर्ट नहीं करता जो सिंगल प्री अंडरस्कोर से शुरू होते हैं।

>>> from my_functions import *
>>> func()
'datacamp'
>>> _private_func()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name '_private_func' is not defined

आप ऊपर दी गई त्रुटि से बच सकते हैं यदि आप मॉड्यूल को सामान्य तरीके से इम्पोर्ट करें।

>>> import my_functions
>>> my_functions.func()
'datacamp'
>>> my_functions._private_func()
7

सिंगल प्री अंडरस्कोर केवल आंतरिक उपयोग के लिए होता है।

5.2 single_postunderscore

name_

कभी-कभी यदि आप Python कीवर्ड्स को वेरिएबल, फंक्शन या क्लास नामों के रूप में उपयोग करना चाहते हैं, तो आप इसके लिए यह प्रथा अपना सकते हैं।

जिस नाम का आप उपयोग करना चाहते हैं उसके अंत में एक अंडरस्कोर जोड़कर आप Python कीवर्ड्स के साथ टकराव से बच सकते हैं।

उदाहरण देखें।

>>> def function(class):
  File "<stdin>", line 1
    def function(class):
                 ^
SyntaxError: invalid syntax
>>> def function(class_):
...     pass
...
>>>

सिंगल पोस्ट अंडरस्कोर का उपयोग आपके वेरिएबलों को Python कीवर्ड्स जैसा नाम देने और अंत में अंडरस्कोर जोड़कर टकराव से बचने के लिए किया जाता है।

5.3. डबल प्री अंडरस्कोर

__name

डबल प्री अंडरस्कोर्स का उपयोग नेम मैंगलिंग के लिए होता है।

डबल प्री अंडरस्कोर्स Python इंटरप्रेटर को बताता है कि नाम-संघर्ष से बचने के लिए सबक्लासेस के एट्रिब्यूट नामों को फिर से लिखे।

• नेम मैंगलिंग:– Python का इंटरप्रेटर वेरिएबल नाम को इस तरह बदल देता है कि क्लास इनहेरिट होने पर टकराव मुश्किल हो जाए।

एक उदाहरण देखें।

class Sample():

    def __init__(self):
        self.a = 1
        self._b = 2
        self.__c = 3
obj1 = Sample()
dir(obj1)

['_Sample__c',
 '__class__',
 '__delattr__',
 '__dict__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__le__',
 '__lt__',
 '__module__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 '__weakref__',
 '_b',
 'a']

ऊपर दिया कोड क्लास ऑब्जेक्ट के सभी एट्रिब्यूट लौटाता है। आइए एट्रिब्यूट्स सूची में अपने वेरिएबल देखें।

self.a वेरिएबल बिना किसी बदलाव के सूची में दिखाई देता है।

self._b वेरिएबल भी बिना किसी बदलाव के सूची में दिखता है। जैसा कि ऊपर चर्चा की, यह केवल आंतरिक उपयोग के लिए है।

• क्या सूची में self.__c वेरिएबल है?

  • यदि आप एट्रिब्यूट्स सूची को ध्यान से देखें, तो आपको _Sample__c नामक एट्रिब्यूट मिलेगा। यही नेम मैंगलिंग है। यह सबक्लासेस में वेरिएबल के ओवरराइडिंग से बचने के लिए है।

आइए Sample क्लास को इनहेरिट करके एक और क्लास बनाते हैं और देखते हैं कि ओवरराइडिंग कैसे काम करती है।

class SecondClass(Sample):

    def __init__(self):
        super().__init__()
        self.a = "overridden"
        self._b = "overridden"
        self.__c = "overridden"
obj2 = SecondClass()
print(obj2.a)
print(obj2._b)
print(obj2.__c)

overridden
overridden



---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-2-4bf6884fbd34> in <module>()
      9 print(obj2.a)
     10 print(obj2._b)
---> 11 print(obj2.__c)


AttributeError: 'SecondClass' object has no attribute '__c'

यहाँ, नेम मैंगलिंग फिर काम करती है। यह obj2.__c को _SecondClass__c में बदल देती है। अब, बदले हुए एट्रिब्यूट का उपयोग कर उसे print करें।

print(obj2._SecondClass__c)

overridden

देखा, यह काम कर गया। आप पहले बनाए गए वेरिएबल को भी _Sample__c का उपयोग कर एक्सेस कर सकते हैं। देखें

print(obj1._Sample__c)

3

आप डबल प्री अंडरस्कोर वेरिएबल को क्लास के मेथड्स के जरिए भी एक्सेस कर सकते हैं। एक उदाहरण देखें।

class SimpleClass:

    def __init__(self):
        self.__datacamp = "Excellent"

    def get_datacamp(self):
        return self.__datacamp

obj = SimpleClass()
print(obj.get_datacamp()) ## it prints the "Excellent" which is a __var
print(obj.__datacamp)     ## here, we get an error as mentioned before. It changes the name of the variable

Excellent



---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-5-8006c0a9b061> in <module>()
      9 obj = SimpleClass()
     10 print(obj.get_datacamp()) ## it prints the "Excellent" which is a __var
---> 11 print(obj.__datacamp)     ## here, we get an error as mentioned before. It changes the name of the variable


AttributeError: 'SimpleClass' object has no attribute '__datacamp'

आप मेथड नामों के लिए भी डबल प्री अंडरस्कोर का उपयोग कर सकते हैं। एक उदाहरण देखें।

class SimpleClass:

    def __datacamp(self):
        return "datacamp"

    def call_datacamp(self):
        return self.__datacamp()

obj = SimpleClass()
print(obj.call_datacamp()) ## same as above it returns the Dobule pre underscore method
print(obj.__datacamp())    ## we get an error here

datacamp



---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-1-cd8ce2e83589> in <module>()
      9 obj = SimpleClass()
     10 print(obj.call_datacamp()) ## same as above it returns the Dobule pre underscore method
---> 11 print(obj.__datacamp())    ## we get an error here


AttributeError: 'SimpleClass' object has no attribute '__datacamp'

आइए नेम मैंगलिंग को एक और तरीके से देखें। पहले हम _SimpleClass__name नाम से एक वेरिएबल बनाएँगे, और फिर उसे डबल प्री अंडरस्कोर नाम से एक्सेस करने की कोशिश करेंगे।

उदाहरण देखें।

_SimpleClass__name = "datacamp"

class SimpleClass:

    def return_name(self):
        return __name

obj = SimpleClass()
print(obj.return_name()) ## it prints the __name variable

datacamp

क्या आपको अवधारणा समझ आई? यदि नहीं, तो दोबारा पढ़ने की कोशिश करें।

5.4. डबल प्री और पोस्ट अंडरस्कोर्स

__name__

Python में आपको कई नाम मिलेंगे जो डबल अंडरस्कोर से शुरू और समाप्त होते हैं। इन्हें मैजिक मेथड्स या डंडर मेथڈ्स कहा जाता है।

class Sample():

    def __init__(self):
        self.__num__ = 7

obj = Sample()
obj.__num__

7

यदि आप इन मेथड्स को अपने वेरिएबल नामों के रूप में उपयोग करते हैं तो इससे टकराव हो सकता है। इसलिए, बेहतर है कि इनसे दूर रहें।

निष्कर्ष

बधाई हो! आपने कर दिखाया। आपने Python की सबसे उबाऊ अवधारणाओं में से एक को पूरा कर लिया है। लेकिन जब आप उन्नत कोड के साथ काम करते हैं तो यह बहुत मदद करती है।

मेरे जैसे अधिकांश लोग पहली बार पढ़ने पर इस अवधारणा को नहीं समझते। इसलिए, धैर्य न खोएँ—यदि पहली बार में समझ न आए तो इसे दोबारा पढ़ें। यदि लेख को लेकर कोई सवाल हो, तो टिप्पणी अनुभाग में बेझिझक लिखें।

यदि आप Python के शुरुआती हैं, तो मैं सुझाव देता हूँ कि आप यह कोर्स करें और फिर पूर्ण समझ के लिए इस लेख को दोबारा पढ़ें।

संसाधन:

• Python में अंडरस्कोर्स का अर्थ