Как я могу преобразовать строку байтов в int в Python?

Скажи так: '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

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

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

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

В 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

в соответствии с порядком байтов вашей строки.

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

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

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", и порядковый номер преобразования string-> int зависят от конкретной реализации Python. Но если вы хотите преобразовать много целых чисел / строк одновременно, то модуль массива сделает это быстро.

В Python 2.x вы могли использовать спецификаторы формата <Bдля байтов без знака и <bдля байтов со знаком с struct.unpack/ struct.pack.

Например:

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

>>> 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: добавьте один байт, скажите «A»:

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

Тест 5: разделить на 256:

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

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

Я изо всех сил пытался найти решение для последовательности байтов произвольной длины, которая работала бы в 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)

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

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

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

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

hex (bytes2int ([0x87, 0x65, 0x43, 0x21])) возвращает «0x87654321».

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

Как уже упоминалось выше, использование unpackфункции struct является хорошим способом. Если вы хотите реализовать свою собственную функцию, есть другое решение:

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

В Python 3 вы можете легко преобразовать байтовую строку в список целых чисел (0..255) с помощью

>>> list(b'y\xcc\xa6\xbb')
[121, 204, 166, 187]

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

предопределенные переменные:

offset = 0
size = 4
big = True # endian
arr = array('B')
arr.fromstring("\x00\x00\xff\x00") # 5 bytes (encoding issues) [0, 0, 195, 191, 0]

к int: (читать)

val = 0
for v in arr[offset:offset+size][::pow(-1,not big)]: val = (val<<8)|v

из int: (написать)

val = 16384
arr[offset:offset+size] = \
    array('B',((val>>(i<<3))&255 for i in range(size)))[::pow(-1,not big)]

Возможно, они могут быть быстрее, хотя.

РЕДАКТИРОВАТЬ:
Для некоторых чисел, вот тест производительности (Anaconda 2.3.0), показывающий стабильные средние значения при чтении по сравнению с reduce():

========================= byte array to int.py =========================
5000 iterations; threshold of min + 5000ns:
______________________________________code___|_______min______|_______max______|_______avg______|_efficiency
⣿⠀⠀⠀⠀⡇⢀⡀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⡀⠀⢰⠀⠀⠀⢰⠀⠀⠀⢸⠀⠀⢀⡇⠀⢀⠀⠀⠀⠀⢠⠀⠀⠀⠀⢰⠀⠀⠀⢸⡀⠀⠀⠀⢸⠀⡇⠀⠀⢠⠀⢰⠀⢸⠀
⣿⣦⣴⣰⣦⣿⣾⣧⣤⣷⣦⣤⣶⣾⣿⣦⣼⣶⣷⣶⣸⣴⣤⣀⣾⣾⣄⣤⣾⡆⣾⣿⣿⣶⣾⣾⣶⣿⣤⣾⣤⣤⣴⣼⣾⣼⣴⣤⣼⣷⣆⣴⣴⣿⣾⣷⣧⣶⣼⣴⣿⣶⣿⣶
    val = 0 \nfor v in arr: val = (val<<8)|v |     5373.848ns |   850009.965ns |     ~8649.64ns |  62.128%
⡇⠀⠀⢀⠀⠀⠀⡇⠀⡇⠀⠀⣠⠀⣿⠀⠀⠀⠀⡀⠀⠀⡆⠀⡆⢰⠀⠀⡆⠀⡄⠀⠀⠀⢠⢀⣼⠀⠀⡇⣠⣸⣤⡇⠀⡆⢸⠀⠀⠀⠀⢠⠀⢠⣿⠀⠀⢠⠀⠀⢸⢠⠀⡀
⣧⣶⣶⣾⣶⣷⣴⣿⣾⡇⣤⣶⣿⣸⣿⣶⣶⣶⣶⣧⣷⣼⣷⣷⣷⣿⣦⣴⣧⣄⣷⣠⣷⣶⣾⣸⣿⣶⣶⣷⣿⣿⣿⣷⣧⣷⣼⣦⣶⣾⣿⣾⣼⣿⣿⣶⣶⣼⣦⣼⣾⣿⣶⣷
                  val = reduce( shift, arr ) |     6489.921ns |  5094212.014ns |   ~12040.269ns |  53.902%

Это необработанный тест производительности, так что endian pow-flip исключен. Функции показано , применяется один и тот же сдвиг-ORing операцию как для цикла, и это просто , как это имеет быстрый итеративный производительность рядом .
shiftarrarray.array('B',[0,0,255,0])dict

Я должен также отметить, что эффективность измеряется с точностью до среднего времени.