Python में ऑपरेटर्स

गणित की तरह ही, Python जैसे प्रोग्रामिंग भाषाओं में भी ऑपरेटर्स होते हैं। आप इन्हें बेहद सरल फंक्शंस की तरह समझ सकते हैं जो कंप्यूटर विज्ञान की बुनियाद में होते हैं। ये वे सबसे सरल क्रियाएँ हैं जिनमें किसी कंप्यूटर प्रोग्राम को घटाया जा सकता है। किसी भी उभरते Data Scientist या Software Engineer के लिए यह अनिवार्य ज्ञान है।

इस ट्यूटोरियल में, आप सीखेंगे:

• ऑपरेटर्स के अलग-अलग प्रकार: Arithmetic, Assignment, Comparison और Logical
• Operator Overloading
• Precedence
• Associativity

यदि आप Python प्रोग्रामिंग भाषा की मूल बातें और अधिक सीखना चाहते हैं, तो हमारा निःशुल्क Intro to Python for Data Science कोर्स ज़रूर देखें।

Artithmetic Operators

आप संभवतः पहले से ही इनसे परिचित होंगे, क्योंकि ये बुनियादी गणित से आते हैं।

Arithmetic ऑपरेटर्स हैं addition (+), subtraction (-), multiplication (*), division (/), exponent (**), floor division (//) और modulus (%)। पहले चार काफ़ी सरल हैं; ये जोड़, घटाव, गुणा और भाग हैं, और आप शायद पहले से इन्हें जानते होंगे।

# Addition
print(5 + 2)

# Subtraction
print(5 - 2)

# Multiplication
print(5 * 2)

# Division
print(5 / 2)
संचालित द्वारा

7
3
10
2.5
संचालित द्वारा

बाकी तीन थोड़े अधिक जटिल हैं। Exponent ऑपरेटर का अर्थ है 'घात'। उदाहरण के लिए, 2 ** 3 का मतलब है कि 2 को खुद से 3 बार गुणा किया गया है, इसलिए 2 ** 3 वही है जो 2 * 2 * 2, जो 8 के बराबर है।

Floor division सामान्य division जैसा ही है, सिवाय इसके कि परिणाम हमेशा नीचे की ओर पूर्णांक में गोल कर दिया जाता है। नीचे दिए उदाहरण में, 5 को 2 से भाग देने पर 2.5 मिलता है। पर चूँकि यह floor division है, 2.5 को घटाकर 2 कर दिया जाता है।

अंत में, modulus भाग देने के बाद शेषफल होता है। 5%2 के मामले में, 2 संख्या 5 में केवल दो बार फिट होती है, जिसका मतलब है शेष 1 रहता है।

# Exponent
print(5 ** 2)
# This is the same as 5 * 5

# Floor Division
print(5 // 2)

# Modulus
print(5 % 2)
संचालित द्वारा

25
2
1
संचालित द्वारा

Python में, addition ऑपरेटर का उपयोग strings को एक साथ जोड़ने के लिए भी किया जा सकता है। इसका मतलब है कि उन्हें जोड़कर एक एकल string बना दिया जाएगा, उदाहरण के लिए:

firstName = "Théo"

introduction = "Hi, my name is " + firstName + "."

print(introduction)
संचालित द्वारा

Hi, my name is Théo.
संचालित द्वारा

Assignment Operators

यदि आपके पास कुछ प्रोग्रामिंग अनुभव है, तो आपने निश्चित रूप से पहले assignment ऑपरेटर्स का उपयोग किया होगा। ये किसी वैरिएबल को एक निश्चित मान असाइन करते हैं। सबसे ज़्यादा इस्तेमाल होने वाला है =। इसका उपयोग करने के लिए, बस उस वैरिएबल का नाम लिखें जिसे आप नया मान देना चाहते हैं, फिर =, और उसके बाद वह मान जिसे आप असाइन करना चाहते हैं। उदाहरण के लिए, यदि आप वैरिएबल balance को 100 का मान देना चाहते हैं, तो आप ऐसा कर सकते हैं:

balance = 100
print(balance)
संचालित द्वारा

100
संचालित द्वारा

यदि आप balance के मान को 10 से बढ़ाना चाहते हैं, तो आप balance += 10 का उपयोग कर सकते हैं। यह balance = balance + 10 के बराबर है, लेकिन यह कहीं छोटा है।

balance += 10
print(balance)
संचालित द्वारा

110
संचालित द्वारा

यही बात -= पर भी लागू होती है, balance -= 10 वही है जो balance = balance - 10:

print(balance)
balance -= 10
print(balance)
संचालित द्वारा

110
100
संचालित द्वारा

अन्य assignment ऑपरेटर्स भी बिल्कुल इसी तरह काम करते हैं। ये हैं:

• *=
• /=
• **=
• //=
• %=

Comparison Operators

आप comparison ऑपरेटर्स का उपयोग, जैसा कि नाम से स्पष्ट है, वैरिएबल्स के मानों की तुलना करने के लिए कर सकते हैं। ये हमेशा एक बूलियन मान लौटाते हैं, जो या तो True होता है या False। ये छह प्रकार के होते हैं:

• Equal: ==
• Not equal: !=
• Greater than: >
• Less than: <
• Greater than or equal: >=
• Less than or equal: <=

यहाँ कुछ उदाहरण तुलना दी गई हैं:

a = 3
b = 5

print(a == b) # Equal
print(a != b) # Not equal
print(a > b) # Greater than
print(a < b) # Less than
print(a >= b) # Greater than or equal to
print(a <= b) # Less than or equal to
संचालित द्वारा

False
True
False
True
False
True
संचालित द्वारा

== और != का उपयोग संख्याओं के बजाय strings की तुलना के लिए भी किया जा सकता है। अन्य ऑपरेटर्स strings के साथ संगत नहीं हैं, क्योंकि वास्तव में कोई string दूसरी string से "अधिक" नहीं हो सकती।

print("Hello" == "World")
print("Python" != "R")
संचालित द्वारा

False
True
संचालित द्वारा

Logical Operators

आप शायद पहले से ही इनसे परिचित हों! तर्कशास्त्र में इन्हें logical connectives कहा जाता है। ये मानवीय भाषा में भी व्यापक रूप से उपयोग होते हैं। ये हैं: and, or और not।

and केवल तभी True लौटाता है जब दोनों ऑपरेन्ड्स (दोनों बूलियन ऑब्जेक्ट जिनकी आप तुलना कर रहे हैं) True हों। उदाहरण के लिए:

print(True and True)
print(True and False)
print(False and False)
संचालित द्वारा

True
False
False
संचालित द्वारा

इस लॉजिकल ऑपरेटर के व्यवहार को समझने के लिए, आप एक ट्रुथ टेबल का उपयोग कर सकते हैं:

or तब True होता है जब कोई भी (एक या अधिक) ऑपरेन्ड True हो।

print(True and True)
print(True and False)
संचालित द्वारा

True
False
संचालित द्वारा

ध्यान दें कि ये दो से अधिक ऑपरेन्ड्स के साथ भी काम करते हैं, उदाहरण के लिए:

print(True and True and True and True)
print(True and True and True and False)
print(False or False or False or False)
print(False or False or False or True)
संचालित द्वारा

True
False
False
True
संचालित द्वारा

not अपने ऑपरेन्ड के विपरीत मान लौटाता है, यानी यदि False दिया गया है तो True और इसके विपरीत।

print(not True)
संचालित द्वारा

False
संचालित द्वारा

Operator overloading

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

यहाँ एक उदाहरण है। मान लीजिए आपके पास दो Dog ऑब्जेक्ट्स हैं, ozzy और filou। ये नीचे दी गई Dog क्लास के हैं। आप क्लास को एक ब्लूप्रिंट की तरह सोच सकते हैं जो बताता है कि ऑब्जेक्ट्स कैसे दिखेंगे और कैसे व्यवहार करेंगे। इस मामले में, Dog ऑब्जेक्ट्स के पास नाम, उम्र और कद (height) है। क्लास परिभाषित होने के बाद, आप ऑब्जेक्ट्स बना सकते हैं। उनमें से एक Ozzy है, जिसकी उम्र 3 साल और कद 30 सेंटीमीटर है। दूसरा Filou है, वह 5 साल का और 65 सेंटीमीटर लंबा है।

यह उदाहरण Object-Oriented Programming की अवधारणा का उपयोग करता है। यदि आप इसके बारे में और सीखना चाहते हैं, तो हमारा Object-Oriented Programming in Python पर ट्यूटोरियल ज़रूर पढ़ें।

मान लीजिए आप दोनों कुत्तों की तुलना greater than: > से करना चाहते हैं। यह काम नहीं करेगा। आपको यह त्रुटि मिलेगी: '>' not supported between instances of 'Dog' and 'Dog'। इसका मतलब है कि > को Dog क्लास के ऑब्जेक्ट्स की तुलना करना नहीं आता।

class Dog:

    def __init__(self, name, age, height):  
        self.name = name
        self.age = age
        self.height = height

ozzy = Dog("Ozzy", 3, 30)
filou = Dog("Filou", 5, 65)

print(filou > ozzy)
संचालित द्वारा

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

TypeError                                 Traceback (most recent call last)

<ipython-input-96-428069ab24cc> in <module>()
      9 filou = Dog("Filou", 5, 65)
     10
---> 11 print(filou > ozzy)


TypeError: '>' not supported between instances of 'Dog' and 'Dog'
संचालित द्वारा

खुशकिस्मती से, ऑपरेटर ओवरलोडिंग के साथ, आप यह परिभाषित कर सकते हैं कि जब ऑपरेटर को Dog ऑब्जेक्ट्स पर बुलाया जाए तो उसका व्यवहार क्या होगा। इस मामले में, __gt__ नाम की एक मेथड, जिसका अर्थ 'greater than' है, परिभाषित करनी होगी, जो दो आर्गुमेंट लेती है। चूँकि हम अपने कुत्तों की तुलना उनके कद पर करना चाहते हैं, मेथड self.height > other.height लौटाती है।

class Dog:

    def __init__(self, name, age, height):  
        self.name = name
        self.age = age
        self.height = height

    def __gt__(self,other):
        return self.height > other.height

ozzy = Dog("Ozzy", 3, 30)
filou = Dog("Filou", 5, 65)

print(filou > ozzy)
print(ozzy > filou)
संचालित द्वारा

True
False
संचालित द्वारा

Precedence

जब आप बहुत सारे ऑपरेटर्स को जोड़ते हैं, तो चीजें भ्रमित हो सकती हैं। नीचे दिए उदाहरण पर नज़र डालें:

a = 2
b = 3
c = 9

a ** b > 5 and c - a // b >= 9 or b ** 2 == c
संचालित द्वारा

True
संचालित द्वारा

आप कैसे जानेंगे कि सबसे पहले कौन सा चलेगा? इतनी सारी निशानियों वाली कोड की लाइन को कैसे पढ़ना चाहिए? क्या यह बाएँ से दाएँ चलती है या कोई विशिष्ट क्रम है?

यहीं पर precedence काम आती है। Python ऑपरेटर्स एक बहुत ही विशिष्ट क्रम में चलते हैं, और कुछ को दूसरों पर प्राथमिकता मिलती है।

निम्न तालिका में, आप ऑपरेटर्स के लिए precedence ऊपर से नीचे के क्रम में देख सकते हैं। ये नियम गणित में भी वही हैं, जहाँ किसी सूत्र में कुछ गणनाएँ दूसरों से पहले की जानी होती हैं।

Associativity

आपने देखा कि precedence मायने रखती है! लेकिन जो एक ही precedence स्तर पर हैं, जैसे multiplication और division, उनका क्या? क्या वे एक साथ चलते हैं? नहीं। *, \, % और \\ बाएँ से दाएँ चलते हैं, जबकि ** दाएँ से बाएँ चलता है। इसे associativity कहा जाता है।

निम्न उदाहरण देखें। इस मामले में, ऑपरेटर्स बाएँ से दाएँ चलेंगे, और आउटपुट 3 होगा।

print(5 * 2 // 3)
संचालित द्वारा

3
संचालित द्वारा

हालाँकि, कोष्ठक जोड़कर आप ऑपरेटर्स के चलने के क्रम को बदल सकते हैं। यही associativity है, जो गणित में associativity की तरह ही काम करती है। जो कुछ भी ब्रैकेट्स के बीच है, वह पहले गणना किया जाएगा। इस मामले में, पहले floor division किया जाएगा, फिर multiplication।

print(5 * (2 // 3))
संचालित द्वारा

Conclusion

अब आप जानते हैं कि ऑपरेटर्स क्या होते हैं, उन्हें कैसे इस्तेमाल करना है और वे कैसे काम करते हैं। आपने overloading, precedence और associativity के बारे में भी सीखा। आप Python में महारत हासिल करने की राह पर अच्छी तरह आगे बढ़ रहे हैं! यदि आप और भी सीखना चाहते हैं, तो हमारा Intermediate Python for Data Science कोर्स देखना न भूलें।