दिलचस्प पोस्ट
आप पायथन में डेमॉन कैसे बनाते हैं? मैं एक बाइट सरणी को एक डबल और पीठ में कैसे रूपांतरित कर सकता / सकती हूं? अजीब एमएससी 8.0 त्रुटि: "ईएसपी का मान फ़ंक्शन कॉल में ठीक से नहीं बचा था …" लालची बनाम अनिच्छुक बनाम पारस्परिक क्वांटीफायर सी # अपनी कक्षा का नाम प्राप्त करना प्लस और माइनस साइंस क्या एक विधि के आगे उद्देश्य सी में क्या मतलब है? UIImagePickerController त्रुटि: एक दृश्य स्नैपशॉट जो आईओएस 7 में खाली स्नैपशॉट में परिणाम प्रदान नहीं किया गया है एक डाटाबेस में ब्लॉप्स के रूप में दस्तावेज़ संग्रह करना – कोई नुकसान? फॉर-लूप के साथ ArrayList से डेटा हटाएं Www के यूआरएल को एचटीएसीएक्स का उपयोग करने के लिए गैर-www की रीडायरेक्ट करने के लिए कैसे? एंड्रॉइड में "सॉकेट एक्सपैशन: पीयर द्वारा कनेक्शन रीसेट" करना Form_for, form_tag के बीच का अंतर? JQuery: DOM के बजाय 'मेमोरी' में HTML बनाएं आईओएस जुड़े प्रमाणीकरण एंड्रॉइड स्टूडियो ग्रेडल मुद्दे को संस्करण 0.5.0 में अपग्रेड कर रहा है – 0.8 से 0.9 तक स्थानांतरित करने वाले ग्रैडल – एंड्रॉइड स्टूडियो 0.8.1 में अपग्रेड

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

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

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 

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

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

Solutions Collecting From Web of "बिटवे ऑपरेशन और उपयोग"

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

  • AND 1 केवल अगर इसकी दोनों निविष्टियाँ 1 हैं, अन्यथा यह 0 है।
  • OR 1 अगर इसकी एक या दोनों सामग्री 1 है, अन्यथा यह 0 है
  • XOR केवल 1 है यदि इसकी एक इनपुट 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 और) का उपयोग कर सकते हैं:

 packed_val = ((val1 & 15) << 4) | (val2 & 15) 
  • & 15 ऑपरेशन यह सुनिश्चित करेगा कि दोनों मूल्यों में केवल 4 बिट्स के निचले हिस्से होंगे।
  • val1 1 को 8-बिट मान के शीर्ष 4 बिट में स्थानांतरित करने के लिए << 4 एक 4-बिट शिफ्ट बाईं ओर है
  • | बस इन दोनों को एक साथ जोड़ती है।

अगर val2 7 और val2 4 है:

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

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

| 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 x | 2 को 1 से 1 के बिट 1 सेट करने के लिए प्रयोग किया जाता है

x & 1 का परीक्षण करने के लिए प्रयोग किया जाता है यदि x 0 का x 0 या 1 है

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

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

उदाहरण के लिए, यहां एक पायथन फ़ंक्शन है जो #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) 

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

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

 x | 2 0001 //x 0010 //2 0011 //result = 3 

 x & 1 0001 //x 0001 //1 0001 //result = 1 

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

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

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

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

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

 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] 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

एक और सामान्य उपयोग-मामले में फाइल अनुमोदनों में हेर-फेर करना / परीक्षण करना है। पायथन स्टेट मॉड्यूल देखें: 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) 

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

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

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

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

 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]),) 

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

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

 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) ..

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

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