Python में is: पहचान ऑपरेटर समझाया गया

Python में is ऑपरेटर एक पहचान ऑपरेटर है जो जांचता है कि दो चर मेमोरी में एक ही वस्तु की ओर इंगित करते हैं या नहीं। == ऑपरेटर के विपरीत जो समानता के लिए मानों की तुलना करता है, is यह जांचकर वस्तु पहचान की तुलना करता है कि दो संदर्भ बिल्कुल एक ही मेमोरी स्थान की ओर इंगित करते हैं या नहीं। यह अंतर सही और कुशल Python कोड लिखने के लिए महत्वपूर्ण है।

IS vs == ऑपरेटर

is और == के बीच मुख्य अंतर यह है कि == मानों (समानता) की तुलना करता है जबकि is पहचान (मेमोरी में एक ही वस्तु) की तुलना करता है।

उदाहरण 1: मूल अंतर

# Value comparison with ==
a = [1, 2, 3]
b = [1, 2, 3]

print(a == b)  # Output: True (same values)
print(a is b)  # Output: False (different objects)

# Identity comparison
c = a
print(a is c)  # Output: True (same object)

# Memory locations
print(f"id(a): {id(a)}")
print(f"id(b): {id(b)}")
print(f"id(c): {id(c)}")

True
False
True
id(a): 140234567890
id(b): 140234567920
id(c): 140234567890

== ऑपरेटर True लौटाता है क्योंकि दोनों सूचियों में समान सामग्री है, लेकिन is False लौटाता है क्योंकि वे मेमोरी में अलग-अलग वस्तुएं हैं।

id() के साथ वस्तु पहचान को समझना

id() फ़ंक्शन एक वस्तु के अद्वितीय पहचानकर्ता (मेमोरी पता) लौटाता है, जिसका उपयोग is ऑपरेटर तुलना के लिए करता है।

उदाहरण: id() फ़ंक्शन का उपयोग करना

x = [1, 2, 3, 4, 5]
y = [1, 2, 3, 4, 5]
z = x

# Check identity with 'is'
print(x is z)    # Output: True
print(x is y)    # Output: False

# Verify with id()
print(f"id(x): {id(x)}")
print(f"id(y): {id(y)}")
print(f"id(z): {id(z)}")

# x and z have the same id
# y has a different id

True
False
id(x): 140234567890
id(y): 140234567920
id(z): 140234567890

id() फ़ंक्शन एक वस्तु के अद्वितीय पहचानकर्ता (मेमोरी पता) लौटाता है, जिसका उपयोग is ऑपरेटर तुलना के लिए करता है।

IS NOT ऑपरेटर

is not ऑपरेटर True लौटाता है जब दो चर मेमोरी में अलग-अलग वस्तुओं को संदर्भित करते हैं।

उदाहरण: is not का उपयोग करना

a = [1, 2, 3, 4, 5]
b = [1, 2, 3, 4, 5]
c = a

# Using 'is not'
print(a is not c)  # Output: False (they are the same object)
print(a is not b)  # Output: True (different objects)

# Equivalent to: not (a is b)
print(not (a is b))  # Output: True

False
True
True

ऑपरेटर तुलना तालिका:

IS ऑपरेटर का उपयोग कब करें

is ऑपरेटर का उपयोग विशिष्ट परिदृश्यों में किया जाना चाहिए जहां वस्तु पहचान मान समानता से अधिक महत्वपूर्ण है।

उपयोग मामला 1: None की जांच करना

def process_data(value):
    # CORRECT: Always use 'is' with None
    if value is None:
        print("No data provided")
        return
    
    print(f"Processing: {value}")

# WRONG: Don't use == with None
def wrong_check(value):
    if value == None:  # Not Pythonic
        print("This works but is not recommended")

process_data(None)  # Output: No data provided
process_data(42)    # Output: Processing: 42

कोई डेटा प्रदान नहीं किया गया
प्रसंस्करण: 42

None के साथ तुलना करते समय हमेशा is या is not का उपयोग करें, क्योंकि यह अधिक स्पष्ट और तेज़ है।

उपयोग मामला 2: बूलियन सिंगलटन की जांच करना

def check_flag(flag):
    # Use 'is' for True/False when checking identity
    if flag is True:
        print("Flag is explicitly True")
    elif flag is False:
        print("Flag is explicitly False")
    else:
        print(f"Flag is truthy/falsy but not boolean: {flag}")

check_flag(True)   # Flag is explicitly True
check_flag(1)      # Flag is truthy/falsy but not boolean: 1
check_flag(False)  # Flag is explicitly False
check_flag(0)      # Flag is truthy/falsy but not boolean: 0

ध्वज स्पष्ट रूप से True है
ध्वज truthy/falsy है लेकिन बूलियन नहीं: 1
ध्वज स्पष्ट रूप से False है
ध्वज truthy/falsy है लेकिन बूलियन नहीं: 0

उपयोग मामला 3: जांच करना कि चर एक ही सूची/शब्दकोश को संदर्भित करते हैं

def modify_list(original_list, new_list):
    if original_list is new_list:
        print("Warning: Same list reference, modifications will affect both")
        return False
    return True

my_list = [1, 2, 3]
same_ref = my_list
different_list = [1, 2, 3]

modify_list(my_list, same_ref)       # Warning message
modify_list(my_list, different_list) # Returns True

चेतावनी: एक ही सूची संदर्भ, संशोधन दोनों को प्रभावित करेंगे

Python का पूर्णांक और स्ट्रिंग इंटर्निंग

Python स्वचालित रूप से छोटे पूर्णांकों और कुछ स्ट्रिंग्स को अनुकूलन के रूप में इंटर्न करता है, जिससे is का आश्चर्यजनक व्यवहार हो सकता है।

उदाहरण: छोटे पूर्णांक कैशिंग

# Small integers (-5 to 256) are cached
a = 256
b = 256
print(a is b)  # Output: True

a = 257
b = 257
print(a is b)  # Output: False (usually, depends on implementation)

# This is due to Python's integer interning optimization
print(id(256) == id(256))  # True
print(id(257) == id(257))  # May vary

True
False
True
True

उदाहरण: स्ट्रिंग इंटर्निंग

# String interning
a = "TutorialsPoint"
b = a
print(f"id(a), id(b): {id(a)}, {id(b)}")
print(f"a is b: {a is b}")          # Output: True
print(f"b is not a: {b is not a}")  # Output: False

# Identical string literals are often interned
x = "hello"
y = "hello"
print(x is y)  # Output: True (usually)

# But not always for dynamically created strings
x = "hello world"
y = "hello world"
print(x is y)  # Output: May be True or False

# Strings with spaces/special chars may not be interned
x = "hello world!"
y = "hello world!"
print(x is y)  # Output: False (typically)

id(a), id(b): 140234567890, 140234567890
a is b: True
b is not a: False
True
True
False

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

सामान्य जाल और गलतियां

is ऑपरेटर का उपयोग करते समय सामान्य गलतियों को समझना बग से बचने और अधिक विश्वसनीय कोड लिखने में मदद करता है।

Mistake 1: Using IS for Value Comparison

# WRONG: Using 'is' to compare values
a = 1000
b = 1000
if a is b:  # Unreliable!
    print("Equal")
else:
    print("Not equal")  # Usually prints this

# CORRECT: Use == for value comparison
if a == b:  # Reliable
    print("Equal")  # Always prints this for equal values

Mistake 2: Relying on Integer Interning

# Don't rely on this behavior!
def bad_comparison(x, y):
    if x is y:  # Only works reliably for small integers
        return True
    return False

print(bad_comparison(5, 5))      # True (cached)
print(bad_comparison(500, 500))  # False (not cached)

# CORRECT approach
def good_comparison(x, y):
    if x == y:  # Always reliable
        return True
    return False

print(good_comparison(5, 5))      # True
print(good_comparison(500, 500))  # True

Mistake 3: Misunderstanding Mutable vs Immutable Types

# Immutable types (int, str, tuple)
a = 42
b = 42
print(a is b)  # May be True (depends on interning)

# Mutable types (list, dict, set)
x = [1, 2]
y = [1, 2]
print(x is y)  # Always False (different objects)

# Assignment creates reference, not copy
z = x
print(x is z)  # True (same object)

# Use copy to create new object
import copy
w = copy.copy(x)
print(x is w)  # False (different objects)
print(x == w)  # True (same values)

सर्वोत्तम प्रथाएं

is ऑपरेटर का उपयोग करते समय सर्वोत्तम प्रथाओं का पालन करना विश्वसनीय और Pythonic कोड सुनिश्चित करता है।

अभ्यास 1: None के साथ हमेशा IS का उपयोग करें

# GOOD: Checking for None
if value is None:
    handle_none()

# BAD: Using == with None
if value == None:  # Works but not Pythonic
    handle_none()

<code>None</code> के साथ तुलना करते समय हमेशा <code>is</code> और <code>is not</code> का उपयोग करें।

अभ्यास 2: मान तुलना के लिए == का उपयोग करें

# GOOD: Value comparison
if count == 0:
    print("Empty")

# BAD: Using 'is' for value comparison
if count is 0:  # Unreliable!
    print("Empty")

अधिकांश अन्य मामलों में मान तुलना के लिए <code>==</code> का उपयोग करें।

अभ्यास 3: सिंगलटन वस्तुओं के लिए IS का उपयोग करें

# GOOD: Checking if same list
if original_list is modified_list:
    print("Same object")

# GOOD: Checking if equal values
if list1 == list2:
    print("Equal contents")

सिंगलटन वस्तुओं (<code>None</code>, <code>True</code>, <code>False</code>) के लिए <code>is</code> का उपयोग करें और जांचें कि दो चर एक ही परिवर्तनशील वस्तु को संदर्भित करते हैं या नहीं।

अभ्यास 4: इंटर्निंग पर कभी भरोसा न करें

# BAD: Relying on integer interning
if x is 256:  # May work, but unreliable
    do_something()

# GOOD: Use == for value comparison
if x == 256:  # Always reliable
    do_something()

उत्पादन कोड में पूर्णांक या स्ट्रिंग इंटर्निंग पर कभी भरोसा न करें।>

वास्तविक दुनिया के उदाहरण

ये उदाहरण वास्तविक दुनिया के परिदृश्यों में is ऑपरेटर के व्यावहारिक उपयोगों को प्रदर्शित करते हैं।

उदाहरण 1: सिंगलटन पैटर्न कार्यान्वयन

class DatabaseConnection:
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            print("Creating new database connection")
        return cls._instance

# Test singleton
db1 = DatabaseConnection()
db2 = DatabaseConnection()

print(db1 is db2)  # Output: True (same instance)
print(id(db1) == id(db2))  # Output: True

नया डेटाबेस कनेक्शन बनाया जा रहा है
True
True

उदाहरण 2: कैश कार्यान्वयन

class Cache:
    def __init__(self):
        self._cache = {}
        self._MISSING = object()
    
    def get(self, key, default=None):
        result = self._cache.get(key, self._MISSING)
        
        if result is self._MISSING:
            print(f"Cache miss for key: {key}")
            return default
        
        print(f"Cache hit for key: {key}")
        return result
    
    def set(self, key, value):
        self._cache[key] = value

# Usage
cache = Cache()
cache.set('user_1', {'name': 'Alice'})

cache.get('user_1')        # Cache hit
cache.get('user_2')        # Cache miss
cache.get('user_2', {})    # Cache miss, returns {}

कुंजी के लिए कैश हिट: user_1
कुंजी के लिए कैश मिस: user_2
कुंजी के लिए कैश मिस: user_2

उदाहरण 3: रक्षात्मक प्रतिलिपि पहचान

def modify_list_safely(original, new_items):
    # Check if caller passed the same list
    if original is new_items:
        raise ValueError("Cannot pass same list for both arguments")
    
    original.extend(new_items)
    return original

my_list = [1, 2, 3]
additional = [4, 5]

result = modify_list_safely(my_list, additional)
print(result)  # [1, 2, 3, 4, 5]

try:
    modify_list_safely(my_list, my_list)  # Raises ValueError
except ValueError as e:
    print(f"Error: {e}")

[1, 2, 3, 4, 5]
त्रुटि: दोनों तर्कों के लिए एक ही सूची पास नहीं की जा सकती

संबंधित विषय

• if in python - मूल सशर्त कथनों के बारे में जानें
• if else in python - वैकल्पिक स्थितियों को कैसे संभालें सीखें
• and in python - कई स्थितियों को संयोजित करें
• or in python - OR तार्किक ऑपरेटर के बारे में जानें
• or in python - OR तार्किक ऑपरेटर के बारे में जानें

अक्सर पूछे जाने वाले प्रश्न