h = '00112233aabbccddee'
जैसी एक स्ट्रिंग में एक हेक्स मान मैं मैं के साथ द्विआधारी को यह परिवर्तित कर सकते हैं पता है खोने के बिना बाइनरी में हेक्स से परिवर्तित:
h = bin(int(h, 16))[2:]
बहरहाल, यह खो देता है अग्रणी 0 है। 0 के खोए बिना इस रूपांतरण को करने के लिए वैसे भी है? या रूपांतरण से पहले अग्रणी 0 की संख्या की गणना करने के लिए इसे करने का सबसे अच्छा तरीका है और बाद में इसे जोड़ें।
मुझे नहीं लगता कि डिफ़ॉल्ट रूप से उन प्रमुख शून्यों को रखने का कोई तरीका है।
प्रत्येक हेक्स अंक 4 बाइनरी अंकों में अनुवाद करता है, इसलिए नई स्ट्रिंग की लंबाई मूल के आकार के ठीक 4 गुणा होनी चाहिए।
h_size = len(h) * 4
उसके बाद, आप .zfill उपयोग कर सकते हैं शून्य में आकार आप चाहते करने के लिए भरने के लिए: प्रत्येक hexdigit
''.join(bin(int(c, 16))[2:].zfill(4) for c in h)
मुझे लगता है कि यह मुझे कुछ कारणों से 3 अतिरिक्त 0 का देता है – root
आह कभी भी यह पूरी तरह से काम नहीं करता है। मैं पहले गैर शून्य हेक्स संख्या से पहले 0 की गणना नहीं कर रहा था। धन्यवाद। – root
@root: असंबंधित: विभिन्न चीज़ों के लिए 'h' नाम का पुन: उपयोग न करें उदाहरण के लिए, 'बिट्स' नाम का उपयोग करें:' बिट्स = बिन (int (h, 16)) [2:]। Zfill (len (h) * 4) ' – jfs
मूल रूप से एक ही लेकिन गद्दी पायथन जैसे कि मैं
datastring = 'HexInFormOfString'
पाइडर स्ट्रिंग को हेक्स में परिवर्तित करते समय पूर्ववर्ती शून्यों को समायोजित करने के लिए पैडिंग।
datastrPadded = 'ffff' + datastring
पैड किए गए मान को बाइनरी में कनवर्ट करें।
databin = bin(int(datastrPadded,16))
निकालें 2bits ('0b') कि अजगर द्विआधारी + 16 गद्देदार बिट्स निरूपित करने के लिए कहते हैं।
databinCrop = databin[18:]
एक नौसिखिया के लिए 4 bindigits को
h = (bin(int(h, 16))[2:]).zfill(h_size)
यह एक हेक्स स्ट्रिंग को बाइनरी स्ट्रिंग में परिवर्तित करता है। चूंकि आप लंबाई को मूल पर निर्भर करना चाहते हैं, यह वही हो सकता है जो आप चाहते हैं।
data = ""
while len(h) > 0:
data = data + chr(int(h[0:2], 16))
h = h[2:]
print h
यह वास्तव में पायथन में काफी आसान है, क्योंकि इसमें पूर्णांक के आकार पर कोई सीमा नहीं है। बस हेक्स स्ट्रिंग में '1' प्रीपेड करें, और आउटपुट से संबंधित '1' को पट्टी करें।
>>> h = '00112233aabbccddee'
>>> bin(int(h, 16))[2:] # old way
'1000100100010001100111010101010111011110011001101110111101110'
>>> bin(int('1'+h, 16))[3:] # new way
'000000000001000100100010001100111010101010111011110011001101110111101110'
वास्तव में एक घंटे के लिए यह देख रहे थे! –
hexa = '91278c4bfb3cbb95ffddc668d995bfe0'
binary = bin(int(hexa, 16))[2:]
print binary
hexa_dec = hex(int(binary, 2))[2:]
print hexa_dec
कोई विशेष कारण है कि आप की जरूरत है '0' की है? –
मैं बाद में एक शब्दकोश के लिए एक कुंजी के रूप में मूल्य एच का उपयोग कर रहा हूँ। हालांकि कुंजी में सभी प्रमुख 0 हैं। – root
क्या कोई अनिवार्य कारण है कि आप कुंजीपटल कुंजी के पूर्णांक के बजाय मान के बाइनरी स्ट्रिंग प्रस्तुति का उपयोग कर रहे हैं? –