दिलचस्प पोस्ट
एक XML स्कीमा में पुनरावर्ती? MySQL में परिणाम सेट पर लूपिंग स्पार्क को नए संस्करण में अपग्रेड कैसे करें? srand फ़ंक्शन समान मूल्यों को वापस कर रहा है ग # छवि आकृति अनुपात को संरक्षित करते समय भिन्न आकार में बदलना बिट मास्किंग क्या है? संग्रहीत कार्यविधि – आउटपुट पैरामीटर या स्केलर के रूप में वापसी की पहचान जांचें कि इनपुट स्ट्रिंग में जावास्क्रिप्ट में कोई संख्या है या नहीं विशिष्ट नामित कनेक्शन या तो कॉन्फ़िगरेशन में नहीं मिला है, जिसका उपयोग एंटिटी क्लाइंट प्रदाता के साथ नहीं किया गया है, या मान्य नहीं है स्लाइडर से पहले और बाद में अलग-अलग रंग के लिए एचटीएमएल 5 रेंज इनपुट कैसे करें? PHP सरणी में डुप्लिकेट मान कैसे पता लगाएंगे? घटते क्रम में पूर्णांक सरणी को क्रमबद्ध करना Bitwise ऑपरेटर क्या हैं? प्रश्नकर्ता के प्रयोग से प्रत्यक्ष बच्चों को पुनः प्राप्त करने के लिए एंड्रॉइड में चिकना स्क्रॉलिंग

पायथन में फ्लोट का बाइनरी का प्रतिनिधित्व (बिट्स न हेक्स)

32 बिट फ्लोट के बाइनरी आईईईई 754 के रूप में स्ट्रिंग कैसे प्राप्त करें?

उदाहरण

1.00 -> '0011111110000000000000000000000000'

Solutions Collecting From Web of "पायथन में फ्लोट का बाइनरी का प्रतिनिधित्व (बिट्स न हेक्स)"

आप ऐसा कर सकते हैं कि struct पैकेज के साथ:

 import struct def binary(num): return ''.join(bin(ord(c)).replace('0b', '').rjust(8, '0') for c in struct.pack('!f', num)) 

यह एक नेटवर्क बाइट-ऑर्डर फ्लोट के रूप में पैक करता है, और फिर परिणामस्वरूप बाइट्स में से प्रत्येक को 8-बिट बाइनरी प्रस्तुति में कनवर्ट करता है और उनको एक साथ जोड़ता है:

 >>> binary(1) '00111111100000000000000000000000' 

संपादित करें : स्पष्टीकरण विस्तृत करने का एक अनुरोध था। मैं इसे प्रत्येक चरण पर टिप्पणी करने के लिए इंटरमीडिएट वैरिएबल्स का उपयोग करके विस्तारित करूंगा।

 def binary(num): # Struct can provide us with the float packed into bytes. The '!' ensures that # it's in network byte order (big-endian) and the 'f' says that it should be # packed as a float. Alternatively, for double-precision, you could use 'd'. packed = struct.pack('!f', num) print 'Packed: %s' % repr(packed) # For each character in the returned string, we'll turn it into its corresponding # integer code point # # [62, 163, 215, 10] = [ord(c) for c in '>\xa3\xd7\n'] integers = [ord(c) for c in packed] print 'Integers: %s' % integers # For each integer, we'll convert it to its binary representation. binaries = [bin(i) for i in integers] print 'Binaries: %s' % binaries # Now strip off the '0b' from each of these stripped_binaries = [s.replace('0b', '') for s in binaries] print 'Stripped: %s' % stripped_binaries # Pad each byte's binary representation's with 0's to make sure it has all 8 bits: # # ['00111110', '10100011', '11010111', '00001010'] padded = [s.rjust(8, '0') for s in stripped_binaries] print 'Padded: %s' % padded # At this point, we have each of the bytes for the network byte ordered float # in an array as binary strings. Now we just concatenate them to get the total # representation of the float: return ''.join(padded) 

और कुछ उदाहरणों के लिए परिणाम:

 >>> binary(1) Packed: '?\x80\x00\x00' Integers: [63, 128, 0, 0] Binaries: ['0b111111', '0b10000000', '0b0', '0b0'] Stripped: ['111111', '10000000', '0', '0'] Padded: ['00111111', '10000000', '00000000', '00000000'] '00111111100000000000000000000000' >>> binary(0.32) Packed: '>\xa3\xd7\n' Integers: [62, 163, 215, 10] Binaries: ['0b111110', '0b10100011', '0b11010111', '0b1010'] Stripped: ['111110', '10100011', '11010111', '1010'] Padded: ['00111110', '10100011', '11010111', '00001010'] '00111110101000111101011100001010' 

यहाँ एक बदसूरत एक है …

 >>> import struct >>> bin(struct.unpack('!i',struct.pack('!f',1.0))[0]) '0b111111100000000000000000000000' 

असल में, मैं सिर्फ संरचना मॉड्यूल का उपयोग फ्लोट को एक पूर्णांक में परिवर्तित करने के लिए करता था …


ctypes का उपयोग करते हुए यहां थोड़ा बेहतर है:

 >>> import ctypes >>> bin(ctypes.c_uint.from_buffer(ctypes.c_float(1.0)).value) '0b111111100000000000000000000000' 

असल में, मैं एक float निर्माण करता हूं और उसी स्मृति स्थान का उपयोग करता हूं, लेकिन मैं इसे c_uint रूप में टैग करता c_uintc_uint का मान एक पायथन पूर्णांक है, जिस पर आप c_uint bin फ़ंक्शन का उपयोग कर सकते हैं।

बीट्सस्ट्रिंग मॉड्यूल का उपयोग करके एक अन्य समाधान मिला।

 import bitstring f1 = bitstring.BitArray(float=1.0, length=32) print f1.read('bin') 

आउटपुट:

 00111111100000000000000000000000 

इस समस्या को दो हिस्सों में इसे तोड़कर इसे और अधिक सफाई से संभाला जाता है

पहले फ्लोट को बराबर बिट पैटर्न के साथ एक इंट में कनवर्ट करना है:

 def float32_bit_pattern(value): return sum(ord(b) << 8*i for i,b in enumerate(struct.pack('f', value))) 

आगे एक स्ट्रिंग में int परिवर्तित करें:

 def int_to_binary(value, bits): return bin(value).replace('0b', '').rjust(bits, '0') 

अब उन्हें संयोजित करें:

 >>> int_to_binary(float32_bit_pattern(1.0), 32) '00111111100000000000000000000000' 

पूर्णता की खातिर, आप यह प्रयोग करके numpy के साथ प्राप्त कर सकते हैं:

 f = 1.00 int32bits = np.asarray(f, dtype=np.float32).view(np.int32).item() # item() optional 

आप b प्रारूप विनिर्देशक का उपयोग करके पैडिंग के साथ इसे प्रिंट कर सकते हैं

 print('{:032b}'.format(int32bits)) 

बहुत सारे समान प्रश्नों के माध्यम से ब्राउज़ करने के बाद मैंने कुछ लिखा है जो उम्मीद करता है कि मैं क्या चाहता था।

 f = 1.00 negative = False if f < 0: f = f*-1 negative = True s = struct.pack('>f', f) p = struct.unpack('>l', s)[0] hex_data = hex(p) scale = 16 num_of_bits = 32 binrep = bin(int(hex_data, scale))[2:].zfill(num_of_bits) if negative: binrep = '1' + binrep[1:] 

binrep परिणाम है प्रत्येक भाग समझाया जाएगा।


 f = 1.00 negative = False if f < 0: f = f*-1 negative = True 

संख्या को सकारात्मक में ऋणात्मक रूपांतरित कर देता है, और नकारात्मक को गलत पर सेट करता है। इसका कारण यह है कि सकारात्मक और नकारात्मक द्विआधारी प्रतिनिधित्व के बीच अंतर बस पहले बिट में है, और नकारात्मक संख्याओं की पूरी प्रक्रिया करते समय यह पता चलता है कि गलत क्या होता है यह आसान तरीका था।


 s = struct.pack('>f', f) #'?\x80\x00\x00' p = struct.unpack('>l', s)[0] #1065353216 hex_data = hex(p) #'0x3f800000' 

s बाइनरी f की एक हेक्स प्रतिनिधित्व है हालांकि यह सुंदर रूप में मुझे ज़रूरत नहीं है वह चीजें जहां पी अंदर आती है। यह हेक्स एस का पूर्णांक है। और फिर एक खूबसूरत हेक्स पाने के लिए एक और रूपांतरण


 scale = 16 num_of_bits = 32 binrep = bin(int(hex_data, scale))[2:].zfill(num_of_bits) if negative: binrep = '1' + binrep[1:] 

scale हेक्स के लिए आधार 16 है। num_of_bits 32 है, जैसा कि फ्लोट 32 बिट है, इसका उपयोग बाद में 0 के साथ अतिरिक्त स्थानों को भरने के लिए किया जाता है। इस प्रश्न से binrep के लिए कोड मिलता है। यदि संख्या नकारात्मक थी, तो बस पहले बिट को बदल दें।


मुझे पता है कि यह बदसूरत है, लेकिन मुझे एक अच्छा रास्ता नहीं मिला और मुझे इसकी आवश्यकता तेजी से थी। टिप्पणियाँ स्वागत है

आप मेरी राय में बिट्स के सबसे आसान प्रतिनिधित्व के लिए प्रारूप का उपयोग कर सकते हैं:

मेरा कोड कुछ ऐसा दिखेगा:

 def fto32b(flt): # is given a 32 bit float value and converts it to a binary string if isinstance(flt,float): # THE FOLLOWING IS AN EXPANDED REPRESENTATION OF THE ONE LINE RETURN # packed = struct.pack('!f',flt) <- get the hex representation in (!)Big Endian format of a (f) Float # integers = [] # for c in packed: # integers.append(ord(c)) <- change each entry into an int # binaries = [] # for i in integers: # binaries.append("{0:08b}".format(i)) <- get the 8bit binary representation of each int (00100101) # binarystring = ''.join(binaries) <- join all the bytes together # return binarystring return ''.join(["{0:08b}".format(i) for i in [ord(c) for c in struct.pack('!f',flt)]]) return None 

आउटपुट:

 >>> a = 5.0 '01000000101000000000000000000000' >>> b = 1.0 '00111111100000000000000000000000' 

इन उत्तर में से कई पायथन 3 के साथ लिखे गए कार्य के रूप में काम नहीं किया, या नकारात्मक फ्लोटिंग पॉइंट नंबरों के लिए सही प्रतिनिधित्व नहीं दिया। मुझे मेरे लिए काम करने के लिए निम्न पाया गया (हालांकि यह 64-बिट प्रतिनिधित्व देता है जो कि मुझे क्या चाहिए)

 def float_to_binary_string(f): def int_to_8bit_binary_string(n): stg=bin(n).replace('0b','') fillstg = '0'*(8-len(stg)) return fillstg+stg return ''.join( int_to_8bit_binary_string(int(b)) for b in struct.pack('>d',f) ) 

यह थोड़ा अधिक पूछा गया था, लेकिन जब मुझे यह प्रविष्टि मिली तो मुझे क्या चाहिए था यह कोड आईएनईई 754 32 बिट फ्लोट का मंटिसा, बेस और साइन देगा।

 import ctypes def binRep(num): binNum = bin(ctypes.c_uint.from_buffer(ctypes.c_float(num)).value)[2:] print("bits: " + binNum.rjust(32,"0")) mantissa = "1" + binNum[-23:] print("sig (bin): " + mantissa.rjust(24)) mantInt = int(mantissa,2)/2**23 print("sig (float): " + str(mantInt)) base = int(binNum[-31:-23],2)-127 print("base:" + str(base)) sign = 1-2*("1"==binNum[-32:-31].rjust(1,"0")) print("sign:" + str(sign)) print("recreate:" + str(sign*mantInt*(2**base))) binRep(-0.75) 

उत्पादन:

 bits: 10111111010000000000000000000000 sig (bin): 110000000000000000000000 sig (float): 1.5 base:-1 sign:-1 recreate:-0.75