पायथन में ऑपरेटर्स का उपयोग(Using Operators in Python)

इस अध्याय में, हम पाइथन में ऑपरेटरों (Operators) के उपयोग को समझेंगे। ऑपरेटर प्रोग्रामिंग में एक महत्वपूर्ण भूमिका निभाते हैं, क्योंकि वे विभिन्न प्रकार के ऑपरेशन्स को निष्पादित करने के लिए उपयोग किए जाते हैं। पाइथन में कई प्रकार के ऑपरेटर होते हैं, जैसे अरिथमेटिक ऑपरेटर, असाइनमेंट ऑपरेटर, कम्पेरिजन ऑपरेटर, लॉजिकल ऑपरेटर, बिटवाइज ऑपरेटर, मेम्बरशिप ऑपरेटर, और आइडेंटिटी ऑपरेटर। इस अध्याय के माध्यम से, आप इन ऑपरेटरों के उपयोग और उनके काम करने के तरीके को समझेंगे।

अरिथमेटिक ऑपरेटर (Arithmetic Operators)

अरिथमेटिक ऑपरेटर (Arithmetic Operators) पाइथन में गणितीय गणनाएँ करने के लिए उपयोग किए जाते हैं। ये ऑपरेटर संख्याओं पर विभिन्न गणितीय ऑपरेशन्स को लागू करते हैं, जैसे जोड़, घटाव, गुणा, भाग, आदि। इस सेक्शन में, हम पाइथन में उपलब्ध विभिन्न अरिथमेटिक ऑपरेटरों और उनके उपयोग के बारे में जानेंगे।

अरिथमेटिक ऑपरेटरों की सूची (List of Arithmetic Operators)

जोड़ (Addition) +

जोड़ ऑपरेटर का उपयोग दो संख्याओं को जोड़ने के लिए किया जाता है।

x = 10
y = 5
result = x + y
print("जोड़:", result)   # आउटपुट: जोड़: 15

घटाव (Subtraction) -

घटाव ऑपरेटर का उपयोग एक संख्या से दूसरी संख्या को घटाने के लिए किया जाता है।

x = 10
y = 5
result = x - y
print("घटाव:", result)   # आउटपुट: घटाव: 5

गुणा (Multiplication) *

गुणा ऑपरेटर का उपयोग दो संख्याओं को गुणा करने के लिए किया जाता है।

x = 10
y = 5
result = x * y
print("गुणा:", result)   # आउटपुट: गुणा: 50

भाग (Division) /

भाग ऑपरेटर का उपयोग एक संख्या को दूसरी संख्या से विभाजित करने के लिए किया जाता है। यह एक फ्लोटिंग-पॉइंट परिणाम लौटाता है।

x = 10
y = 5
result = x / y
print("भाग:", result)   # आउटपुट: भाग: 2.0

मोड्यूलस (Modulus) %

मोड्यूलस ऑपरेटर का उपयोग एक संख्या को दूसरी संख्या से विभाजित करने पर शेष (remainder) को प्राप्त करने के लिए किया जाता है।

x = 10
y = 3
result = x % y
print("मोड्यूलस:", result)   # आउटपुट: मोड्यूलस: 1

घात (Exponentiation) **

घात ऑपरेटर का उपयोग एक संख्या को दूसरी संख्या की शक्ति (power) तक बढ़ाने के लिए किया जाता है।

x = 2
y = 3
result = x ** y
print("घात:", result)   # आउटपुट: घात: 8

फ्लोर डिवीजन (Floor Division) //

फ्लोर डिवीजन ऑपरेटर का उपयोग एक संख्या को दूसरी संख्या से विभाजित करने पर पूर्णांक परिणाम प्राप्त करने के लिए किया जाता है।

x = 10
y = 3
result = x // y
print("फ्लोर डिवीजन:", result)   # आउटपुट: फ्लोर डिवीजन: 3

इस सेक्शन में, हमने पाइथन में उपलब्ध विभिन्न अरिथमेटिक ऑपरेटरों और उनके उपयोग के बारे में सीखा। अगली सेक्शन में, हम असाइनमेंट ऑपरेटरों के बारे में जानेंगे और समझेंगे कि उन्हें वेरिएबल्स को मान असाइन करने के लिए कैसे उपयोग किया जाता है।

असाइनमेंट ऑपरेटर (Assignment Operators)

असाइनमेंट ऑपरेटर (Assignment Operators) पाइथन में वेरिएबल्स को मान (value) असाइन करने के लिए उपयोग किए जाते हैं। ये ऑपरेटर वेरिएबल्स के साथ विभिन्न ऑपरेशन्स करके उनके मान को अपडेट करने में मदद करते हैं। इस सेक्शन में, हम पाइथन में उपलब्ध विभिन्न असाइनमेंट ऑपरेटरों और उनके उपयोग के बारे में जानेंगे।

असाइनमेंट ऑपरेटरों की सूची (List of Assignment Operators)

वेरिएबल को एक मान असाइन करना (Assign a Value to a Variable) =

यह ऑपरेटर वेरिएबल को एक मान असाइन करने के लिए उपयोग किया जाता है।

x = 5
print(x)   # आउटपुट: 5

वेरिएबल को जोड़ और असाइन करना (Add and Assign) +=

यह ऑपरेटर वेरिएबल के वर्तमान मान में एक मान जोड़ता है और फिर उसे असाइन करता है।

x = 5
x += 3    # x = x + 3
print(x)   # आउटपुट: 8

वेरिएबल को घटा और असाइन करना (Subtract and Assign) -=

यह ऑपरेटर वेरिएबल के वर्तमान मान से एक मान घटाता है और फिर उसे असाइन करता है।

x = 5
x -= 2    # x = x - 2
print(x)   # आउटपुट: 3

वेरिएबल को गुणा और असाइन करना (Multiply and Assign) *=

यह ऑपरेटर वेरिएबल के वर्तमान मान को एक मान से गुणा करता है और फिर उसे असाइन करता है।

x = 5
x *= 4    # x = x * 4
print(x)   # आउटपुट: 20

वेरिएबल को भाग और असाइन करना (Divide and Assign) /=

यह ऑपरेटर वेरिएबल के वर्तमान मान को एक मान से विभाजित करता है और फिर उसे असाइन करता है। यह एक फ्लोटिंग-पॉइंट परिणाम लौटाता है।

x = 5
x /= 2    # x = x / 2
print(x)   # आउटपुट: 2.5

वेरिएबल को मोड्यूलस और असाइन करना (Modulus and Assign) %=

यह ऑपरेटर वेरिएबल के वर्तमान मान को एक मान से विभाजित करने पर शेष (remainder) को प्राप्त करता है और फिर उसे असाइन करता है।

x = 5
x %= 2    # x = x % 2
print(x)   # आउटपुट: 1

वेरिएबल को घात और असाइन करना (Exponentiation and Assign) **=

यह ऑपरेटर वेरिएबल के वर्तमान मान को एक घात (power) तक बढ़ाता है और फिर उसे असाइन करता है।

x = 2
x **= 3    # x = x ** 3
print(x)    # आउटपुट: 8

वेरिएबल को फ्लोर डिवीजन और असाइन करना (Floor Division and Assign) //=

यह ऑपरेटर वेरिएबल के वर्तमान मान को एक मान से विभाजित करता है और पूर्णांक परिणाम को असाइन करता है।

x = 5
x //= 2    # x = x // 2
print(x)    # आउटपुट: 2

इस सेक्शन में, हमने पाइथन में उपलब्ध विभिन्न असाइनमेंट ऑपरेटरों और उनके उपयोग के बारे में सीखा। अगली सेक्शन में, हम कम्पेरिजन ऑपरेटरों के बारे में जानेंगे और समझेंगे कि उनका उपयोग कैसे किया जाता है।

कम्पेरिजन ऑपरेटर (Comparison Operators)

कम्पेरिजन ऑपरेटर (Comparison Operators) का उपयोग दो मानों की तुलना करने के लिए किया जाता है। ये ऑपरेटर दो मानों के बीच संबंध स्थापित करते हैं और एक बूलियन परिणाम (True या False) लौटाते हैं। पाइथन में कई प्रकार के कम्पेरिजन ऑपरेटर होते हैं। इस सेक्शन में, हम पाइथन में उपलब्ध विभिन्न कम्पेरिजन ऑपरेटरों और उनके उपयोग के बारे में जानेंगे।

कम्पेरिजन ऑपरेटरों की सूची (List of Comparison Operators)

बराबर (Equal to) ==

यह ऑपरेटर जांचता है कि क्या दो मान बराबर हैं।

x = 10
y = 10
result = (x == y)
print("x और y बराबर हैं:", result)   # आउटपुट: x और y बराबर हैं: True

बराबर नहीं (Not equal to) !=

यह ऑपरेटर जांचता है कि क्या दो मान बराबर नहीं हैं।

x = 10
y = 5
result = (x != y)
print("x और y बराबर नहीं हैं:", result)   # आउटपुट: x और y बराबर नहीं हैं: True

बड़ा (Greater than) >

यह ऑपरेटर जांचता है कि क्या पहला मान दूसरे मान से बड़ा है।

x = 10
y = 5
result = (x > y)
print("x बड़ा है y से:", result)   # आउटपुट: x बड़ा है y से: True

छोटा (Less than) <

यह ऑपरेटर जांचता है कि क्या पहला मान दूसरे मान से छोटा है।

x = 10
y = 20
result = (x < y)
print("x छोटा है y से:", result)   # आउटपुट: x छोटा है y से: True

बड़ा या बराबर (Greater than or equal to) >=

यह ऑपरेटर जांचता है कि क्या पहला मान दूसरे मान से बड़ा या बराबर है।

x = 10
y = 10
result = (x >= y)
print("x बड़ा या बराबर है y से:", result)   # आउटपुट: x बड़ा या बराबर है y से: True

छोटा या बराबर (Less than or equal to) <=

यह ऑपरेटर जांचता है कि क्या पहला मान दूसरे मान से छोटा या बराबर है।

x = 10
y = 20
result = (x <= y)
print("x छोटा या बराबर है y से:", result)   # आउटपुट: x छोटा या बराबर है y से: True

कम्पेरिजन ऑपरेटरों का उपयोग (Using Comparison Operators)

कम्पेरिजन ऑपरेटरों का उपयोग कंडीशनल स्टेटमेंट्स (if, elif, else) में किया जाता है ताकि प्रोग्राम को निर्णय लेने में मदद मिल सके।

x = 10
y = 5

if x > y:
    print("x बड़ा है y से")
else:
    print("x छोटा या बराबर है y से")

इस सेक्शन में, हमने पाइथन में उपलब्ध विभिन्न कम्पेरिजन ऑपरेटरों और उनके उपयोग के बारे में सीखा। अगली सेक्शन में, हम लॉजिकल ऑपरेटरों के बारे में जानेंगे और समझेंगे कि उनका उपयोग कैसे किया जाता है।

लॉजिकल ऑपरेटर (Logical Operators)

लॉजिकल ऑपरेटर (Logical Operators) का उपयोग एक से अधिक कंडीशनल स्टेटमेंट्स को जोड़ने के लिए किया जाता है। ये ऑपरेटर विभिन्न कंडीशनों का परीक्षण करके एकल बूलियन परिणाम (True या False) लौटाते हैं। पाइथन में तीन मुख्य लॉजिकल ऑपरेटर होते हैं: and, or, और not। इस सेक्शन में, हम पाइथन में उपलब्ध विभिन्न लॉजिकल ऑपरेटरों और उनके उपयोग के बारे में जानेंगे।

लॉजिकल ऑपरेटरों की सूची (List of Logical Operators)

और (Logical AND) and

and ऑपरेटर का उपयोग तब किया जाता है जब दोनों कंडीशन सही हों। यदि दोनों कंडीशन सही हैं, तो परिणाम True होता है, अन्यथा False।

x = 5
y = 10
result = (x > 2 and y < 15)
print("x > 2 और y < 15:", result)   # आउटपुट: x > 2 और y < 15: True

result = (x > 6 and y < 15)
print("x > 6 और y < 15:", result)   # आउटपुट: x > 6 और y < 15: False

या (Logical OR) or

or ऑपरेटर का उपयोग तब किया जाता है जब किसी एक कंडीशन का सही होना जरूरी हो। यदि कोई भी एक कंडीशन सही है, तो परिणाम True होता है, अन्यथा False।

x = 5
y = 10
result = (x > 2 or y < 5)
print("x > 2 या y < 5:", result)   # आउटपुट: x > 2 या y < 5: True

result = (x > 6 or y < 5)
print("x > 6 या y < 5:", result)   # आउटपुट: x > 6 या y < 5: False

नहीं (Logical NOT) not

not ऑपरेटर का उपयोग किसी कंडीशन के परिणाम को उलटने के लिए किया जाता है। यदि कंडीशन True है, तो not उसे False में बदल देता है, और यदि कंडीशन False है, तो not उसे True में बदल देता है।

x = 5
result = not(x > 2)
print("not(x > 2):", result)   # आउटपुट: not(x > 2): False

result = not(x > 6)
print("not(x > 6):", result)   # आउटपुट: not(x > 6): True

लॉजिकल ऑपरेटरों का उपयोग (Using Logical Operators)

लॉजिकल ऑपरेटरों का उपयोग कंडीशनल स्टेटमेंट्स (if, elif, else) में किया जाता है ताकि प्रोग्राम को अधिक जटिल निर्णय लेने में मदद मिल सके।

x = 5
y = 10

if x > 2 and y < 15:
print("x > 2 और y < 15")
else:
print("कंडीशन गलत है")

if x > 6 or y < 15:
print("x > 6 या y < 15")
else:
print("दोनों कंडीशन गलत हैं")

if not(x > 6):
print("x > 6 नहीं है")
else:
print("x > 6 है")

बिटवाइज ऑपरेटर (Bitwise Operators)

बिटवाइज ऑपरेटर (Bitwise Operators) का उपयोग बिट-लेवल पर ऑपरेशन्स करने के लिए किया जाता है। ये ऑपरेटर बाइनरी नंबरों पर काम करते हैं और बाइनरी डिजिट्स के अनुसार ऑपरेशन्स को निष्पादित करते हैं। पाइथन में विभिन्न प्रकार के बिटवाइज ऑपरेटर होते हैं, जैसे AND, OR, XOR, NOT, लेफ्ट शिफ्ट, और राइट शिफ्ट। इस सेक्शन में, हम पाइथन में उपलब्ध विभिन्न बिटवाइज ऑपरेटरों और उनके उपयोग के बारे में जानेंगे।

बिटवाइज ऑपरेटरों की सूची (List of Bitwise Operators)

बिटवाइज AND &

यह ऑपरेटर दो बाइनरी नंबरों के प्रत्येक बिट पर AND ऑपरेशन करता है।

x = 5    # 0101
y = 3    # 0011
result = x & y    # 0001
print("बिटवाइज AND:", result)   # आउटपुट: बिटवाइज AND: 1

बाइनरी में:

   0101 (x)
&  0011 (y)
--------
   0001 (result = 1)

Binary 0001 = 1 in decimal

बिटवाइज OR |

यह ऑपरेटर दो बाइनरी नंबरों के प्रत्येक बिट पर OR ऑपरेशन करता है।

x = 5    # 0101
y = 3    # 0011
result = x | y    # 0111
print("बिटवाइज OR:", result)   # आउटपुट: बिटवाइज OR: 7

बाइनरी में:

   0101    (x = 5)
|  0011    (y = 3)
--------
   0111    (result = 7)

चरण दर चरण:

1. सबसे बाएं बिट (leftmost bit) देखें: 0 OR 0 = 0
2. दूसरा बिट: 1 OR 0 = 1
3. तीसरा बिट: 0 OR 1 = 1
4. चौथा बिट (rightmost bit): 1 OR 1 = 1

इस प्रकार, 0101 OR 0011 का परिणाम 0111 होता है, जो दशमलव में 7 के बराबर है।

इसलिए, जब आप x | y का उपयोग करते हैं, तो बाइनरी ऑपरेशन के अनुसार परिणाम 7 आता है।

बिटवाइज XOR ^

यह ऑपरेटर दो बाइनरी नंबरों के प्रत्येक बिट पर XOR ऑपरेशन करता है।

x = 5    # 0101
y = 3    # 0011
result = x ^ y    # 0110
print("बिटवाइज XOR:", result)   # आउटपुट: बिटवाइज XOR: 6

कैसे बना:

   0101 (x)
^  0011 (y)
--------
   0110 (result = 6)

बिटवाइज NOT ~

यह ऑपरेटर बाइनरी नंबर के प्रत्येक बिट को उलट देता है (0 को 1 में और 1 को 0 में)। पाइथन में, यह ऑपरेटर 2’s complement फॉर्म में परिणाम लौटाता है, जिससे परिणाम नेगेटिव बनता है।

x = 5    # 0101
result = ~x    # 1010 (in 2's complement form, it's -6 in decimal)
print("बिटवाइज NOT:", result)   # आउटपुट: बिटवाइज NOT: -6

कैसे बना:

x = 5 (0101)
~x = -6 (1010 in 2's complement form)

लेफ्ट शिफ्ट (Left Shift) <<

यह ऑपरेटर बाइनरी नंबर के बिट्स को बाईं ओर शिफ्ट करता है और शिफ्ट की गई जगह को 0 से भरता है।

x = 5    # 0101
result = x << 2    # 010100 (20 in decimal)
print("लेफ्ट शिफ्ट:", result)   # आउटपुट: लेफ्ट शिफ्ट: 20

कैसे बना:

   0101 (x)
<< 2 (shift left by 2 bits)
--------
   010100 (result = 20)

राइट शिफ्ट (Right Shift) >>

यह ऑपरेटर बाइनरी नंबर के बिट्स को दाईं ओर शिफ्ट करता है और शिफ्ट की गई जगह को 0 से भरता है।

x = 20   # 10100
result = x >> 2    # 00101 (5 in decimal)
print("राइट शिफ्ट:", result)   # आउटपुट: राइट शिफ्ट: 5

कैसे बना:

   10100 (x)
>> 2 (shift right by 2 bits)
--------
   00101 (result = 5)

बिटवाइज ऑपरेटरों का उपयोग (Using Bitwise Operators)

बिटवाइज ऑपरेटरों का उपयोग विशेष परिस्थितियों में किया जाता है, जैसे लो-लेवल प्रोग्रामिंग, एम्बेडेड सिस्टम्स, क्रिप्टोग्राफी, आदि।

x = 5    # 0101
y = 3    # 0011

# बिटवाइज AND
result = x & y
print("बिटवाइज AND:", result)   # आउटपुट: बिटवाइज AND: 1

# बिटवाइज OR
result = x | y
print("बिटवाइज OR:", result)   # आउटपुट: बिटवाइज OR: 7

# बिटवाइज XOR
result = x ^ y
print("बिटवाइज XOR:", result)   # आउटपुट: बिटवाइज XOR: 6

# बिटवाइज NOT
result = ~x
print("बिटवाइज NOT:", result)   # आउटपुट: बिटवाइज NOT: -6

# लेफ्ट शिफ्ट
result = x << 2
print("लेफ्ट शिफ्ट:", result)   # आउटपुट: लेफ्ट शिफ्ट: 20

# राइट शिफ्ट
result = x >> 2
print("राइट शिफ्ट:", result)   # आउटपुट: राइट शिफ्ट: 1

इस सेक्शन में, हमने पाइथन में उपलब्ध विभिन्न बिटवाइज ऑपरेटरों और उनके उपयोग के बारे में सीखा। अगली सेक्शन में, हम मेम्बरशिप ऑपरेटरों के बारे में जानेंगे और समझेंगे कि उनका उपयोग कैसे किया जाता है।

मेम्बरशिप ऑपरेटर (Membership Operators)

मेम्बरशिप ऑपरेटर (Membership Operators) का उपयोग यह जांचने के लिए किया जाता है कि कोई विशेष मान किसी अनुक्रम (sequence) में मौजूद है या नहीं। पाइथन में दो मुख्य मेम्बरशिप ऑपरेटर होते हैं: in और not in। ये ऑपरेटर बूलियन परिणाम (True या False) लौटाते हैं। इस सेक्शन में, हम पाइथन में उपलब्ध मेम्बरशिप ऑपरेटरों और उनके उपयोग के बारे में जानेंगे।

मेम्बरशिप ऑपरेटरों की सूची (List of Membership Operators)

अनुक्रम में मौजूद (Present in the sequence) in

यह ऑपरेटर जांचता है कि कोई विशेष मान अनुक्रम (जैसे लिस्ट, ट्यूपल, स्ट्रिंग) में मौजूद है या नहीं।

# उदाहरण के लिए लिस्ट में
fruits = ["सेब", "केला", "संतरा"]
result = "सेब" in fruits
print("सेब in fruits:", result)   # आउटपुट: सेब in fruits: True

# उदाहरण के लिए स्ट्रिंग में
text = "नमस्ते दुनिया!"
result = "दुनिया" in text
print("दुनिया in text:", result)   # आउटपुट: दुनिया in text: True

अनुक्रम में मौजूद नहीं (Not present in the sequence) not in

यह ऑपरेटर जांचता है कि कोई विशेष मान अनुक्रम में मौजूद नहीं है।

# उदाहरण के लिए लिस्ट में
fruits = ["सेब", "केला", "संतरा"]
result = "आम" not in fruits
print("आम not in fruits:", result)   # आउटपुट: आम not in fruits: True

# उदाहरण के लिए स्ट्रिंग में
text = "नमस्ते दुनिया!"
result = "स्वागत" not in text
print("स्वागत not in text:", result)   # आउटपुट: स्वागत not in text: True

मेम्बरशिप ऑपरेटरों का उपयोग (Using Membership Operators)

मेम्बरशिप ऑपरेटरों का उपयोग कंडीशनल स्टेटमेंट्स (if, elif, else) में किया जा सकता है ताकि प्रोग्राम को निर्णय लेने में मदद मिल सके।

# उदाहरण के लिए लिस्ट में
fruits = ["सेब", "केला", "संतरा"]

if "सेब" in fruits:
    print("सेब लिस्ट में मौजूद है")
else:
    print("सेब लिस्ट में मौजूद नहीं है")

# उदाहरण के लिए स्ट्रिंग में
text = "नमस्ते दुनिया!"

if "दुनिया" in text:
    print("दुनिया टेक्स्ट में मौजूद है")
else:
    print("दुनिया टेक्स्ट में मौजूद नहीं है")

इस सेक्शन में, हमने पाइथन में उपलब्ध विभिन्न मेम्बरशिप ऑपरेटरों और उनके उपयोग के बारे में सीखा। अगली सेक्शन में, हम आइडेंटिटी ऑपरेटरों के बारे में जानेंगे और समझेंगे कि उनका उपयोग कैसे किया जाता है।

आइडेंटिटी ऑपरेटर (Identity Operators)

आइडेंटिटी ऑपरेटर (Identity Operators) का उपयोग यह जांचने के लिए किया जाता है कि क्या दो वेरिएबल्स समान ऑब्जेक्ट को संदर्भित करते हैं या नहीं। पाइथन में दो मुख्य आइडेंटिटी ऑपरेटर होते हैं: is और is not। ये ऑपरेटर बूलियन परिणाम (True या False) लौटाते हैं। इस सेक्शन में, हम पाइथन में उपलब्ध आइडेंटिटी ऑपरेटरों और उनके उपयोग के बारे में जानेंगे।

आइडेंटिटी ऑपरेटरों की सूची (List of Identity Operators)

समान ऑब्जेक्ट है (Identical to) is

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

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

result = (x is y)
print("x is y:", result)   # आउटपुट: x is y: True

result = (x is z)
print("x is z:", result)   # आउटपुट: x is z: False

स्पष्टीकरण (Explanation)

1. x = [1, 2, 3]: यह एक लिस्ट (list) बनाता है और उसे वेरिएबल x में असाइन करता है। अब x एक लिस्ट ऑब्जेक्ट को संदर्भित करता है जिसमें मान [1, 2, 3] हैं।
2. y = x: यह स्टेटमेंट वेरिएबल y को वही ऑब्जेक्ट संदर्भित कराता है जो x संदर्भित करता है। इसलिए, अब x और y दोनों एक ही लिस्ट ऑब्जेक्ट को संदर्भित कर रहे हैं।
3. z = [1, 2, 3]: यह एक नई लिस्ट (list) बनाता है और उसे वेरिएबल z में असाइन करता है। हालांकि इस लिस्ट के मान [1, 2, 3] x की लिस्ट के समान हैं, यह एक नया और अलग ऑब्जेक्ट है।
4. result = (x is y): is ऑपरेटर यह जांचता है कि क्या x और y एक ही ऑब्जेक्ट को संदर्भित कर रहे हैं। चूंकि y = x स्टेटमेंट के कारण x और y एक ही ऑब्जेक्ट को संदर्भित कर रहे हैं, परिणाम True होता है।
   print("x is y:", result) # आउटपुट: x is y: True

5. result = (x is z): is ऑपरेटर यह जांचता है कि क्या x और z एक ही ऑब्जेक्ट को संदर्भित कर रहे हैं। चूंकि z एक नई लिस्ट है, जो x से अलग है, परिणाम False होता है।
   print("x is z:", result) # आउटपुट: x is z: False


इस प्रकार, x is y का परिणाम True है क्योंकि x और y एक ही ऑब्जेक्ट को संदर्भित कर रहे हैं, जबकि x is z का परिणाम False है क्योंकि x और z अलग-अलग ऑब्जेक्ट्स हैं, भले ही उनके मान समान हों।

समान ऑब्जेक्ट नहीं है (Not identical to) is not

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

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

result = (x is not y)
print("x is not y:", result)   # आउटपुट: x is not y: False

result = (x is not z)
print("x is not z:", result)   # आउटपुट: x is not z: True

आइडेंटिटी ऑपरेटरों का उपयोग (Using Identity Operators)

आइडेंटिटी ऑपरेटरों का उपयोग तब किया जाता है जब यह जांचने की आवश्यकता होती है कि दो वेरिएबल्स वास्तव में एक ही ऑब्जेक्ट को संदर्भित कर रहे हैं या नहीं। यह विशेष रूप से तब महत्वपूर्ण होता है जब आप mutable (बदलने योग्य) ऑब्जेक्ट्स के साथ काम कर रहे होते हैं।

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

# जांचना कि x और y एक ही ऑब्जेक्ट को संदर्भित कर रहे हैं
if x is y:
    print("x और y एक ही ऑब्जेक्ट को संदर्भित कर रहे हैं")
else:
    print("x और y एक ही ऑब्जेक्ट को संदर्भित नहीं कर रहे हैं")

# जांचना कि x और z एक ही ऑब्जेक्ट को संदर्भित नहीं कर रहे हैं
if x is not z:
    print("x और z एक ही ऑब्जेक्ट को संदर्भित नहीं कर रहे हैं")
else:
    print("x और z एक ही ऑब्जेक्ट को संदर्भित कर रहे हैं")

ऑपरेटर प्रेसीडेंस (Operator Precedence)

ऑपरेटर प्रेसीडेंस (Operator Precedence) यह निर्धारित करता है कि जब एक ही एक्सप्रेशन में कई ऑपरेटर होते हैं, तो कौन सा ऑपरेटर पहले निष्पादित होगा। पाइथन में विभिन्न ऑपरेटरों की प्राथमिकता निर्धारित की गई है, जो यह निर्धारित करती है कि कौन से ऑपरेटर पहले मूल्यांकन किए जाएंगे। इस सेक्शन में, हम पाइथन में ऑपरेटर प्रेसीडेंस और इसके उपयोग के बारे में जानेंगे।

ऑपरेटर प्रेसीडेंस की सूची (List of Operator Precedence)

पाइथन में ऑपरेटर प्रेसीडेंस की एक निश्चित क्रम होता है, जिसे निम्न तालिका में दर्शाया गया है:

ऑपरेटर प्रेसीडेंस का महत्व (Importance of Operator Precedence)

ऑपरेटर प्रेसीडेंस यह सुनिश्चित करता है कि जब एक ही एक्सप्रेशन में कई ऑपरेटर होते हैं, तो ऑपरेटरों को सही क्रम में निष्पादित किया जाएगा। यह प्रोग्राम के तर्क को सही ढंग से बनाए रखने में मदद करता है और संभावित त्रुटियों को रोकता है।

उदाहरण (Examples)

नीचे कुछ उदाहरण दिए गए हैं जो ऑपरेटर प्रेसीडेंस को स्पष्ट करते हैं:

1. घात (**) और गुणा (*) ऑपरेटर:

   result = 2 + 3 * 2 ** 2
   # प्रेसीडेंस: ** > * > +
   # 2 + (3 * (2 ** 2))
   # 2 + (3 * 4)
   # 2 + 12
   # परिणाम: 14
   print("result:", result)   # आउटपुट: result: 14
   

    

2. पैरेंटेसेस (()) का उपयोग:

   result = (2 + 3) * 2
   # प्रेसीडेंस: () > *
   # (2 + 3) * 2
   # 5 * 2
   # परिणाम: 10
   print("result:", result)   # आउटपुट: result: 10
   

    

3. लॉजिकल ऑपरेटर:

   result = True or False and False
   # प्रेसीडेंस: and > or
   # True or (False and False)
   # True or False
   # परिणाम: True
   print("result:", result)   # आउटपुट: result: True
   

    

4. तुलना और पहचान ऑपरेटर:

   x = 5
   y = 10
   z = 5
   result = x < y and x is z
   # प्रेसीडेंस: <, is > and
   # (x < y) and (x is z)
   # (True) and (True)
   # परिणाम: True
   print("result:", result)   # आउटपुट: result: True
   

    

प्रेसीडेंस को ओवरराइड करना (Overriding Precedence)

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

result = (2 + 3) * 2 ** 2
# प्रेसीडेंस: () > **
# (2 + 3) * (2 ** 2)
# 5 * 4
# परिणाम: 20
print("result:", result)   # आउटपुट: result: 20