दिलचस्प पोस्ट
कैनेटलेशन टोकन की संपत्ति का उपयोग कैसे करें? जब मैं एक ड्रैग-योग्य क्लोन करता हूं और इसे ड्रॉपपॉबल में छोड़ देता हूं तो मैं इसे फिर से नहीं खींच सकता एक अंगुलर जेएस सेवा में एक नकली इंजेक्शन संग्रह कैसे करता है। एंड्रॉइड – फोन अनलॉक ईवेंट का पता लगाएं, स्क्रीन पर नहीं संयोजित डमैन XY प्लॉट डोमेन अक्ष को पुन: नहीं करना क्या एक सूची बनाम एक ArrayList? एसबीटी कमांड के अंदर सेटिंग कैसे बदल सकती है? क्या डीमन के लिए PHP का उपयोग करना बुद्धिमान है? जर्सी के साथ जेएक्स-आरएस का उपयोग कर कॉरस को कैसे संभालना है क्या पॉडकास्ट नियंत्रण दिखाने के लिए MPNowPlayingInfoCenter को मजबूर करने का कोई सार्वजनिक तरीका है? Asp.Net MVC 4 में HttpPostedFileBase विशेषता का फ़ाइल प्रकार कैसे मान्य करें? मैं HTTP पर एक बाइनरी फ़ाइल कैसे डाउनलोड करूं? इन इनलाइन-ब्लॉक वाले तत्वों के बीच में एक अविवेकीय अंतर क्यों है? एंड्रॉइड के लिए चौड़ाई और ऊंचाई कैसे प्राप्त करें I

बाइट्स की एक स्ट्रिंग को एक int (अजगर) में परिवर्तित करें

मैं अजगर में एक स्ट्रिंग को कैसे अजगर में परिवर्तित कर सकता / सकती हूं?

इस तरह से कहें: 'y\xcc\xa6\xbb'

मैं यह करने के एक चालाक / बेवकूफ तरीके से आया था:

 sum(ord(c) << (i * 8) for i, c in enumerate('y\xcc\xa6\xbb'[::-1])) 

मुझे पता है कि कुछ अंतर्निर्मित या मानक लाइब्रेरी में होना चाहिए जो यह अधिक आसानी से करता है …

यह हेक्स अंकों की स्ट्रिंग को परिवर्तित करने से अलग है, जिसके लिए आप int (xxx, 16) का उपयोग कर सकते हैं, लेकिन इसके बजाय मैं वास्तविक बाइट मानों की एक स्ट्रिंग परिवर्तित करना चाहता हूं।

अद्यतन करें:

मैं जेम्स की तरह थोड़े बेहतर जवाब देता हूं क्योंकि इससे दूसरे मॉड्यूल को आयात करने की आवश्यकता नहीं होती है, लेकिन ग्रेग की विधि तेज है:

 >>> from timeit import Timer >>> Timer('struct.unpack("<L", "y\xcc\xa6\xbb")[0]', 'import struct').timeit() 0.36242198944091797 >>> Timer("int('y\xcc\xa6\xbb'.encode('hex'), 16)").timeit() 1.1432669162750244 

मेरी हैकी विधि:

 >>> Timer("sum(ord(c) << (i * 8) for i, c in enumerate('y\xcc\xa6\xbb'[::-1]))").timeit() 2.8819329738616943 

आगे अद्यतन:

किसी ने किसी अन्य मॉड्यूल को आयात करने में समस्या क्या है, टिप्पणी में पूछा अच्छा, एक मॉड्यूल आयात करना सस्ता नहीं है, एक नज़र रखना:

 >>> Timer("""import struct\nstruct.unpack(">L", "y\xcc\xa6\xbb")[0]""").timeit() 0.98822188377380371 

मॉड्यूल को आयात करने की लागत सहित लगभग सभी लाभों को नकारता है जो इस पद्धति में है। मेरा विश्वास है कि इसमें केवल एक बार पूरे बेंचमार्क रन के लिए आयात करने की कीमत शामिल होगी; देखो क्या होता है जब मैं इसे हर बार पुनः लोड करने के लिए बाध्य करता हूं:

 >>> Timer("""reload(struct)\nstruct.unpack(">L", "y\xcc\xa6\xbb")[0]""", 'import struct').timeit() 68.474128007888794 

कहने की ज़रूरत नहीं है कि अगर आप इस पद्धति की एक बहुत कुछ कर रहे हैं, तो यह एक आयात की तुलना में कम हो जाता है। यह सीपीयू के बजाय शायद आई / ओ लागत है, इसलिए यह विशेष मशीन की क्षमता और लोड विशेषताओं पर निर्भर हो सकती है।

Solutions Collecting From Web of "बाइट्स की एक स्ट्रिंग को एक int (अजगर) में परिवर्तित करें"

आप ऐसा करने के लिए संरचना मॉड्यूल का उपयोग भी कर सकते हैं:

 >>> struct.unpack("<L", "y\xcc\xa6\xbb")[0] 3148270713L 

पायथन 3.2 और बाद में, उपयोग करें

 >>> int.from_bytes(b'y\xcc\xa6\xbb', byteorder='big') 2043455163 

या

 >>> int.from_bytes(b'y\xcc\xa6\xbb', byteorder='little') 3148270713 

अपने बाइट-स्ट्रिंग की अंत्यता के अनुसार

यह मनमाना लंबाई के बायटेस्टिंग-इंटिजर्स के लिए भी काम करता है, और हस्ताक्षर signed=True को निर्दिष्ट करके दो पूर्ण पूरक पूर्णांक के लिए from_bytes लिए दस्तावेज़ देखें

जैसा कि ग्रेग ने कहा, यदि आप द्विआधारी मान से निपटते हैं, तो आप संरचना का उपयोग कर सकते हैं, लेकिन अगर आपके पास "हेक्स नंबर" है लेकिन बाइट प्रारूप में आप इसे बस इसे परिवर्तित करना चाहते हैं:

 s = 'y\xcc\xa6\xbb' num = int(s.encode('hex'), 16) 

… यह वही है:

 num = struct.unpack(">L", s)[0] 

… सिवाय इसके कि यह किसी भी संख्या में बाइट्स के लिए काम करेगी।

मैं int, hex और बाइट्स के बीच डेटा कनवर्ट करने के लिए निम्न फ़ंक्शन का उपयोग करता हूं।

 def bytes2int(str): return int(str.encode('hex'), 16) def bytes2hex(str): return '0x'+str.encode('hex') def int2bytes(i): h = int2hex(i) return hex2bytes(h) def int2hex(i): return hex(i) def hex2int(h): if len(h) > 1 and h[0:2] == '0x': h = h[2:] if len(h) % 2: h = "0" + h return int(h, 16) def hex2bytes(h): if len(h) > 1 and h[0:2] == '0x': h = h[2:] if len(h) % 2: h = "0" + h return h.decode('hex') 

स्रोत: http://opentechnotes.blogspot.com.au/2014/04/convert-values-to-from-integer-hex.html

 import array integerValue = array.array("I", 'y\xcc\xa6\xbb')[0] 

चेतावनी: ऊपर जोरदार प्लेटफ़ॉर्म-विशिष्ट है। "I" स्पेसिफ़ायर और स्ट्रिंग-> इंट रूपांतरण की समाप्ति दोनों आपके विशेष पायथन कार्यान्वयन पर निर्भर हैं। लेकिन अगर आप एक बार में कई पूर्णांक / तार कन्वर्ट करना चाहते हैं, तो सरणी मॉड्यूल इसे जल्दी से करता है

पायथन 2.x में, आप प्रारूप विनिर्देशक <B , अहस्ताक्षरित बाइट के लिए, और <b लिए struct.unpack / struct.pack साथ हस्ताक्षरित बाइट्स का उपयोग कर सकते हैं।

उदाहरण के लिए:

चलिए x = '\xff\x10\x11'

data_ints = struct.unpack('<' + 'B'*len(x), x) # [255, 16, 17]

तथा:

data_bytes = struct.pack('<' + 'B'*len(data_ints), *data_ints) # '\xff\x10\x11'
वह * आवश्यक है!

प्रारूप विनिर्देशकों की सूची के लिए https://docs.python.org/2/library/struct.html#format-characters देखें

यदि आप संस्करण> = 3.2 पर हैं तो int.from_bytes सबसे अच्छा समाधान है। "Struct.unpack" समाधान के लिए स्ट्रिंग की आवश्यकता होती है, इसलिए यह बाइट्स के एरे पर लागू नहीं होगी। यहां एक और समाधान है:

 def bytes2int( tb, order='big'): if order == 'big': seq=[0,1,2,3] elif order == 'little': seq=[3,2,1,0] i = 0 for j in seq: i = (i<<8)+tb[j] return i 

हेक्स (बाइट्सिंंट ([0x87, 0x65, 0x43, 0x21])) '0x87654321' देता है

यह बड़े और छोटे अंत्यापन को संभालता है और 8 बाइट्स के लिए आसानी से बदलने योग्य है

 >>> reduce(lambda s, x: s*256 + x, bytearray("y\xcc\xa6\xbb")) 2043455163 

टेस्ट 1: उलटा:

 >>> hex(2043455163) '0x79cca6bb' 

टेस्ट 2: बाइट्स की संख्या> 8:

 >>> reduce(lambda s, x: s*256 + x, bytearray("AAAAAAAAAAAAAAA")) 338822822454978555838225329091068225L 

टेस्ट 3: एक से वृद्धि:

 >>> reduce(lambda s, x: s*256 + x, bytearray("AAAAAAAAAAAAAAB")) 338822822454978555838225329091068226L 

टेस्ट 4: एक बाइट संलग्न करें, 'ए' कहें:

 >>> reduce(lambda s, x: s*256 + x, bytearray("AAAAAAAAAAAAAABA")) 86738642548474510294585684247313465921L 

टेस्ट 5: 256 से विभाजित करें:

 >>> reduce(lambda s, x: s*256 + x, bytearray("AAAAAAAAAAAAAABA"))/256 338822822454978555838225329091068226L 

परिणाम 4 के रूप में अपेक्षित के परिणाम के बराबर है

मैं मनमाना लंबाई बाइट अनुक्रमों के लिए एक समाधान खोजने के लिए संघर्ष कर रहा था जो कि पायथन 2.x के तहत काम करेगा। अंत में मैंने यह लिखा था, यह थोड़ा हैकी है क्योंकि यह एक स्ट्रिंग रूपांतरण करता है, लेकिन यह काम करता है।

पायथन 2.x के लिए फ़ंक्शन, मनमाना लंबाई

 def signedbytes(data): """Convert a bytearray into an integer, considering the first bit as sign. The data must be big-endian.""" negative = data[0] & 0x80 > 0 if negative: inverted = bytearray(~d % 256 for d in data) return -signedbytes(inverted) - 1 encoded = str(data).encode('hex') return int(encoded, 16) 

इस समारोह में दो आवश्यकताएं हैं:

  • इनपुट data को bytearray होना चाहिए। आप इस तरह से समारोह कॉल कर सकते हैं:

     s = 'y\xcc\xa6\xbb' n = signedbytes(s) 
  • डेटा को बड़ा-एंडियन होना चाहिए यदि आपके पास थोड़ा-अंत मूल्य है, तो आपको इसे पहले उल्टा करना चाहिए:

     n = signedbytes(s[::-1]) 

बेशक, इसका इस्तेमाल केवल तब किया जाना चाहिए जब मनमानी लंबाई की आवश्यकता हो। अन्यथा, अधिक मानक तरीके (जैसे struct ) के साथ रहें