问题描述：

如何在 Python 中将整数转换为二进制字符串？

37   →   '100101'

解决方案 1：

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

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

针对 Python 2 格式化规范文档

针对 Python 3 格式化规范文档

解决方案 2：

如果您正在寻找bin()与 等效的东西hex()，它已被添加到 python 2.6 中。

例子：

>>> bin(10)
'0b1010'

解决方案 3：

Python 实际上已经内置了一些用于实现此功能的功能，即执行诸如 之类的操作的能力，这将为您提供、 或 的'{0:b}'.format(42)位模式（在字符串中）。42`101010`

从更普遍的理念来看，没有任何语言或库能够满足用户的所有需求。如果您的工作环境无法提供您所需的一切，那么您应该在开发过程中收集代码片段，以确保您不必重复编写相同的代码。例如，伪代码：

define intToBinString, receiving intVal:
    if intVal is equal to zero:
        return "0"
    set strVal to ""
    while intVal is greater than zero:
        if intVal is odd:
            prefix "1" to strVal
        else:
            prefix "0" to strVal
        divide intVal by two, rounding down
    return strVal

这将根据十进制值构造二进制字符串。请记住，这只是一段通用的伪代码，可能不是最有效的方法，但根据您似乎建议的迭代，它不会有太大区别。它实际上只是关于如何完成的指导方针。

总体思路是使用以下代码（按优先顺序）：

• 语言或内置库。

• 具有适当许可证的第三方库。

• 您自己的收藏。

• 您需要写一些新内容（并保存在您自己的收藏中以供日后使用）。

解决方案 4：

我很惊讶没有提到使用 Python 3.6 及更高版本支持的格式化字符串来实现这一点的好方法。TLDR：

>>> number = 1
>>> f'0b{number:08b}'
'0b00000001'

更长的故事

这是从 Python 3.6 开始提供的格式化字符串的功能：

>>> x, y, z = 1, 2, 3
>>> f'{x} {y} {2*z}'
'1 2 6'

您也可以请求二进制文件：

>>> f'{z:b}'
'11'

指定宽度：

>>> f'{z:8b}'
'      11'

请求零填充：

f'{z:08b}'
'00000011'

并添加公共前缀来表示二进制数：

>>> f'0b{z:08b}'
'0b00000011'

您也可以让 Python 为您添加前缀，但我不太喜欢上面的版本，因为您必须考虑前缀的宽度：

>>> f'{z:#010b}'
'0b00000011'

更多信息请参阅格式化字符串文字和格式规范小语言的官方文档。

解决方案 5：

如果您想要没有 0b 前缀的文本表示，您可以使用以下命令：

get_bin = lambda x: format(x, 'b')

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

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

当您需要 n 位表示时：

get_bin = lambda x, n: format(x, 'b').zfill(n)
>>> get_bin(12, 32)
'00000000000000000000000000001100'
>>> get_bin(-12, 32)
'-00000000000000000000000000001100'

或者，如果您更喜欢使用以下函数：

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)

解决方案 6：

作为参考：

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

此函数可以将最大为的正整数转换18446744073709551615为字符串'1111111111111111111111111111111111111111111111111111111111111111'。

它可以被修改来提供更大的整数，尽管它可能不如"{0:b}".format()或那么方便bin()。

解决方案 7：

这是针对 python 3 的，它保留前导零！

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

解决方案 8：

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

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

如果您想要固定长度的二进制字符串，您可以使用以下命令：

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

如果需要二进制补码，则可以使用以下行：

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

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

解决方案 9：

使用lambda的一行代码：

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

测试：

>>> binary(5)
'101'

编辑：

但后来:(

t1 = time()
for i in range(1000000):
     binary(i)
t2 = time()
print(t2 - t1)
# 6.57236599922

相比于

t1 = time()
for i in range(1000000):
    '{0:b}'.format(i)
t2 = time()
print(t2 - t1)
# 0.68017411232

解决方案 10：

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

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

输出：

00111

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

解决方案 11：

替代方案总结：

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.

贡献者包括John Fouhy、Tung Nguyen、mVChr、Martin Thoma。和马丁·彼得斯。

解决方案 12：

>>> format(123, 'b')
'1111011'

解决方案 13：

对于那些需要将有符号整数（范围 -2(digits-1) 到 2(digits-1)-1）转换为 2 的补码二进制字符串的人来说，这样做有效：

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

得出的结果为：

>>> int2bin(10, 8)
'00001010'
>>> int2bin(-10, 8)
'11110110'
>>> int2bin(-128, 8)
'10000000'
>>> int2bin(127, 8)
'01111111'

解决方案 14：

你可以这样做：

bin(10)[2:]

或者 ：

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

解决方案 15：

使用 numpy pack/unpackbits，它们是你最好的朋友。

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)

解决方案 16：

接受的答案没有解决负数问题，我将介绍这一点。除了上述答案之外，您还可以使用bin和hex函数。相反，使用二进制表示法：

>>> bin(37)
'0b100101'
>>> 0b100101
37

但对于负数，事情就变得有点复杂了。问题没有具体说明如何处理负数。

Python 只是添加了一个负号，因此 -37 的结果将是这样的：

>>> bin(-37)
'-0b100101'

在计算机/硬件二进制数据中，不存在负号。我们只有 1 和 0。因此，如果您正在读取或生成二进制数据流以供其他软件/硬件处理，则需要首先了解所使用的符号。

一种表示法是符号-数值表示法，其中第一位代表负号，其余的是实际值。在这种情况下，-37 将是0b1100101，37 将是0b0100101。这看起来像 python 生成的，但只需在前面添加 0 或 1 来表示正数/负数。

更常见的是二进制补码表示法，它看起来更复杂，结果与 python 的字符串格式有很大不同。您可以在链接中阅读详细信息，但对于 8 位有符号整数 -37 将是 ，0b11011011而 37 将是0b00100101。

Python 没有简单的方法来生成这些二进制表示。您可以使用numpy将二进制补码值转换为 Python 整数：

>>> import numpy as np
>>> np.int8(0b11011011)
-37
>>> np.uint8(0b11011011)
219
>>> np.uint8(0b00100101)
37
>>> np.int8(0b00100101)
37

但我不知道使用内置函数实现相反效果的简单方法。不过bitstring 包可以提供帮助。

>>> from bitstring import BitArray
>>> arr = BitArray(int=-37, length=8)
>>> arr.uint
219
>>> arr.int
-37
>>> arr.bin
'11011011'
>>> BitArray(bin='11011011').int
-37
>>> BitArray(bin='11011011').uint
219

解决方案 17：

Python 3.6 添加了一种新的字符串格式化方法，称为格式化字符串文字或“f 字符串”。示例：

name = 'Bob'
number = 42
f"Hello, {name}, your number is {number:>08b}"

输出将是“你好，鲍勃，您的号码是 00001010！”

您可以在此处找到有关此问题的讨论 -此处

解决方案 18：

还有一种解决方案，采用另一种算法，即使用按位运算符。

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

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

def int2bin(val):
   res=''
   while val>0:
       res = chr((val&1) + 0x30) + res
       val=val>>1    
   return res 

解决方案 19：

numpy.binary_repr(num, width=None)

来自上面文档链接的示例：

>>> np.binary_repr(3)
'11'
>>> np.binary_repr(-3)
'-11'
>>> np.binary_repr(3, width=4)
'0011'

当输入数为负数且指定宽度时，返回二进制补码：

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

解决方案 20：

n=input()
print(bin(n).replace("0b", ""))

解决方案 21：

def binary(decimal) :
    otherBase = ""
    while decimal != 0 :
        otherBase  =  str(decimal % 2) + otherBase
        decimal    //=  2
    return otherBase

print binary(10)

输出：

1010

解决方案 22：

这是我刚刚实现的代码。这不是一个方法，但你可以将其用作现成的函数！

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

解决方案 23：

具有 DEC、BIN、HEX 所有必要函数的计算器:(使用 Python 3.5 制作并测试）

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

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

解决方案 24：

除非我误解了你所说的二进制字符串的意思，否则我认为你正在寻找的模块是结构

解决方案 25：

有点类似的解决方案

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 

解决方案 26：

这是一个使用 divmod() 函数的简单解决方案，该函数返回余数和不带分数的除法结果。

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

解决方案 27：

这是使用常规数学的另一种方法，没有循环，只有递归。（简单情况 0 不返回任何内容）。

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

解决方案 28：

计算数字的二进制数：

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

计算数字的十六进制数：

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

计算所有二进制数到 16::

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

计算十六进制数不超过 17

 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

解决方案 29：

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

解决方案 30：

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

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的二进制矩阵格式。