преобразовать строку байтов в int (python)

Question

Как преобразовать строку байтов в int в python?

Скажем так: 'y\xcc\xa6\xbb'

я придумал умный/глупый способ сделать это:

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

Я знаю, что там должно быть что-то встроенных или в стандартной библиотеке, что делает это более просто ...

Это отличается от converting a string of hex digits, для которого вы можете использовать int (xxx, 16), но вместо этого я хочу преобразовать строку фактических байтовых значений.

UPDATE:

Я вроде как ответ Джеймса немного лучше, потому что он не требует импорта другого модуля, но метод Грэга быстрее:

>>> 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 

Мой Hacky метод:

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

ДАЛЕЕ UPDATE:

Кто-то спросил в комментариях, что это пр oblem с импортом другого модуля. Ну, импортируя модуль не обязательно дешевое, посмотрите:

>>> 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 

Излишне говорить, что если вы делаете много выполнений этого метода на один импорт, чем это становится пропорционально меньше проблемы. Это также, вероятно, стоимость ввода-вывода, а не процессора, поэтому он может зависеть от характеристик емкости и нагрузки конкретной машины.

Answer 1

Вы также можете использовать struct модуль, чтобы сделать это:

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

Answer 2

Как сказал Грег, вы можете использовать-структуру, если вы имеете дело с двоичными значениями, но если у вас есть только «шестнадцатеричное число», но в байтовый формат вы можете просто преобразовать его, как:

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

... это то же самое, как:

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

... за исключением того, что он будет работать для любого количества байтов.

Answer 3

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

Предупреждение: вышеупомянутое сильно зависит от конкретной платформы. И спецификатор «I», и сущность преобразования string-> int зависят от конкретной реализации Python. Но если вы хотите преобразовать сразу несколько целых чисел/строк, то модуль массива сделает это быстро.

Answer 4

В Python 3.2, а затем используйте

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

или

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

по endianness вашего байт-строки.

Это также работает для байтов-целых чисел произвольной длины и для целых чисел со знаком с двумя символами, задавая signed=True. См. docs for from_bytes.

Answer 5

Я использую следующую функцию для преобразования данных между 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

Answer 6

В Python 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 для получения списка спецификаторов формата.

Answer 7

Я пытался найти решение для произвольной длины байтовых последовательностей, которые будут работать под Python 2.x. Наконец, я написал это, он немного взломан, потому что он выполняет преобразование строк, но он работает.

Функция для Python 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) 
  

• Данные должны быть большим обратным порядком байтов. В случае, если у вас есть немного-Endian значение, вы должны обратить его первый:

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

Конечно, это должно быть использовано только в том случае произвольной длины требуется. В противном случае придерживайтесь более стандартных способов (например, struct).

Answer 8

int.from_bytes - лучшее решение, если вы находитесь в версии> = 3.2. Решение «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 

гекс (bytes2int ([0x87, 0x65, 0x43, 0x21])) возвращает '0x87654321'.

Он обрабатывает большой и маленький порядок байтов и легко модифицируется для 8 байт

Answer 9

>>> 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: Append один байт, скажем 'А':

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

Тест 5: Деление на 256:

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

Результат равен результату теста 4, как и следовало ожидать.

Answer 10

Как указано выше, используя unpack Функция struct - это хороший способ. Если вы хотите реализовать свою собственную функцию, есть еще одно решение:

def bytes_to_int(bytes): 
    result = 0 
    for b in bytes: 
     result = result * 256 + int(b) 
return result