बिटवाइज ऑपरेशन और उपयोग

Question

इस कोड पर विचार करें:

x = 1        # 0001
x << 2       # Shift left 2 bits: 0100
# Result: 4

x | 2        # Bitwise OR: 0011
# Result: 3

x & 1        # Bitwise AND: 0001
# Result: 1

मैं पायथन (और अन्य भाषाओं) में अंकगणितीय ऑपरेटरों को समझ सकता हूं, लेकिन मैंने 'बिटवाइज़' ऑपरेटरों को कभी अच्छी तरह से नहीं समझा। उपरोक्त उदाहरण में (एक पायथन पुस्तक से), मैं बाएं-शिफ्ट को समझता हूं लेकिन अन्य दो को नहीं।

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

Comments

यह ब्याज की हो सकती है: stackoverflow.com/questions/276706/what-are-bitwise-operators

— 5

यह भी ब्याज की हो सकती है: stackoverflow.com/questions/8556206/what-does-mean-in-python

— फिलिप ओगर

Answer 1

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

• AND1 तो केवल तभी है जब इसके दोनों इनपुट 1 हैं, अन्यथा यह 0 है।
• OR1 है यदि एक या उसके दोनों इनपुट 1 हैं, अन्यथा यह 0 है।
• XOR1 केवल तभी है जब इसके इनपुटों में से एक ठीक 1 हो, अन्यथा यह 0 है।
• NOT केवल 1 है यदि इसका इनपुट 0 है, अन्यथा यह 0 है।

इन्हें अक्सर सत्य सारणी के रूप में दिखाया जा सकता है। इनपुट संभावनाएं शीर्ष और बाईं ओर हैं, परिणामी बिट चार में से एक है (दो के मामले में नहीं क्योंकि इसमें केवल एक इनपुट है) इनपुट के चौराहे पर दिखाए गए मान।

AND | 0 1     OR | 0 1     XOR | 0 1    NOT | 0 1
----+-----    ---+----     ----+----    ----+----
 0  | 0 0      0 | 0 1       0 | 0 1        | 1 0
 1  | 0 1      1 | 1 1       1 | 1 0

एक उदाहरण यह है कि यदि आप केवल एक पूर्णांक के निचले 4 बिट्स चाहते हैं, तो आप इसे 15 (बाइनरी 1111) के साथ:

    201: 1100 1001
AND  15: 0000 1111
------------------
 IS   9  0000 1001

उस मामले में 15 में शून्य बिट्स प्रभावी रूप से एक फिल्टर के रूप में कार्य करते हैं, परिणाम में बिट्स को शून्य होने के लिए मजबूर करते हैं।

इसके अलावा, >>और <<अक्सर बिटवाइज़ ऑपरेटरों के रूप में शामिल होते हैं, और वे एक निश्चित संख्या में बिट्स के क्रमशः दाएं और बाएं "मूल्य" को स्थानांतरित करते हैं, बिट्स को फेंकते हैं जो अंत में आप की ओर बढ़ रहे हैं और शून्य बिट में खिलाते हैं। दूसरा अंत।

इसलिए, उदाहरण के लिए:

1001 0101 >> 2 gives 0010 0101
1111 1111 << 4 gives 1111 0000

ध्यान दें कि पायथन में बाएं बदलाव असामान्य है कि यह एक निश्चित चौड़ाई का उपयोग नहीं कर रहा है जहां बिट्स को छोड़ दिया गया है - जबकि कई भाषाएं डेटा प्रकार के आधार पर एक निश्चित चौड़ाई का उपयोग करती हैं, पायथन केवल अतिरिक्त बिट्स को पूरा करने के लिए चौड़ाई का विस्तार करता है। पायथन में आपत्तिजनक व्यवहार को प्राप्त करने के लिए, आप एक बिटवाइज़ के साथ बाईं पारी का अनुसरण कर सकते हैं andजैसे कि 8-बिट वैल्यू शिफ्टिंग में चार बिट्स:

bits8 = (bits8 << 4) & 255

इसे ध्यान में रखते, बिटवाइज़ ऑपरेटर्स का एक और उदाहरण अगर आप दो 4 बिट मूल्यों है कि आप एक 8 बिट एक में पैक करने के लिए चाहते हैं, तो आप अपने ऑपरेटरों के सभी तीन उपयोग कर सकते हैं (है left-shift, andऔर or):

packed_val = ((val1 & 15) << 4) | (val2 & 15)

• & 15संचालन सुनिश्चित करें कि दोनों मूल्यों केवल कम 4 बिट्स है कर देगा।
• << 4एक 4 बिट पारी स्थानांतरित करने के लिए छोड़ दिया है val1शीर्ष में एक 8 बिट मूल्य का 4 बिट्स।
• |बस इन दोनों एक साथ जोड़ती है।

यदि val17 है और val24 है:

                val1            val2
                ====            ====
 & 15 (and)   xxxx-0111       xxxx-0100  & 15
 << 4 (left)  0111-0000           |
                  |               |
                  +-------+-------+
                          |
| (or)                0111-0100

Answer 2

एक विशिष्ट उपयोग:

| एक निश्चित बिट को 1 पर सेट करने के लिए उपयोग किया जाता है

& एक निश्चित बिट का परीक्षण या साफ़ करने के लिए उपयोग किया जाता है

• थोड़ा सेट करें (जहां n बिट संख्या है, और 0 सबसे कम महत्वपूर्ण बिट है):

  unsigned char a |= (1 << n);

• थोड़ा साफ़ करें:

  unsigned char b &= ~(1 << n);

• थोड़ा टॉगल करें:

  unsigned char c ^= (1 << n);

• थोड़ा परीक्षण करें:

  unsigned char e = d & (1 << n);

उदाहरण के लिए अपनी सूची का मामला लें:

x | 2के सेट बिट को 1 पर प्रयोग किया जाता है x1 करने के लिए

x & 1यह जांचने के लिए उपयोग किया जाता है कि बिट 0 का x1 या 0 है

Answer 3

बिटवाइज़ ऑपरेटर वास्तव में किसके लिए उपयोग किए जाते हैं? मैं कुछ उदाहरणों की सराहना करूंगा।

बिटवाइस संचालन का सबसे आम उपयोग हेक्साडेसिमल रंगों को पार्स करने के लिए है।

उदाहरण के लिए, यहां एक पायथन फ़ंक्शन है जो स्ट्रिंग को स्वीकार करता है #FF09BEऔर अपने लाल, हरे और नीले रंग के मूल्यों का एक टपल देता है।

def hexToRgb(value):
    # Convert string to hexadecimal number (base 16)
    num = (int(value.lstrip("#"), 16))

    # Shift 16 bits to the right, and then binary AND to obtain 8 bits representing red
    r = ((num >> 16) & 0xFF)

    # Shift 8 bits to the right, and then binary AND to obtain 8 bits representing green
    g = ((num >> 8) & 0xFF)

    # Simply binary AND to obtain 8 bits representing blue
    b = (num & 0xFF)
    return (r, g, b)

मुझे पता है कि इसे हासिल करने के लिए अधिक कुशल तरीके हैं, लेकिन मेरा मानना ​​है कि यह वास्तव में संक्षिप्त उदाहरण है जो दोनों पारियों और बिटवाइज़ बूलियन ऑपरेशनों को दर्शाता है।

Answer 4

मुझे लगता है कि प्रश्न का दूसरा भाग:

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

केवल आंशिक रूप से संबोधित किया गया है। उस मामले पर ये मेरे दो सेंट हैं।

प्रोग्रामिंग भाषाओं में बिटवाइज़ ऑपरेशन बहुत सारे अनुप्रयोगों के साथ काम करते समय एक मौलिक भूमिका निभाता है। लगभग सभी निम्न-स्तरीय कंप्यूटिंग इस तरह के संचालन का उपयोग करके किया जाना चाहिए।

सभी अनुप्रयोगों में जिन्हें दो नोड्स के बीच डेटा भेजने की आवश्यकता होती है, जैसे:

• कंप्यूटर नेटवर्क;

• दूरसंचार अनुप्रयोगों (सेलुलर फोन, उपग्रह संचार, आदि)।

संचार के निचले स्तर की परत में, डेटा आमतौर पर जिसे फ़्रेम कहा जाता है उसमें भेजा जाता है । फ़्रेम बस बाइट्स के तार हैं जो एक भौतिक चैनल के माध्यम से भेजे जाते हैं। इस फ़्रेम में आमतौर पर वास्तविक डेटा प्लस कुछ अन्य फ़ील्ड (बाइट्स में कोडित) होते हैं जो हेडर कहलाते हैं, का हिस्सा होते हैं । हेडर में आमतौर पर बाइट्स होते हैं जो संचार की स्थिति से संबंधित कुछ जानकारी को सांकेतिक शब्दों में बदलना (जैसे, झंडे (बिट्स)), फ्रेम काउंटर, सुधार और त्रुटि का पता लगाने के कोड, आदि। एक फ्रेम में संचरित डेटा प्राप्त करने के लिए, और निर्माण के लिए। फ़्रेम डेटा भेजने के लिए, आपको निश्चित बिटवाइज़ ऑपरेशनों की आवश्यकता होगी।

सामान्य तौर पर, इस तरह के अनुप्रयोगों से निपटने के दौरान, एक एपीआई उपलब्ध होता है ताकि आपको उन सभी विवरणों से निपटना न पड़े। उदाहरण के लिए, सभी आधुनिक प्रोग्रामिंग भाषाएं सॉकेट कनेक्शन के लिए लाइब्रेरी प्रदान करती हैं, इसलिए आपको वास्तव में टीसीपी / आईपी संचार फ्रेम बनाने की आवश्यकता नहीं है। लेकिन उन अच्छे लोगों के बारे में सोचें जिन्होंने आपके लिए उन एपीआई को प्रोग्राम किया था, उन्हें निश्चित रूप से फ्रेम निर्माण से निपटना था; निम्न-स्तर से उच्च-स्तर के संचार के लिए आगे और पीछे जाने के लिए सभी प्रकार के बिटवाइज़ संचालन का उपयोग करना।

एक ठोस उदाहरण के रूप में, कल्पना करें कि कोई आपको एक फ़ाइल देता है जिसमें कच्चा डेटा होता है जिसे सीधे दूरसंचार हार्डवेयर द्वारा कैप्चर किया गया था। इस मामले में, फ़्रेम को खोजने के लिए, आपको फ़ाइल में कच्ची बाइट्स को पढ़ना होगा और डेटा को थोड़ा-थोड़ा स्कैन करके किसी प्रकार के सिंक्रनाइज़ेशन शब्द खोजने की कोशिश करनी होगी। तुल्यकालन शब्द की पहचान करने के बाद, आप वास्तविक फ्रेम मिलता है, और करने की आवश्यकता होगी शिफ्ट (और है कि बस कहानी की शुरुआत है) वास्तविक डेटा है कि प्रेषित किया जा रहा प्राप्त करने के लिए यदि आवश्यक हो तो उन्हें।

आवेदन का एक और बहुत ही निम्न स्तर का परिवार है जब आपको कुछ (प्राचीन) बंदरगाहों, जैसे समानांतर और सीरियल पोर्ट का उपयोग करके हार्डवेयर को नियंत्रित करने की आवश्यकता होती है। इस पोर्ट को कुछ बाइट्स सेट करके नियंत्रित किया जाता है, और निर्देशों के संदर्भ में उस बाइट के प्रत्येक बिट का एक विशिष्ट अर्थ होता है, उस पोर्ट के लिए (उदाहरण के लिए देखें http://en.wikipedia.org/wiki/Parallel_port )। यदि आप ऐसे सॉफ़्टवेयर का निर्माण करना चाहते हैं जो उस हार्डवेयर के साथ कुछ करता है तो आपको उन निर्देशों का अनुवाद करने के लिए बिटवाइज़ संचालन की आवश्यकता होगी जिन्हें आप उस बाइट्स को निष्पादित करना चाहते हैं जिसे पोर्ट समझते हैं।

उदाहरण के लिए, यदि आपके पास कुछ अन्य डिवाइस को नियंत्रित करने के लिए समानांतर पोर्ट से जुड़े कुछ भौतिक बटन हैं, तो यह कोड की एक पंक्ति है जिसे आप सॉफ्ट एप्लिकेशन में पा सकते हैं:

read = ((read ^ 0x80) >> 4) & 0x0f; 

आशा है कि यह योगदान देगा।

Comments

मैं en.wikipedia.org/wiki/Bit_banging को एक अन्य एवेन्यू के रूप में जोड़ना चाहूंगा, खासकर अगर समानांतर और धारावाहिक बंदरगाहों के बारे में पढ़कर एक उदाहरण के रूप में जहां बिटवाइज़ ऑपरेशन उपयोगी हो सकते हैं।

— दान

Answer 5

मुझे आशा है कि यह उन दोनों को स्पष्ट करता है:

x | 2

0001 //x
0010 //2

0011 //result = 3

---

x & 1

0001 //x
0001 //1

0001 //result = 1

Comments

उफ़ ... पश्चिम में सबसे तेज़ बंदूक होने की कोशिश की .... एक बेवकूफ के रूप में समाप्त हो गया जो दो के लिए भी बाइनरी नहीं जानता है :( इसे ठीक किया।

— अमरघोष

x & 1प्रभाव के रूप में अच्छी तरह से वर्णन नहीं x & 2करेगा।

— डैनसाल्मो

Answer 6

० को असत्य और १ को सत्य मानें। तब बिटवाइज़ और (()) और (()) रेगुलर की तरह ही काम करते हैं और या इसके अलावा वे सभी बिट्स को एक ही बार में वैल्यू देते हैं। आमतौर पर आप उन्हें झंडे के लिए इस्तेमाल करते देखेंगे यदि आपके पास 30 विकल्प हैं जो सेट किए जा सकते हैं (जैसे कि एक विंडो पर स्टाइल्स के रूप में कहें) तो आप 30 अलग-अलग बूलियन मानों में पास होने या सेट करने के लिए हर एक का उपयोग नहीं करना चाहते हैं ताकि आप उपयोग करें। विकल्पों को एक एकल मूल्य में संयोजित करने के लिए और फिर आप उपयोग करते हैं और जांचते हैं कि क्या प्रत्येक विकल्प सेट है। फ्लैग पासिंग की इस शैली का इस्तेमाल ओपेन वील द्वारा किया जाता है। चूंकि प्रत्येक बिट एक अलग झंडा होता है, इसलिए आपको दो (उर्फ संख्याओं में केवल एक बिट सेट) की शक्तियों पर ध्वज मान मिलता है) 1 (2 ^ 0) 2 (2 ^ 1) 4 (2 ^ 2) 8 (2 ^ 3) दो की शक्ति आपको बताती है कि यदि ध्वज चालू है तो कौन सा बिट सेट है।

यह भी नोट करें 2 = 10 तो x 2 है 110 (6) नहीं 111 (7) यदि बिट्स ओवरलैप (जो इस मामले में सच है) में से कोई भी नहीं। इसके अलावा कार्य करता है।

Answer 7

मैंने इसे ऊपर उल्लेखित नहीं देखा था, लेकिन आप कुछ लोगों को अंकगणितीय कार्यों के लिए बाएँ और दाएँ बदलाव का उपयोग करते हुए भी देखेंगे। X द्वारा एक बायाँ शिफ्ट 2 ^ x से गुणा करने के बराबर है (जब तक कि यह ओवरफ्लो नहीं होता) और एक राइट शिफ्ट 2 ^ x से विभाजित होने के बराबर है।

हाल ही में मैंने लोगों को x << 1 और x >> 1 का उपयोग करते हुए दोहरीकरण और हलालिंग के लिए देखा है, हालांकि मुझे यकीन नहीं है कि अगर वे सिर्फ चालाक होने की कोशिश कर रहे हैं या अगर वास्तव में सामान्य ऑपरेटरों पर एक अलग फायदा है।

Comments

मैं अजगर के बारे में नहीं जानता, लेकिन निम्न स्तर की भाषाओं में जैसे C या उससे भी कम असेंबली, बिटवाइज़ शिफ्ट बहुत अधिक कुशल है। अंतर देखने के लिए, आप प्रत्येक तरीके से ऐसा करने वाले सी में एक प्रोग्राम लिख सकते हैं और बस असेंबली कोड के लिए संकलन कर सकते हैं (या यदि आप असेंबली लैंग जानते हैं, तो आप पहले से ही यह जानते होंगे :))। निर्देशों की संख्या में अंतर देखें।

— 0xc0de

बिट शिफ्ट ऑपरेटरों का उपयोग करने के खिलाफ मेरा तर्क यह होगा कि अधिकांश आधुनिक संकलक संभवतया पहले से ही अंकगणितीय संचालन का अनुकूलन कर रहे हैं, इसलिए होशियारी सबसे अच्छी लूट में है या संकलक से बुरी तरह से लड़ रही है। मुझे सी, कंपाइलर, या सीपीयू डिज़ाइनों में कोई विशेषज्ञता नहीं है और इसलिए मैं सही नहीं हूं। :)

— पी। स्टालवर्थ

यह अधिक होना चाहिए। मुझे कुछ कोड से निपटना पड़ा है जो बिटवाइज़ ऑपरेटर का ठीक उसी तरह से उपयोग कर रहे थे, और उस उत्तर ने मुझे चीजों का पता लगाने में मदद की।

— फिलिप ओगर

Answer 8

सेट

गणितीय कार्यों का उपयोग करके सेटों को जोड़ा जा सकता है।

• यूनियन ऑपरेटर |दो सेटों को मिलाकर एक नया आइटम बनाता है।
• चौराहा संचालक &को दोनों में ही सामान मिलता है।
• अंतर ऑपरेटर -को पहले सेट में आइटम मिलते हैं लेकिन दूसरे में नहीं।
• सममित अंतर ऑपरेटर ^को दोनों सेटों में आइटम मिलते हैं, लेकिन दोनों नहीं।

इसे स्वयं आज़माएं:

first = {1, 2, 3, 4, 5, 6}
second = {4, 5, 6, 7, 8, 9}

print(first | second)

print(first & second)

print(first - second)

print(second - first)

print(first ^ second)

परिणाम:

{1, 2, 3, 4, 5, 6, 7, 8, 9}

{4, 5, 6}

{1, 2, 3}

{8, 9, 7}

{1, 2, 3, 7, 8, 9}

Comments

यह उत्तर पूरी तरह से प्रश्न से असंबंधित है, और लगता है कि इसे कहीं और से कॉपी और पेस्ट किया गया है।

— डॉक्टफ्रेड 6

सवाल पूछता है "वास्तव में उपयोग किए जाने वाले बिटवाइज़ ऑपरेटर क्या हैं?"। यह उत्तर बिटकॉइन ऑपरेटरों के कम ज्ञात लेकिन बहुत उपयोगी उपयोग प्रदान करता है।

— तायंग तुंग

Answer 9

यह उदाहरण आपको सभी चार 2 बिट मानों के संचालन को दिखाएगा:

10 | 12

1010 #decimal 10
1100 #decimal 12

1110 #result = 14

---

10 & 12

1010 #decimal 10
1100 #decimal 12

1000 #result = 8

यहाँ उपयोग का एक उदाहरण है:

x = raw_input('Enter a number:')
print 'x is %s.' % ('even', 'odd')[x&1]

Answer 10

एक और आम उपयोग-मामला फ़ाइल अनुमतियों का परीक्षण / हेरफेर कर रहा है। : अजगर स्टेट मॉड्यूल देखें http://docs.python.org/library/stat.html ।

उदाहरण के लिए, फ़ाइल की अनुमतियों को वांछित अनुमति सेट से तुलना करने के लिए, आप कुछ ऐसा कर सकते हैं:

import os
import stat

#Get the actual mode of a file
mode = os.stat('file.txt').st_mode

#File should be a regular file, readable and writable by its owner
#Each permission value has a single 'on' bit.  Use bitwise or to combine 
#them.
desired_mode = stat.S_IFREG|stat.S_IRUSR|stat.S_IWUSR

#check for exact match:
mode == desired_mode
#check for at least one bit matching:
bool(mode & desired_mode)
#check for at least one bit 'on' in one, and not in the other:
bool(mode ^ desired_mode)
#check that all bits from desired_mode are set in mode, but I don't care about 
# other bits.
not bool((mode^desired_mode)&desired_mode)

मैंने परिणामों को बुलियन के रूप में रखा, क्योंकि मैं केवल सच्चाई या झूठ के बारे में परवाह करता हूं, लेकिन हर एक के लिए बिन () मूल्यों को प्रिंट करने के लिए एक सार्थक अभ्यास होगा।

Comments

आप अंतिम उदाहरण में गलत हैं। यहाँ यह कैसे दिखना चाहिए not bool((mode ^ desired_mode) & 0777):। या (समझने में आसान) not (mode & 0777) ^ desired_mode == 0:। और केवल दिलचस्प बिट्स को छोड़ देगा, XOR यह जांच करेगा कि सभी वांछित बिट सेट हैं या नहीं। स्पष्ट == 0तुलना की तुलना में अधिक सार्थक है bool()।

— वादिम फिन

मुझे नहीं लगता कि यह फ़ाइल संचालन के लिए विशिष्ट है। उदाहरण के लिए, PyQt में आप कुछ ऐसा ही करते हैं setWindowFlags। उदाहरण: setWindowFlags(SplashScreen | WindowStaysOnTopHint)। मुझे अभी भी यह भ्रामक लगता है, क्योंकि ऐसा लगता है कि आप एक 'टॉगल' पर 'सेट' कर रहे हैं, इसलिए यह इस तरह के मामले में 'और' अधिक सहज लगता है।

— एरिक

Answer 11

पूर्णांक की बिट अभ्यावेदन का उपयोग अक्सर वैज्ञानिक कंप्यूटिंग में सच्ची-झूठी सूचनाओं के सरणियों का प्रतिनिधित्व करने के लिए किया जाता है क्योंकि एक बिटवाइज़ ऑपरेशन बूलियन की एक सरणी के माध्यम से पुनरावृत्ति करने की तुलना में बहुत तेज़ है। (उच्च स्तर की भाषाएं थोड़ी सरणी के विचार का उपयोग कर सकती हैं।)

इसका एक अच्छा और काफी सरल उदाहरण निम के खेल का सामान्य समाधान है। पर एक नजर डालें अजगर पर कोड विकिपीडिया पृष्ठ । यह बिटवाइज़ एक्सक्लूसिव का भारी उपयोग करता है या ^।

Answer 12

वहाँ जहां एक सरणी तत्व दो मानों के बीच है खोजने के लिए एक बेहतर तरीका हो सकता है, लेकिन इस उदाहरण से पता चलता है के रूप में, और काम करता है यहाँ है, जबकि और नहीं करता है।

import numpy as np
a=np.array([1.2, 2.3, 3.4])
np.where((a>2) and (a<3))      
#Result: Value Error
np.where((a>2) & (a<3))
#Result: (array([1]),)

Answer 13

मैंने यह उल्लेख नहीं किया, यह उदाहरण आपको (-) 2 बिट मानों के लिए दशमलव ऑपरेशन दिखाएगा: AB (केवल यदि A में B है)

जब हम बिट्स का प्रतिनिधित्व करते हैं तो हमारे कार्यक्रम में एक क्रिया होती है, इस ऑपरेशन की आवश्यकता होती है। कभी-कभी हमें बिट्स जोड़ने की आवश्यकता होती है (ऊपर की तरह) और कभी-कभी हमें बिट्स को हटाने की आवश्यकता होती है (यदि क्रिया तब होती है)

111 #decimal 7
-
100 #decimal 4
--------------
011 #decimal 3

अजगर के साथ: 7 और ~ 4 = 3 (7 बिट से हटाएं जो 4 का प्रतिनिधित्व करते हैं)

001 #decimal 1
-
100 #decimal 4
--------------
001 #decimal 1

अजगर के साथ: 1 & ~ 4 = 1 (1 से बिट्स निकालें जो 4 का प्रतिनिधित्व करते हैं - इस मामले में 1 में '4' शामिल नहीं है) ।।

Answer 14

जब एक पूर्णांक के बिट्स में हेरफेर करना उपयोगी होता है, तो अक्सर नेटवर्क प्रोटोकॉल के लिए, जिसे बिट तक निर्दिष्ट किया जा सकता है, किसी को लंबे बाइट अनुक्रमों के हेरफेर की आवश्यकता हो सकती है (जो आसानी से एक पूर्णांक में परिवर्तित नहीं होते हैं)। इस मामले में यह बिटस्ट्रिंग लाइब्रेरी को नियोजित करने के लिए उपयोगी है जो डेटा पर बिटवाइज़ संचालन के लिए अनुमति देता है - जैसे कोई स्ट्रिंग 'ABCDEFGHIJKLMNOPQ' को एक स्ट्रिंग के रूप में या हेक्स के रूप में आयात कर सकता है और बिट इसे स्थानांतरित कर सकता है (या बिटवाइज़ संचालन कर सकता है):

>>> import bitstring
>>> bitstring.BitArray(bytes='ABCDEFGHIJKLMNOPQ') << 4
BitArray('0x142434445464748494a4b4c4d4e4f50510')
>>> bitstring.BitArray(hex='0x4142434445464748494a4b4c4d4e4f5051') << 4
BitArray('0x142434445464748494a4b4c4d4e4f50510')

Answer 15

निम्नलिखित बिटवाइज़ ऑपरेटर: & , | , ^ , और ~ रिटर्न वैल्यूज़ (उनके इनपुट के आधार पर) उसी तरह लॉजिक गेट्स सिग्नल को प्रभावित करते हैं। आप उन्हें सर्किट का अनुकरण करने के लिए उपयोग कर सकते हैं।

Answer 16

बिट्स फ्लिप करने के लिए (अर्थात 1 का पूरक / उल्टा) आप निम्नलिखित कार्य कर सकते हैं:

चूंकि सभी 1s के परिणाम के साथ Exored उलटा होता है, किसी दिए गए बिट चौड़ाई के लिए आप ExOR का उपयोग कर उन्हें उल्टा कर सकते हैं।

In Binary
a=1010 --> this is 0xA or decimal 10
then 
c = 1111 ^ a = 0101 --> this is 0xF or decimal 15
-----------------
In Python
a=10
b=15
c = a ^ b --> 0101
print(bin(c)) # gives '0b101'