Python int到二进制字符串？


Python int to binary string?

在python中，是否有任何隐藏的python方法可以将整数(或long)转换为二进制字符串？

google上有很多dec2bin()函数…但我希望我可以使用内置的函数/库。

python的字符串格式方法可以采用格式规范。

1
2
>>>"{0:b}".format(37)
'100101'

python 2的格式规范文档

python 3的格式规范文档

相关讨论

如果您在寻找与hex()等效的bin()，它是在python 2.6中添加的。

例子：

1
2
>>> bin(10)
'0b1010'

号

相关讨论

python实际上已经为此内置了一些功能，比如可以执行诸如'{0:b}'.format(42)之类的操作，这将为42或101010提供位模式(字符串)。

对于更一般的哲学来说，没有任何一种语言或库能够满足用户的所有需求。如果您的工作环境不完全满足您的需求，那么您应该在开发过程中收集代码片段，以确保不必重复编写相同的代码。例如：

1
2
3
4
5
6
7
8
9
10
11
def int_to_bin_string(i):
    if i == 0:
        return"0"
    s = ''
    while i:
        if i & 1 == 1:
            s ="1" + s
        else:
            s ="0" + s
        i //= 2
    return s

它将基于十进制值构造二进制字符串，假设python还没有更简单的方法。

一般的想法是使用(按优先顺序)中的代码：

  • 语言或内置库。
  • 具有适当许可证的第三方图书馆。
  • 你自己的收藏。
  • 您需要编写一些新的内容(并保存在自己的集合中以备以后使用)。
相关讨论

作为参考：

1
2
def toBinary(n):
    return ''.join(str(1 & int(n) >> i) for i in range(64)[::-1])

。

此函数可以转换一个大到18446744073709551615的正整数，用字符串'1111111111111111111111111111111111111111111111111111111111111111'表示。

它可以修改为一个更大的整数，尽管它可能不如"{0:b}".format()或bin()那样方便。

相关讨论

如果需要不带0b前缀的文本表示，可以使用以下命令：

1
2
3
4
5
6
7
get_bin = lambda x: format(x, 'b')

print(get_bin(3))
>>> '11'

print(get_bin(-3))
>>> '-11'

当需要n位表示时：

1
2
3
4
5
get_bin = lambda x, n: format(x, 'b').zfill(n)
>>> get_bin(12, 32)
'00000000000000000000000000001100'
>>> get_bin(-12, 32)
'-00000000000000000000000000001100'

。

或者，如果您更喜欢功能：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def get_bin(x, n=0):
   """
    Get the binary representation of x.

    Parameters
    ----------
    x : int
    n : int
        Minimum number of digits. If x needs less digits in binary, the rest
        is filled with zeros.

    Returns
    -------
    str
   """
    return format(x, 'b').zfill(n)

。

相关讨论

一个带lambda的衬里：

1
>>> binary = lambda n: '' if n==0 else binary(n/2) + str(n%2)

号

测试：

1
2
>>> binary(5)
'101'

号

编辑：

但随后：(

1
2
3
4
5
6
t1 = time()
for i in range(1000000):
     binary(i)
t2 = time()
print(t2 - t1)
# 6.57236599922

号

与…相比

1
2
3
4
5
6
t1 = time()
for i in range(1000000):
    '{0:b}'.format(i)
t2 = time()
print(t2 - t1)
# 0.68017411232
相关讨论

一个简单的方法是使用字符串格式，请参见本页。

1
2
>>"{0:b}".format(10)
'1010'

号

如果你想要一个固定长度的二进制字符串，你可以使用这个：

1
2
>>"{0:{fill}8b}".format(10, fill='0')
'00001010'

如果需要两个补码，则可以使用以下行：

1
'{0:{fill}{width}b}'.format((x + 2**n) % 2**n, fill='0', width=n)

其中n是二进制字符串的宽度。

备选方案概要：

1
2
3
4
5
6
n=42
assert "-101010" == format(-n, 'b')
assert "-101010" =="{0:b}".format(-n)
assert "-101010" == (lambda x: x >= 0 and str(bin(x))[2:] or"-" + str(bin(x))[3:])(-n)
assert"0b101010" == bin(n)
assert  "101010" == bin(n)[2:]   # But this won't work for negative numbers.

号

贡献者包括约翰·福伊、东阮、MVCHR、马丁·托马。还有马提金·彼得斯。

相关讨论

这是针对Python3的，它保持前导零！

1
print(format(0, '08b'))

。

enter image description here。

使用numpy pack/unpackbits，他们是您最好的朋友。

1
2
3
4
5
6
7
8
9
10
11
12
Examples
--------
>>> a = np.array([[2], [7], [23]], dtype=np.uint8)
>>> a
array([[ 2],
       [ 7],
       [23]], dtype=uint8)
>>> b = np.unpackbits(a, axis=1)
>>> b
array([[0, 0, 0, 0, 0, 0, 1, 0],
       [0, 0, 0, 0, 0, 1, 1, 1],
       [0, 0, 0, 1, 0, 1, 1, 1]], dtype=uint8)

。

相关讨论

另一种解决方案是使用另一种算法，使用位运算符。

1
2
3
4
5
6
def int2bin(val):
    res=''
    while val>0:
        res += str(val&1)
        val=val>>1     # val=val/2
    return res[::-1]   # reverse the string

号

更快的版本，无需反转字符串。

1
2
3
4
5
6
def int2bin(val):
   res=''
   while val>0:
       res = chr((val&1) + 0x30) + res
       val=val>>1    
   return res

号

相关讨论

1
2
3
4
5
6
7
8
def binary(decimal) :
    otherBase =""
    while decimal != 0 :
        otherBase  =  str(decimal % 2) + otherBase
        decimal    //=  2
    return otherBase

print binary(10)

号

输出：

1010

号

除非我误解了二进制字符串的含义，否则我认为您要查找的模块是struct

对于需要将有符号整数(range-2**(digits-1)转换为2**(digits-1)-1)到2的补码二进制字符串的人，这是有效的：

1
2
3
4
5
def int2bin(integer, digits):
if integer >= 0:
    return bin(integer)[2:].zfill(digits)
else:
    return bin(2**digits + integer)[2:]

。

这将产生：

1
2
3
4
5
6
7
8
>>> int2bin(10, 8)
'00001010'
>>> int2bin(-10, 8)
'11110110'
>>> int2bin(-128, 8)
'10000000'
>>> int2bin(127, 8)
'01111111'

号

这是我刚刚实现的代码。这不是一个方法，但您可以将它用作一个随时可用的函数！

1
2
3
4
5
6
7
8
9
def inttobinary(number):
  if number == 0:
    return str(0)
  result =""
  while (number != 0):
      remainder = number%2
      number = number/2
      result += str(remainder)
  return result[::-1] # to invert the string

下面是使用divmod()函数的简单解决方案，它返回不带分数的除法的提示和结果。

1
2
3
4
5
6
def dectobin(number):
    bin = ''
    while (number >= 1):
        number, rem = divmod(number, 2)
        bin = bin + str(rem)
    return bin

号

相关讨论

具有DEC、BIN、HEX所有必要功能的计算器：(用python 3.5制作并测试)

您可以更改输入测试编号并获取转换后的编号。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
# CONVERTER: DEC / BIN / HEX

def dec2bin(d):
    # dec -> bin
    b = bin(d)
    return b

def dec2hex(d):
    # dec -> hex
    h = hex(d)
    return h

def bin2dec(b):
    # bin -> dec
    bin_numb="{0:b}".format(b)
    d = eval(bin_numb)
    return d,bin_numb

def bin2hex(b):
    # bin -> hex
    h = hex(b)
    return h

def hex2dec(h):
    # hex -> dec
    d = int(h)
    return d

def hex2bin(h):
    # hex -> bin
    b = bin(h)
    return b


## TESTING NUMBERS
numb_dec = 99
numb_bin = 0b0111
numb_hex = 0xFF


## CALCULATIONS
res_dec2bin = dec2bin(numb_dec)
res_dec2hex = dec2hex(numb_dec)

res_bin2dec,bin_numb = bin2dec(numb_bin)
res_bin2hex = bin2hex(numb_bin)

res_hex2dec = hex2dec(numb_hex)
res_hex2bin = hex2bin(numb_hex)



## PRINTING
print('------- DECIMAL to BIN / HEX -------
')
print('decimal:',numb_dec,'
bin:    ',res_dec2bin,'
hex:    ',res_dec2hex,'
')

print('------- BINARY to DEC / HEX -------
')
print('binary: ',bin_numb,'
dec:    ',numb_bin,'
hex:    ',res_bin2hex,'
')

print('----- HEXADECIMAL to BIN / HEX -----
')
print('hexadec:',hex(numb_hex),'
bin:    ',res_hex2bin,'
dec:    ',res_hex2dec,'
')
1
2
n=input()
print(bin(n).replace("0b",""))

号

这里还有另一种使用常规数学的方法，不使用循环，只使用递归。(一般情况0不返回任何值)。

1
2
3
4
5
6
7
8
def toBin(num):
  if num == 0:
    return""
  return toBin(num//2) + str(num%2)

print ([(toBin(i)) for i in range(10)])

['', '1', '10', '11', '100', '101', '110', '111', '1000', '1001']

号

有点类似的解决方案

1
2
3
4
5
6
7
8
9
10
11
12
def to_bin(dec):
    flag = True
    bin_str = ''
    while flag:
        remainder = dec % 2
        quotient = dec / 2
        if quotient == 0:
            flag = False
        bin_str += str(remainder)
        dec = quotient
    bin_str = bin_str[::-1] # reverse the string
    return bin_str

。

To calculate binary of numbers:

号

1
print("Binary is {0:>08b}".format(16))

号

To calculate the Hexa decimal of a number:

号

1
print("Hexa Decimal is {0:>0x}".format(15))

To Calculate all the binary no till 16::

号

1
2
for i in range(17):
   print("{0:>2}: binary is {0:>08b}".format(i))

。

To calculate Hexa decimal no till 17

号

1
2
3
 for i in range(17):
    print("{0:>2}: Hexa Decimal is {0:>0x}".format(i))
##as 2 digit is enogh for hexa decimal representation of a number

你可以这样做：

1
bin(10)[2:]

。

或：

1
2
3
4
f = str(bin(10))
c = []
c.append("".join(map(int, f[2:])))
print c

如果你愿意放弃"纯"Python，但获得大量火力，这里有一个圣人的例子：

1
2
3
sage: a = 15
sage: a.binary()
'1111'

您会注意到它以字符串的形式返回，所以要将它用作一个数字，您需要执行如下操作

1
2
sage: eval('0b'+b)
15

我发现了一种使用矩阵运算将十进制转换为二进制的方法。

1
2
3
4
import numpy as np
E_mat = np.tile(E,[1,M])
M_order = pow(2,(M-1-np.array(range(M)))).T
bindata = np.remainder(np.floor(E_mat /M_order).astype(np.int),2)

。

E为输入十进制数据，M为二进制顺序。bindata是输出二进制数据，其格式为1×m的二进制矩阵。

1
2
>>> format(123, 'b')
'1111011'
1
2
3
4
5
6
7
8
9
10
11
12
try:
    while True:
        p =""
        a = input()
        while a != 0:
            l = a % 2
            b = a - l
            a = b / 2
            p = str(l) + p
        print(p)
except:
    print ("write 1 number")

号

相关讨论

这是一个简单的二进制到十进制转换器，它连续循环

1
2
3
4
5
6
7
8
t = 1
while t > 0:
    binaryNumber = input("Enter a binary No.")
    convertedNumber = int(binaryNumber, 2)

    print(convertedNumber)

print("")

号

相关讨论

与尤素夫·亚齐兹的回答类似

1
2
3
4
5
6
7
8
9
10
11
def intToBin(n):
    if(n < 0):
        print"Sorry, invalid input."
    elif(n == 0):
        print n
    else:
        result =""
        while(n != 0):
            result += str(n%2)
            n /= 2
        print result[::-1]

。

我对它进行了调整，使唯一被变异的变量是结果(当然是n)。

如果您需要在其他地方使用此函数(即让另一个模块使用结果)，请考虑以下调整：

1
2
3
4
5
6
7
8
9
10
11
def intToBin(n):
    if(n < 0):
        return -1
    elif(n == 0):
        return str(n)
    else:
        result =""
        while(n != 0):
            result += str(n%2)
            n /= 2
        return result[::-1]

所以-1将是您的sentinel值，指示转换失败。(假设您只转换正数，不管它们是整数还是长整数)。

相关讨论

由于前面的答案大多使用format()，这里是一个F字符串实现。

1
2
3
integer = 7
bit_count = 5
print(f'{integer:0{bit_count}b}')

号

输出：

00111

号

为了方便起见，这里有格式化字符串文本的python-docs链接：https://docs.python.org/3/reference/lexical_analysis.html_f-strings。

这是我的答案，它工作得很好。

1
2
3
4
5
6
def binary(value) :
    binary_value = ''
    while value !=1  :
        binary_value += str(value%2)
        value = value//2
    return '1'+binary_value[::-1]

号

埃多克斯1〔3〕

以上文档链接中的示例：

1
2
3
4
5
6
>>> np.binary_repr(3)
'11'
>>> np.binary_repr(-3)
'-11'
>>> np.binary_repr(3, width=4)
'0011'

The two’s complement is returned when the input number is negative and width is specified:

1
2
3
4
>>> np.binary_repr(-3, width=3)
'101'
>>> np.binary_repr(-3, width=5)
'11101'

号

我觉得Martijn Pieter的评论值得作为一个答案加以强调：

1
binary_string = format(value, '0{}b'.format(width))

号

对我来说既清晰又多才多艺。