इन ऑपरेटरों का क्या अर्थ है (**, ^,%, //)? - पायथन?

Question

मानक +, -, * और / ऑपरेटरों के अलावा; लेकिन इनका मतलब क्या है (**, ^, %, //)?

>>> 9+float(2) # addition 
11.0 
>>> 9-float(2) # subtraction 
7.0 
>>> 9*float(2) # multiplication 
18.0 
>>> 9/float(2) # division 
4.5 
>>> 
>>> 9**float(2) # This looks like a square, (i.e. power 2) 
81.0 
>>> 9**float(3) # So ** is equivalent to `math.pow(x,p)` ? 
729.0 

कैसे ^ ऑपरेटर के बारे में?

>>> 9^int(2) # What is `^` in `x^u` , it only allows `int` for `u` 
11 
>>> 9^int(3) 
10 
>>> 9^int(4) 
13 
>>> 9^int(5) 
12 
>>> 9^int(6) 
15 
>>> 9^int(7) 
14 
>>> 9^int(8) 
1 
>>> 9^int(9) 
0 
>>> 9^int(10) 
3 
>>> 9^int(11) 
2 
>>> 9^int(12) 
5 

x%m में % एक सामान्य शेष मापांक देता है, लेकिन केवल m < x अगर, क्यों है इतना है कि? % क्या करता है?

>>> 9%float(2) 
1.0 
>>> 9%float(3) 
0.0 
>>> 9%float(4) 
1.0 
>>> 9%float(5) 
4.0 
>>> 9%float(6) 
3.0 
>>> 9%float(7) 
2.0 
>>> 9%float(8) 
1.0 
>>> 9%float(9) 
0.0 
>>> 9%float(10) 
9.0 
>>> 9%float(11) 
9.0 
>>> 9%float(12) 
9.0 

कैसे // ऑपरेटर के बारे में? यह क्या करता है?

>>> 9//float(2) 
4.0 
>>> 9//float(3) 
3.0 
>>> 9//float(4) 
2.0 
>>> 9//float(5) 
1.0 
>>> 9//float(6) 
1.0 
>>> 9//float(7) 
1.0 
>>> 9//float(8) 
1.0 
>>> 9//float(9) 
1.0 
>>> 9//float(1) 
9.0 
>>> 9//float(0.5) 
18.0 

Answer 1

• **: घातांक
• ^: अनन्य या (बिटवाइज़)
• %: मापांक
• //: अभिन्न परिणाम के साथ विभाजन (छोड़ें शेष)

Answer 2

आप सही हैं कि ** पाउ है एर समारोह

^ बिटवाई एक्सओआर है।

% वास्तव में मॉड्यूलस ऑपरेशन है, लेकिन ध्यान दें कि सकारात्मक संख्याओं के लिए, x % m = x जब भी m > x। यह मॉड्यूलस की परिभाषा से पालन करता है। (इसके अतिरिक्त, पाइथन x % m को m का संकेत प्राप्त करने के लिए निर्दिष्ट करता है।)

// एक विभाजन ऑपरेशन है जो शेष को छोड़कर एक पूर्णांक देता है। अधिकांश प्रोग्रामिंग भाषाओं में / का उपयोग करके यह विभाजन का मानक रूप है। हालांकि, पायथन / के व्यवहार को फ्लोटिंग-पॉइंट डिवीजन करने के लिए बदल दिया है भले ही तर्क पूर्णांक हैं। // ऑपरेटर अजगर 2.6 और अजगर 3 में पेश किया गया था एक पूर्णांक विभाजन ऑपरेटर कि अजगर 2 और अजगर 3. के बीच लगातार कैसा व्यवहार करेंगे इसका मतलब यह है प्रदान करने के लिए:

| context        | `/` behavior | `//` behavior | 
--------------------------------------------------------------------------- 
| floating-point arguments, Python 2 & 3 | float division | int divison | 
--------------------------------------------------------------------------- 
| integer arguments, python 2   | int division | int division | 
--------------------------------------------------------------------------- 
| integer arguments, python 3   | float division | int division | 

अधिक जानकारी के लिए इस सवाल का देखें: Division in Python 2.7. and 3.3

Answer 3

आप उन सभी ऑपरेटरों को Python language reference में पा सकते हैं, हालांकि आपको उन्हें सभी खोजने के लिए थोड़ा सा स्क्रॉल करना होगा। जैसा कि अन्य उत्तरों ने कहा है:

• ** ऑपरेटर एक्सपोनेंटिएशन करता है। a ** bab शक्ति तक बढ़ाया गया है।एक ही ** प्रतीक का प्रयोग फ़ंक्शन तर्क और कॉलिंग नोटेशन में भी किया जाता है, एक अलग अर्थ के साथ (मनमाना कीवर्ड तर्क गुजरना और प्राप्त करना)।
• ^ ऑपरेटर एक बाइनरी xor करता है। a^ba या b में सेट की गई बिट्स के साथ ही एक मान वापस करेगा, लेकिन दोनों नहीं। यह एक आसान है!
• % ऑपरेटर ज्यादातर दो पूर्णांक के मॉड्यूलस को खोजने के लिए है। a % bab द्वारा विभाजित करने के बाद शेष को वापस कर देता है। कुछ अन्य प्रोग्रामिंग भाषाओं (जैसे सी) में मॉड्यूलस ऑपरेटरों के विपरीत, पाइथन में एक मॉड्यूलस के समान के समान संकेत के बजाय b जैसा ही संकेत होगा। स्ट्रिंग स्वरूपण की "पुरानी" शैली के लिए एक ही ऑपरेटर का भी उपयोग किया जाता है, इसलिए a % ba एक प्रारूप स्ट्रिंग है और b एक मान (या मानों का ट्यूपल) है जो a में डाला जा सकता है।
• // ऑपरेटर पाइथन का पूर्णांक विभाजन का संस्करण करता है। पायथन का पूर्णांक विभाजन बिल्कुल अन्य भाषाओं (जैसे सी) द्वारा प्रदान किए गए पूर्णांक विभाजन के समान नहीं है, क्योंकि यह शून्य की बजाय नकारात्मक अनंतता की ओर जाता है। मॉड्यूलस ऑपरेटर के साथ, आप कह सकते हैं कि a == (a // b)*b + (a % b)। पायथन 2 में, फर्श डिवीजन डिफ़ॉल्ट व्यवहार होता है जब आप दो पूर्णांक विभाजित करते हैं (सामान्य विभाजन ऑपरेटर / का उपयोग करके)। चूंकि यह अप्रत्याशित हो सकता है (विशेष रूप से जब आप इस बात के बारे में नहीं चुनते कि आपको किसी फ़ंक्शन के तर्क के रूप में किस प्रकार की संख्या मिलती है), पाइथन 3 "सत्य" (फ़्लोटिंग पॉइंट) को विभाजन के लिए मानक बनाने के लिए बदल गया है जो गोलाकार होगा अन्यथा, और यह स्पष्ट रूप से अनुरोध किए जाने पर ही "मंजिल" विभाजन करेगा। (आप अपनी फ़ाइलों के शीर्ष पर from __future__ import division डालकर पाइथन 2 में नया व्यवहार भी प्राप्त कर सकते हैं। मैं दृढ़ता से इसकी अनुशंसा करता हूं!)