लंबे हेक्स स्ट्रिंग से अजगर बाइट्स ऑब्जेक्ट कैसे बनाएं?


91

मेरे पास एक स्ट्रिंग में हेक्स अंकों का एक लंबा अनुक्रम है, जैसे कि

000000000000484240FA063DE5D0B744ADBED63A81FAEA390000C8428640A43D5005BD44

केवल लंबे समय तक, कई किलोबाइट। अजगर 2.6 / 3 में इसे बाइट्स ऑब्जेक्ट में बदलने का एक अंतर्निहित तरीका है?


4
ध्यान दें कि नीचे दिए गए उत्तर एक जैसे दिख सकते हैं लेकिन वे विभिन्न प्रकार के मान लौटाते हैं। s.decode ('hex') एक str देता है, जैसा कि unhexlify (s) करता है। bytearray.fromhex (s) एक ब्योरा देता है। इस प्रश्न के शब्दों को देखते हुए, मुझे लगता है कि बड़ा हरे रंग का चेकमार्क bytearray.fromhex (s) पर होना चाहिए, s.decode ('हेक्स') पर नहीं।
पॉल हॉफमैन


2
2 साल बाद बनाए गए प्रश्न का डुप्लिकेट कैसे हो सकता है?
पुनरावर्ती

1
@CiroSantilli 郝海东 冠状 ill ill 法轮功 string एक बाइट स्ट्रिंग एक बाइट सरणी नहीं है। stackoverflow.com/questions/1740696/…
11

@ लार्स फेयर काफी। @ पुनरावर्ती: तिथि मुख्य कारक नहीं है: meta.stackexchange.com/questions/147643/…
Ciro Santilli 郝海东 date date 六四 法轮功

जवाबों:


96

अजगर 2.7 और उच्च पायथन 3 सहित में काम करता है:

result = bytearray.fromhex('deadbeef')

नोट: लगता है कि bytearray.fromhex()पायथन 2.6 में फ़ंक्शन के साथ एक बग है । Python.org प्रलेखन बताता है कि फ़ंक्शन एक स्ट्रिंग को एक तर्क के रूप में स्वीकार करता है, लेकिन जब लागू किया जाता है, तो निम्न त्रुटि दी जाती है:

>>> bytearray.fromhex('B9 01EF')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: fromhex() argument 1 must be unicode, not str`

9
और एक अतिरिक्त कदम, मैं एक बाइट स्ट्रिंग चाहता था (जैसे कि पायथन 3 के बी '\ x04 \ xea [...]'), जिसे आप bytes(bytearray.fromhex('deadbeef'))
बायटियर

5
@berto: उस मामले में के रूप में एक अधिक सीधा मार्ग है binascii.unhexlify()
मार्टिन पीटर्स

1
धन्यवाद, @MartijnPieters, मैं देता हूँ कि एक शॉट
'12

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

2
@ लार्स: यह विधि पुराने पाइथन 2 रिलीज में उपलब्ध नहीं है। यही कारण है कि किसी भी अधिक आज कोई फर्क नहीं पड़ता है, लेकिन यह 2016 में एक मुद्दा था
मार्टिन पीटर्स

74
result = bytes.fromhex(some_hex_string)

2
यह ऐसा करने का सबसे सीधा तरीका लगता है जो मूल पोस्ट पूछ रहा है। क्या कोई कारण है कि यह स्वीकृत उत्तर नहीं है?
सेबेस्टियन गावेडा

जब हेक्स संख्या रिक्त स्थान से अलग हो जाती है, तो हेक्स () बाइट्स और बायटेरियर दोनों की विधि भी काम करेगी। बहुत ही सुविधाजनक!
क्लॉस

1
यह वास्तव में स्वीकृत उत्तर होना चाहिए। वर्तमान स्वीकृत उत्तर वह नहीं करता है जो प्रश्न पूछा गया था। यह बाइट्स का एक परिवर्तनशील सरणी देता है, न कि बाइटस्ट्रिंग।
माइक मार्टिन

40

आप हेक्स कोडेक के साथ ऐसा कर सकते हैं। अर्थात:

>>> s='000000000000484240FA063DE5D0B744ADBED63A81FAEA390000C8428640A43D5005BD44'
>>> s.decode('hex')
'\x00\x00\x00\x00\x00\x00HB@\xfa\x06=\xe5\xd0\xb7D\xad\xbe\xd6:\x81\xfa\xea9\x00\x00\xc8B\x86@\xa4=P\x05\xbdD'

16
codecs.decode('0a0a0a', 'hex_codec')2.x और 3.x :-) के लिए काम करना चाहिए
अब्बाफी

37

Binascii मॉड्यूल आज़माएं

from binascii import unhexlify
b = unhexlify(myhexstr)

9
2.x में इसे करने के दो तरीके, 3.x में तीन तरीके। "इतना करने का केवल एक ही तरीका है" के लिए इतना ...
टेक्नोलाॅजिकल

अन्य दो तरीके अधिक 'बिल्ट-इन' हैं, इसलिए मैं वास्तव में उनमें से एक का उपयोग करूंगा।
क्रिसेंट फ्रेश

@technomalogical: आपकी टिप्पणी उत्तर के लिए अप्रासंगिक है; शायद आपको इसे हटा देना चाहिए और इसे एक पोस्ट में बदलकर comp.lang.python करना चाहिए।
तजोट

1
@technomalogical: मैं ical से सहमत हूं। साथ ही, आपको यह गलत लगा। सही वाक्यांश है: एक होना चाहिए - और अधिमानतः केवल एक - स्पष्ट तरीका यह करने के लिए।
nosklo

2
ध्यान दें कि पायथन 3.2 (डिज़ाइन या बग मैं निश्चित नहीं हूं) unhexlifyअब एक स्ट्रिंग को स्वीकार नहीं करेगा, लेकिन केवल बाइट्स। बहुत मूर्खतापूर्ण वास्तव में, लेकिन इसका मतलब है कि आपको उपयोग करने की आवश्यकता होगीb = unhexlify(bytes(myhexstr, 'utf-8'))
स्कॉट ग्रिफ़िथ

2
import binascii

binascii.a2b_hex(hex_string)

जिस तरह से मैंने यह किया था।


हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.