पायथन खालील बिटवाइज ऑपरेटर प्रदान करते, जे अनुक्रमे बायनरी पूर्णांक प्रकार इंट व्हॅल्यूच्या प्रत्येक बिटवर लॉजिकल संयोजन, तार्किक वियोग, अनन्य वियोग, बिटवाइज इन्व्हर्शन, डावे बिट शिफ्ट आणि उजवे बिट शिफ्ट करतात.
&|^~<<>>
या विभागात, आम्ही प्रथम खालील स्पष्ट करतो.
- छेदनबिंदू(AND) :
& - वियोग(OR) :
| - EXCLUSIVE-किंवा ऑपरेशन(XOR) :
^
पुढे आपण पुढील गोष्टींवर चर्चा करू.
- ऋण पूर्णांकांवर बिटवाइज ऑपरेशन्स
- थोडा झटका( NOT) :
~ - थोडा शिफ्ट:
<<,>>
बायनरी, ऑक्टल आणि हेक्साडेसिमलमध्ये पूर्णांक कसे लिहायचे आणि खालील फंक्शन्सचा वापर करून बायनरी, ऑक्टल आणि हेक्साडेसिमल संख्या आणि स्ट्रिंगचे रूपांतर कसे करायचे याबद्दल अधिक माहितीसाठी, पुढील लेख पहा.
bin()oct()hex()format()
- संबंधित लेख:बायनरी, ऑक्टल आणि हेक्साडेसिमल संख्या आणि स्ट्रिंग्सना पायथनमध्ये एकमेकांमध्ये रूपांतरित करा
तसेच, बिटवाइज ऑपरेशन्सऐवजी बुलियन व्हॅल्यूजवरील लॉजिकल ऑपरेशन्स (बुलियन ऑपरेशन्स) (खरे, असत्य) साठी, खालील लेख पहा. &,| च्या ऐवजी आणि, किंवा वापरा.
छेदनबिंदू(AND) :&ऑपरेटर
हे तार्किक आणि & वापरण्याचे उदाहरण आहे. ऑपरेटर, परिणाम bin() द्वारे बायनरी नोटेशनमधील स्ट्रिंगमध्ये रूपांतरित केला जातो.
x = 9 # 0b1001 y = 10 # 0b1010 print(x & y) print(bin(x & y)) # 8 # 0b1000
वियोग(OR) :|ऑपरेटर
| वापरून तार्किक उत्पादनाचे (OR) उदाहरण ऑपरेटर, परिणाम bin() आणि आउटपुट द्वारे बायनरी नोटेशनमधील स्ट्रिंगमध्ये रूपांतरित केला जातो.
print(x | y) print(bin(x | y)) # 11 # 0b1011
EXCLUSIVE-किंवा ऑपरेशन(XOR) :^ऑपरेटर
^ ऑपरेटर वापरून लॉजिकल उत्पादनाचे उदाहरण (XOR), bin() वापरून बायनरी नोटेशनमधील स्ट्रिंगमध्ये रूपांतरणाच्या परिणामासह एकत्रित.
print(x ^ y) print(bin(x ^ y)) # 3 # 0b11
लॉजिकल AND, OR, आणि XOR च्या प्रत्येक बिटसाठी इनपुट आणि आउटपुटमधील संबंध खालील तक्त्यामध्ये दर्शविला आहे.
| इनपुट १ | इनपुट 2 | छेदनबिंदू(AND) | वियोग(OR) | EXCLUSIVE-किंवा ऑपरेशन(XOR) |
|---|---|---|---|---|
| 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 |
| 0 | 1 | 0 | 1 | 1 |
| 0 | 0 | 0 | 0 | 0 |
ऋण पूर्णांकांवर बिटवाइज ऑपरेशन्स
जेव्हा ऋण पूर्णांकावर बिटवाइज ऑपरेशन केले जाते, तेव्हा मूल्य दोनच्या पूरक स्वरूपात व्यक्त केल्याप्रमाणे प्रक्रिया केली जाते.
लक्षात ठेवा, तथापि, जर तुम्ही bin() किंवा format() वापरून ऋण पूर्णांक बायनरी स्ट्रिंगमध्ये रूपांतरित केले तर, परिपूर्ण मूल्यामध्ये दोनच्या पूरक स्वरूपाऐवजी वजा चिन्ह असेल.
जर तुम्हाला दोनचे पूरक प्रतिनिधित्व असलेली स्ट्रिंग मिळवायची असेल, तर खाली दाखवल्याप्रमाणे AND घ्या.
- 4-बिट साठी
0b1111(=0xf) - 8-बिट साठी
0xff - 16-बिट साठी
0xffff
तुम्ही दोनच्या पूरक प्रतिनिधित्वाची स्ट्रिंग मिळवू शकता (प्रत्येक बिट उलटा केला आहे आणि 1 जोडला आहे).
x = -9 print(x) print(bin(x)) # -9 # -0b1001 print(bin(x & 0xff)) print(format(x & 0xffff, 'x')) # 0b11110111 # fff7
- संबंधित लेख:बायनरी, ऑक्टल आणि हेक्साडेसिमल संख्या आणि स्ट्रिंग्सना पायथनमध्ये एकमेकांमध्ये रूपांतरित करा
थोडा झटका:~ऑपरेटर
~ ऑपरेटरसह बिट फ्लिपिंगचे उदाहरण.
बिटवाइज इनव्हर्शन हे फक्त प्रत्येक बिटचे इन्व्हर्टेड मूल्य नाही. हा ऑपरेटर वापरताना परतावा मूल्य खालीलप्रमाणे आहे.~x#ERROR!-(x+1)
-(x+1)हे मूल्य इनपुट मूल्य x ला दोनचे पूरक फॉर्म म्हणून विचारात घेण्यासारखे आणि सर्व बिट्स उलटे करण्यासारखे आहे.
वर नमूद केल्याप्रमाणे, पायथनमध्ये, जेव्हा ऋण पूर्णांक bin(), format(), इ. वापरून बायनरी स्ट्रिंगमध्ये रूपांतरित केला जातो, तेव्हा ते दोनच्या पूरक स्वरूपात नसते, तर वजा चिन्हासह परिपूर्ण मूल्यात असते. म्हणून, ~x ला थेट स्ट्रिंगमध्ये रूपांतरित केल्याने मूळ मूल्याच्या बिट्ससह स्ट्रिंग उलटणार नाही.
x = 9 # 0b1001 print(~x) print(bin(~x)) # -10 # -0b1010
जेव्हा आपण AND ऑपरेशन करतो आणि त्यास दोनच्या पूरक प्रतिनिधित्वाच्या स्ट्रिंगमध्ये बदलतो, तेव्हा आपण पाहू शकतो की मूळ मूल्याचे बिट उलटे आहेत.
या व्यतिरिक्त, उदाहरणार्थ, 4-अंकी बिट स्ट्रिंग उलटे असलेली बिट स्ट्रिंग मिळविण्यासाठी (साइन बिट वगळलेले), खालीलप्रमाणे ANDed मूल्यासाठी शून्य भरण्यासाठी format() वापरा04b'
print(bin(~x & 0xff)) print(format(~x & 0b1111, '04b')) # 0b11110110 # 0110
थोडा शिफ्ट:<<,>>
बिट शिफ्ट ऑपरेटर वापरून डाव्या बिट शिफ्ट आणि उजव्या बिट शिफ्टची उदाहरणे.
x = 9 # 0b1001 print(x << 1) print(bin(x << 1)) # 18 # 0b10010 print(x >> 1) print(bin(x >> 1)) # 4 # 0b100
नकारात्मक मूल्यांसाठी, चिन्ह बिट विस्तारित आणि स्थलांतरित केले जाते आणि सकारात्मक/नकारात्मक चिन्ह समान राहते. नकारात्मक मूल्य म्हणजे डावीकडील 1s च्या ओळीची प्रतिमा.
x = -9 print(bin(x)) print(bin(x & 0xff)) # -0b1001 # 0b11110111 print(x << 1) print(bin(x << 1)) print(bin((x << 1) & 0xff)) # -18 # -0b10010 # 0b11101110 print(x >> 1) print(bin(x >> 1)) print(bin((x >> 1) & 0xff)) # -5 # -0b101 # 0b11111011
दोनच्या पूरक अभिव्यक्तींच्या तारांच्या संदर्भात विचार करणे चांगले आहे, कारण संख्यांच्या संदर्भात विचार करणे स्पष्ट नाही.
