पायथन में ऑपरेटर्स

यह लेख पायथन में ऑपरेटर्स को समझाता है।

YouTube Video

पायथन में ऑपरेटर्स

पायथन में विभिन्न प्रकार के ऑपरेटर्स हैं, जिन्हें मुख्य रूप से निम्नलिखित श्रेणियों में बांटा जा सकता है। हम प्रत्येक श्रेणी के प्रतिनिधि ऑपरेटर्स की व्याख्या करेंगे।

अंकगणित ऑपरेटर्स

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

 1a = 10
 2b = 3
 3
 4print(f"{a} + {b} = {a + b}")     # Addition
 5print(f"{a} - {b} = {a - b}")     # Subtraction
 6print(f"{a} * {b} = {a * b}")     # Multiplication
 7print(f"{a} / {b} = {a / b}")     # Division (float)
 8print(f"6 / 3 = {6 / 3}")         # Division (float)
 9print(f"{a} // {b} = {a // b}")   # Floor Division
10print(f"{a} % {b} = {a % b}")     # Modulo (remainder)
11print(f"{a} ** {b} = {a ** b}")   # Exponentiation

• चार मूल अंकगणितीय संक्रियाओं के अलावा, Python विभाजन (/), पूर्णांक विभाजन (//), मापांक (%), और घात (**) के लिए ऑपरेटर प्रदान करता है। विभाजन पूर्णांकों को विभाजित करने पर भी एक फ्लोटिंग-प्वाइंट संख्या लौटाता है।

असाइनमेंट ऑपरेटर्स

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

 1x = 5           # x = 5
 2
 3x += 3          # x = x + 3
 4x -= 2          # x = x - 2
 5x *= 4          # x = x * 4
 6x /= 3          # x = x / 3
 7x //= 2         # x = x // 2
 8x %= 5          # x = x % 5
 9x **= 3         # x = x ** 3
10
11x = 0b1100      # x = 0b1100 (12)
12
13x &= 0b1010     # x = x & 0b1010
14x |= 0b0011     # x = x | 0b0011
15x ^= 0b0101     # x = x ^ 0b0101
16x <<= 2         # x = x << 2
17x >>= 1         # x = x >> 1
18
19print(bin(x))   # Display in binary
20print(x)        # Display in decimal
21
22# Walrus operator
23if (n := len("hello")) > 3:
24    print(f"Length is {n}")

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

तुलना ऑपरेटर्स

तुलना ऑपरेटर मानों की तुलना करते हैं और True या False लौटाते हैं।

 1a = 10
 2b = 20
 3
 4# Equal to (==)
 5print(f"{a} == {b} -> {a == b}")      # False: a and b are not equal
 6print(f"3 == 3.0 -> {3 == 3.0}")      # True: int and float with the same value are equal
 7print(f"3 == '3' -> {3 == '3'}")      # False: different types (int vs str)
 8print(f"True == 1 -> {True == 1}")    # True: True is equivalent to 1
 9print(f"False == 0 -> {False == 0}")  # True: False is equivalent to 0
10print(f"None == 0 -> {None == 0}")    # False: None is not equal to 0
11
12# Not equal to (!=)
13print(f"{a} != {b} -> {a != b}")      # True: a and b are not equal
14
15# Greater than (>)
16print(f"{b} > {a} -> {b > a}")        # True: 20 > 10
17
18# Less than (<)
19print(f"{a} < {b} -> {a < b}")        # True: 10 < 20
20
21# Greater than or equal to (>=)
22print(f"{a} >= 10 -> {a >= 10}")      # True: a is greater than or equal to 10
23
24# Less than or equal to (<=)
25print(f"{a} <= 10 -> {a <= 10}")      # True: a is less than or equal to 10

• तुलना ऑपरेटर दो मानों की क्रम या समानता की तुलना करते हैं और परिणामस्वरूप True या False लौटाते हैं।
• Python में, विभिन्न डेटा प्रकारों की तुलना करते समय सावधान रहना चाहिए। कुछ प्रकारों की आपस में तुलना की जा सकती है, लेकिन परिणाम हमेशा सहज नहीं होते।

लॉजिकल ऑपरेटर्स

तार्किक ऑपरेटर लॉजिकल अभिव्यक्तियों को संयोजित करने के लिए उपयोग किए जाते हैं।

1x = 10
2print(x > 5 and x < 20)  # True
3print(x < 5 or x > 20)   # False
4print(not x == 10)       # False

• and एक तार्किक ऑपरेटर है जो केवल तभी True लौटाता है जब बाएँ और दाएँ दोनों शर्तें True हों।
• or एक तार्किक ऑपरेटर है जो या तो बाईं या दाईं शर्त True होने पर True लौटाता है।
• not एक तार्किक ऑपरेटर है जो किसी शर्त का सत्य मान उलट देता है। अगर यह True है, तो यह False बन जाता है, और अगर यह False है, तो यह True बन जाता है।

लॉजिक ऑपरेटरों की प्राथमिकता

ऑपरेटरों की अपनी प्राथमिकता होती है। यह वह नियम है जो यह निर्धारित करता है कि किसी अभिव्यक्ति में सबसे पहले किस ऑपरेटर का मूल्यांकन किया जाएगा। लॉजिक ऑपरेटरों का मूल्यांकन इस क्रम में होता है: not, फिर and, फिर or।

1result = True or False and False
2print(result)  # True
3
4result = (True or False) and False
5print(result)  # False

たとえば、

पहले उदाहरण में, सबसे पहले and का मूल्यांकन होता है, इसलिए False and False के परिणामस्वरूप False मिलता है, और इसके बाद True or False का परिणाम True होता है। आप परांथेसिस (कोष्ठक) का उपयोग करके मूल्यांकन के क्रम को बदल सकते हैं, जैसा कि दूसरे उदाहरण में दिखाया गया है।

बिटवाइज ऑपरेटर्स

बिटवाइज़ ऑपरेटर बिट स्तर पर संचालन करते हैं।

 1# Sample code for bitwise operators
 2
 3# Define two integers
 4a = 5  # Binary: 0101
 5b = 3  # Binary: 0011
 6
 7# Bitwise AND
 8result_and = a & b  # Binary: 0001 -> Decimal: 1
 9print(f"{a} & {b} = {result_and}")
10
11# Bitwise OR
12result_or = a | b  # Binary: 0111 -> Decimal: 7
13print(f"{a} | {b} = {result_or}")
14
15# Bitwise XOR
16result_xor = a ^ b  # Binary: 0110 -> Decimal: 6
17print(f"{a} ^ {b} = {result_xor}")
18
19# Bitwise NOT (inverting bits)
20result_not = ~a  # Binary: -(0101 + 1) -> Decimal: -6
21print(f"~{a} = {result_not}")
22
23# Left shift
24shift_left = a << 1  # Binary: 1010 -> Decimal: 10
25print(f"{a} << 1 = {shift_left}")
26
27# Right shift
28shift_right = a >> 1  # Binary: 0010 -> Decimal: 2
29print(f"{a} >> 1 = {shift_right}")

• आप बिटवाइज़ AND, OR, XOR, NOT ऑपरेशन्स के साथ-साथ बिट शिफ्ट ऑपरेशन्स भी कर सकते हैं। आप इन्हें असाइनमेंट ऑपरेटरों (जैसे &=) के साथ भी जोड़ सकते हैं।

सदस्यता ऑपरेटर्स

सदस्यता ऑपरेटर सूचियाँ और शब्दकोश जैसी संग्रहित वस्तुओं के साथ उपयोग किए जाते हैं।

 1x = [1, 2, 3]
 2y = 2
 3z = 4
 4
 5print("y in x : ", y in x)  # Result is True
 6print("z in x : ", z in x)  # Result is False
 7
 8print("y not in x : ", y not in x)  # Result is False
 9print("z not in x : ", z not in x)  # Result is True
10
11text = "hello world"
12print("'world' in 'hello world' : ",      "world" in text)      # True
13print("'python' not in 'hello world' : ", "python" not in text) # True

• in ऑपरेटर का उपयोग यह निर्धारित करने के लिए किया जाता है कि कोई दिया गया मान किसी अनुक्रम जैसे सूची (list) या स्ट्रिंग (string), या किसी संग्रह (collection) जैसे शब्दकोश (dictionary) में मौजूद है या नहीं।
• not in ऑपरेटर का उपयोग यह निर्धारित करने के लिए किया जाता है कि कोई दिया गया मान किसी अनुक्रम (sequence) या संग्रह (collection) में मौजूद नहीं है।

पहचान ऑपरेटर्स

पहचान ऑपरेटर वस्तुओं की पहचान की जांच करते हैं।

 1x = [1, 2, 3]
 2y = x
 3z = x.copy()
 4
 5print("x is y : ", x is y)  # Result is True
 6print("x is z : ", x is z)  # Result is False
 7
 8print("x is not y : ", x is not y)  # Result is False
 9print("x is not z : ", x is not z)  # Result is True
10
11print("x == y : ", x == y)  # Result is True
12print("x == z : ", x == z)  # Result is True

• is ऑपरेटर यह जांचता है कि दो ऑब्जेक्ट एक ही ऑब्जेक्ट हैं या नहीं (अर्थात वे मेमोरी के एक ही स्थान को संदर्भित करते हैं)।
• is not ऑपरेटर यह जांचता है कि दो ऑब्जेक्ट अलग-अलग ऑब्जेक्ट हैं या नहीं।
• उदाहरण के लिए, x is y, x == y से इस प्रकार भिन्न है कि यह ऑब्जेक्ट की समानता की जांच करता है, न कि मूल्य समानता की।

टाइप जांच

Python में आप isinstance() फंक्शन का उपयोग किसी मान के विशेष प्रकार का होने की जांच के लिए करते हैं। आप type() फंक्शन का उपयोग किसी वेरिएबल के बिल्कुल सही प्रकार की जांच के लिए भी कर सकते हैं। हालांकि ये ऑपरेटर नहीं हैं, ये टाइप जांच के मूलभूत तरीकों में आते हैं।

 1x = 10
 2print(isinstance(x, int))  # True
 3
 4y = "hello"
 5print(isinstance(y, str))  # True
 6
 7z = [1, 2, 3]
 8print(isinstance(z, list))  # True
 9
10print(type(10))        # <class 'int'>
11print(type("hello"))   # <class 'str'>
12
13print("isinstance(3, int) : ", isinstance(3, int))  # True
14print("type(3) is int : ", type(3) is int)          # True
15print("type(True) is bool : ", type(True) is bool)  # True

• isinstance() एक फ़ंक्शन है जो जांचता है कि कोई ऑब्जेक्ट निर्दिष्ट क्लास या उसके उपवर्ग का इंस्टेंस है या नहीं।
• type() एक फ़ंक्शन है जो किसी ऑब्जेक्ट का सटीक प्रकार (क्लास) लौटाता है। इसका प्रायः उपयोग तब किया जाता है जब आप सख्त प्रकार की तुलना करना चाहते हैं।
• isinstance() विरासत (इनहेरिटेंस) संबंधों को ध्यान में रखता है, जबकि type() बिल्कुल सही मिलान की जांच करता है।

सारांश

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

आप हमारे YouTube चैनल पर Visual Studio Code का उपयोग करके ऊपर दिए गए लेख के साथ आगे बढ़ सकते हैं। कृपया YouTube चैनल को भी देखें।

YouTube Video