python language एक पायथन int को बाइट्स की एक बड़ी-एंडियन स्ट्रिंग में कनवर्ट करें




python language pdf (7)

आप struct मॉड्यूल का उपयोग कर सकते हैं:

import struct
print struct.pack('>I', your_int)

'>I' एक प्रारूप स्ट्रिंग है। > अर्थ है बड़ा एंडियन और I मतलब है कि हस्ताक्षर किए गए int। अधिक प्रारूप वर्णों के लिए प्रलेखन की जांच करें।

मेरे पास एक गैर-नकारात्मक int है और मैं इसे एक ही डेटा युक्त एक बड़े-अंतराल स्ट्रिंग में कुशलतापूर्वक रूपांतरित करना चाहता हूं। उदाहरण के लिए, int 1245427 (जो 0x1300F3 है) परिणामस्वरूप लम्बाई 3 की एक स्ट्रिंग में परिणाम होना चाहिए जिसमें तीन वर्ण हैं जिनके बाइट मान 0x13, 0x00, और 0xf3 हैं।

मेरी चींटियां 35 (बेस -10) अंकों के पैमाने पर हैं।

मैं यह कैसे करु?


Answer #1

मुझे लगता है कि सबसे छोटा रास्ता निम्नलिखित है:

import struct
val = 0x11223344
val = struct.unpack("<I", struct.pack(">I", val))[0]
print "%08x" % val

यह एक बाइट-स्वैप पूर्णांक के लिए एक पूर्णांक को परिवर्तित करता है।


Answer #2

पायथन 3.2+ में, आप int.to_bytes उपयोग कर सकते हैं:

यदि आप आकार निर्दिष्ट नहीं करना चाहते हैं

>>> n = 1245427
>>> n.to_bytes((n.bit_length() + 7) // 8, 'big') or b'\0'
b'\x13\x00\xf3'

यदि आपको आकार निर्दिष्ट करने में कोई फर्क नहीं पड़ता है

>>> (1245427).to_bytes(3, byteorder='big')
b'\x13\x00\xf3'

Answer #3

यह तेज़ है और छोटे और (मनमाने ढंग से) बड़ी चींटियों के लिए काम करता है:

def Dump(n): 
  s = '%x' % n
  if len(s) & 1:
    s = '0' + s
  return s.decode('hex')
print repr(Dump(1245427))  #: '\x13\x00\xf3'

Answer #4

bitstring मॉड्यूल का उपयोग करना:

>>> bitstring.BitArray(uint=1245427, length=24).bytes
'\x13\x00\xf3'

ध्यान दें कि इस विधि के लिए आपको अपनी बनाई गई बिटस्ट्रिंग के बिट्स में लंबाई निर्दिष्ट करने की आवश्यकता है।

आंतरिक रूप से यह एलेक्स के उत्तर के समान ही है, लेकिन यदि आप अपने डेटा के साथ और अधिक करना चाहते हैं तो मॉड्यूल में बहुत अधिक कार्यक्षमता उपलब्ध है।


Answer #5

@pts 'उत्तर के आधार पर एकल-स्रोत पायथन 2/3 संगत संस्करण:

#!/usr/bin/env python
import binascii

def int2bytes(i):
    hex_string = '%x' % i
    n = len(hex_string)
    return binascii.unhexlify(hex_string.zfill(n + (n & 1)))

print(int2bytes(1245427))
# -> b'\x13\x00\xf3'

Answer #6

संभवतः अंतर्निहित struct माध्यम से सबसे अच्छा तरीका है:

>>> import struct
>>> x = 1245427
>>> struct.pack('>BH', x >> 16, x & 0xFFFF)
'\x13\x00\xf3'
>>> struct.pack('>L', x)[1:]  # could do it this way too
'\x13\x00\xf3'

वैकल्पिक रूप से - और मैं आमतौर पर इसकी अनुशंसा नहीं करता, क्योंकि यह गलती-प्रवण है - आप इसे "मैन्युअल" स्थानांतरित कर सकते हैं और chr() फ़ंक्शन:

>>> x = 1245427
>>> chr((x >> 16) & 0xFF) + chr((x >> 8) & 0xFF) + chr(x & 0xFF)
'\x13\x00\xf3'

जिज्ञासा से, आप केवल तीन बाइट क्यों चाहते हैं? आम तौर पर आप एक पूर्ण 32 बिट्स (एक सी unsigned long ) में इस तरह के एक पूर्णांक पैक करेंगे, और struct.pack('>L', 1245427) उपयोग करें struct.pack('>L', 1245427) लेकिन [1:] कदम छोड़ दें?







python