如何在Python中将字符串转换为int

How can I convert a string of bytes into an int in python?

如何在python中将字符串转换为int?

Say like this: 'y\xcc\xa6\xbb'

这样说:'y \ xcc \ xa6 \ xbb'

I came up with a clever/stupid way of doing it:

我想出了一个聪明/愚蠢的方法:

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

I know there has to be something builtin or in the standard library that does this more simply...

我知道必须有内置的东西或在标准库中更简单地做到这一点......

This is different from converting a string of hex digits for which you can use int(xxx, 16), but instead I want to convert a string of actual byte values.

这与转换可以使用int(xxx,16)的十六进制数字字符串不同,但我想转换一串实际字节值。

UPDATE:

I kind of like James' answer a little better because it doesn't require importing another module, but Greg's method is faster:

我有点像詹姆斯的答案好一点,因为它不需要导入另一个模块,但Greg的方法更快:

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

My hacky method:

我的hacky方法:

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

FURTHER UPDATE:

Someone asked in comments what's the problem with importing another module. Well, importing a module isn't necessarily cheap, take a look:

有人在评论中询问导入另一个模块的问题是什么。好吧,导入模块不一定便宜,看看:

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

Including the cost of importing the module negates almost all of the advantage that this method has. I believe that this will only include the expense of importing it once for the entire benchmark run; look what happens when I force it to reload every time:

包括导入模块的成本几乎抵消了该方法的所有优点。我相信这只会包括在整个基准测试中导入一次的费用;看看我每次强迫它重装时会发生什么:

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

Needless to say, if you're doing a lot of executions of this method per one import than this becomes proportionally less of an issue. It's also probably i/o cost rather than cpu so it may depend on the capacity and load characteristics of the particular machine.

毋庸置疑,如果您在每次导入时执行大量此方法的执行,那么这在一定程度上会成为问题。它也可能是i / o成本而不是cpu,因此它可能取决于特定机器的容量和负载特性。

10 个解决方案

#1

You can also use the struct module to do this:

您还可以使用struct模块执行此操作:

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

#2

In Python 3.2 and later, use

在Python 3.2及更高版本中,使用

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

or

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

according to the endianness of your byte-string.

根据你的字节串的字节顺序。

This also works for bytestring-integers of arbitrary length, and for two's-complement signed integers by specifying signed=True. See the docs for from_bytes.

这也适用于任意长度的字节串整数,并且通过指定signed = True可用于二进制补码有符号整数。请参阅from_bytes的文档。

#3

As Greg said, you can use struct if you are dealing with binary values, but if you just have a "hex number" but in byte format you might want to just convert it like:

正如Greg所说,如果你正在处理二进制值,你可以使用struct,但如果你只有一个“十六进制数”但是以字节格式,你可能只想转换它:

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

...this is the same as:

......这与以下相同:

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

...except it'll work for any number of bytes.

...除了它可以用于任何数量的字节。

#4

I use the following function to convert data between int, hex and bytes.

我使用以下函数在int,hex和bytes之间转换数据。

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

Source: http://opentechnotes.blogspot.com.au/2014/04/convert-values-to-from-integer-hex.html

#5

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

Warning: the above is strongly platform-specific. Both the "I" specifier and the endianness of the string->int conversion are dependent on your particular Python implementation. But if you want to convert many integers/strings at once, then the array module does it quickly.

警告:以上内容特别针对特定于平台。 “I”说明符和string-> int转换的字节顺序都取决于您的特定Python实现。但是如果你想一次转换许多整数/字符串,那么数组模块会很快完成。

#6

In Python 2.x, you could use the format specifiers <B for unsigned bytes, and <b for signed bytes with struct.unpack/struct.pack.

在Python 2.x中,您可以使用格式说明符 表示无符号字节,

E.g:

Let x = '\xff\x10\x11'

设x ='\ xff \ x10 \ x11'

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

And:

data_bytes = struct.pack('<' + 'B'*len(data_ints), *data_ints) # '\xff\x10\x11'

That * is required!

*是必需的!

See https://docs.python.org/2/library/struct.html#format-characters for a list of the format specifiers.

有关格式说明符的列表,请参阅https://docs.python.org/2/library/struct.html#format-characters。

#7

int.from_bytes is the best solution if you are at version >=3.2. The "struct.unpack" solution requires a string so it will not apply to arrays of bytes. Here is another solution:

如果您的版本> = 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

hex( bytes2int( [0x87, 0x65, 0x43, 0x21])) returns '0x87654321'.

hex(bytes2int([0x87,0x65,0x43,0x21]))返回'0x87654321'。

It handles big and little endianness and is easily modifiable for 8 bytes

它处理大和小的字节序,并且很容易修改为8个字节

#8

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

Test 1: inverse:

测试1:逆:

>>> hex(2043455163)
'0x79cca6bb'

Test 2: Number of bytes > 8:

测试2:字节数> 8:

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

Test 3: Increment by one:

测试3:增加一:

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

Test 4: Append one byte, say 'A':

测试4:附加一个字节,说'A':

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

Test 5: Divide by 256:

测试5:除以256:

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

Result equals the result of Test 4, as expected.

正如预期的那样,结果等于测试4的结果。

#9

As mentioned above using unpack function of struct is a good way. If you want to implement your own function there is an another solution:

如上所述使用struct的unpack函数是一个好方法。如果您想实现自己的功能,还有另一种解决方案:

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

#10

I was struggling to find a solution for arbitrary length byte sequences that would work under Python 2.x. Finally I wrote this one, it's a bit hacky because it performs a string conversion, but it works.

我正在努力寻找可在Python 2.x下工作的任意长度字节序列的解决方案。最后我写了这个,它有点hacky因为它执行字符串转换,但它的工作原理。

Function for Python 2.x, arbitrary length

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)

This function has two requirements:

此功能有两个要求:

• The input data needs to be a bytearray. You may call the function like this:

  输入数据需要是一个bytearray。您可以像这样调用函数:

  s = 'y\xcc\xa6\xbb'
  n = signedbytes(s)
  

• The data needs to be big-endian. In case you have a little-endian value, you should reverse it first:

  数据需要是大端的。如果你有一个小端值,你应该先反转它:

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

Of course, this should be used only if arbitrary length is needed. Otherwise, stick with more standard ways (e.g. struct).

当然,只有在需要任意长度时才应该使用它。否则,坚持使用更多标准方法(例如struct)。