Python int到二进制字符串？

时间：2009-03-31 03:04:38

标签： python

是否有任何固定的Python方法可以在Python中将Integer（或Long）转换为二进制字符串？

Google上有无数的dec2bin（）函数......但我希望我能使用内置的函数/库。

35 个答案:

答案 0 :(得分：601)

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

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

Format spec docs for Python 2

Format spec docs for Python 3

答案 1 :(得分：394)

如果您正在寻找与hex()相当的bin()，则会在python 2.6中添加它。

示例：

>>> bin(10)
'0b1010'

答案 2 :(得分：55)

Python实际上 已经内置了一些内容，能够执行'{0:b}'.format(42)等操作，这将为{{1}提供位模式（字符串中） }，或42。

对于更一般的理念，任何语言或库都不会为其用户群提供他们想要的所有。如果您在一个无法提供所需内容的环境中工作，那么您应该在开发时收集代码片段，以确保您不必再编写两次相同的内容。例如：

101010

它将根据十进制值构造二进制字符串，假设Python没有更简单的方法。

一般的想法是使用代码（按优先顺序）：

  • 语言或内置库。
  • 拥有合适许可证的第三方图书馆。
  • 你自己的收藏。
  • 您需要编写的新内容（并保存在您自己的集合中以供日后使用）。

答案 3 :(得分：36)

作为参考：

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

此函数可以转换为18446744073709551615的正整数，表示为字符串'1111111111111111111111111111111111111111111111111111111111111111'。

可以修改它以提供更大的整数，但它可能不像"{0:b}".format()或bin()那样方便。

答案 4 :(得分：33)

如果你想要一个没有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)

答案 5 :(得分：14)

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

答案 6 :(得分：12)

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

>> "{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是二进制字符串的宽度。

答案 7 :(得分：7)

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

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

enter image description here

答案 8 :(得分：5)

我很惊讶，没有提到使用格式化字符串完成此操作的好方法。 TLDR：

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

更长的故事

这是格式化字符串的功能：

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

答案 9 :(得分：5)

使用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)

答案 10 :(得分：4)

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

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

输出为“你好，鲍勃，你的电话号码是00001010！”

对此问题的讨论可以在这里找到-Here

答案 11 :(得分：4)

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

答案 12 :(得分：4)

使用按位运算符的另一种算法的另一种解决方案。 

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

答案 13 :(得分：4)

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

print binary(10)

输出：

  

1010

答案 14 :(得分：3)

以下是我刚刚实施的代码。这不是方法，但您可以将其用作即用型功能！

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

答案 15 :(得分：3)

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

答案 16 :(得分：3)

对于我们这些需要将带符号整数（范围-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'

答案 17 :(得分：3)

具有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 -------\n')
print('decimal:',numb_dec,'\nbin:    ',res_dec2bin,'\nhex:    ',res_dec2hex,'\n')

print('------- BINARY to DEC / HEX -------\n')
print('binary: ',bin_numb,'\ndec:    ',numb_bin,'\nhex:    ',res_bin2hex,'\n')

print('----- HEXADECIMAL to BIN / HEX -----\n')
print('hexadec:',hex(numb_hex),'\nbin:    ',res_hex2bin,'\ndec:    ',res_hex2dec,'\n')

答案 18 :(得分：3)

这里是使用divmod（）函数的简单解决方案，它返回余数和没有分数的除法结果。

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

答案 19 :(得分：2)

这是使用常规数学，无循环，仅递归的另一种方式。 （普通案例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']

答案 20 :(得分：2)

有点类似的解决方案

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

答案 21 :(得分：2)

  

计算数字二进制数： 

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

计算Hexa十进制数至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

答案 22 :(得分：1)

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

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

答案 23 :(得分：1)

您可以这样做：

bin(10)[2:]

或：

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

答案 24 :(得分：1)

如果你愿意放弃＆＃34;纯粹的＆＃34; Python但获得了很多火力，there is Sage - example here：

{
 "serialNumber" : "ABCDEFG12345",
 "clickType" : "SINGLE",
 "batteryVoltage" : "5v USB"
}

您会注意到它会以字符串形式返回，因此要将其用作您想要执行此操作的数字

sage: a = 15
sage: a.binary()
'1111'

答案 25 :(得分：1)

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

答案 26 :(得分：1)

@staticmethod

答案 27 :(得分：1)

由于前面的答案主要使用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。

答案 28 :(得分：1)

已接受的答案未涉及负数，我将介绍负数。 除上述答案外，您还可以使用bin和hex函数。并以相反的方向使用二进制符号：

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

但是，如果为负数，情况会变得更加复杂。这个问题没有指定您要如何处理负数。

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

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

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

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

更常见的是Two's complement notation，它似乎更复杂，其结果与python的字符串格式非常不同。您可以阅读链接中的详细信息，但使用8位带符号整数-37将是0b11011011，而37将是0b00100101。

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

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

但是我不知道使用内置函数做相反的简单方法。 bitstring package可以提供帮助。

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

答案 29 :(得分：0)

这是我的回答，效果很好..！

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

答案 30 :(得分：0)

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'

答案 31 :(得分：0)

我觉得Martijn Pieter's comment应该作为答案突出显示：

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

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

答案 32 :(得分：0)

与Yusuf Yazici的答案类似，

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

如果您需要在其他地方使用此功能（即，将结果用于其他模块），请考虑以下调整：

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将是您的哨兵值，表示转换失败。 （假设您只转换正数，无论它们是整数还是长数）。

答案 33 :(得分：0)

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

t = 1
while t > 0:
    binaryNumber = input("Enter a binary No.")
    convertedNumber = int(binaryNumber, 2)

    print(convertedNumber)

print("")

答案 34 :(得分：-1)

这是一个使用divmod构造二进制列表的（调试）程序：

程序 

while True:
    indecimal_str = input('Enter positive(decimal) integer: ')
    if indecimal_str == '':
        raise SystemExit
    indecimal_save = int(indecimal_str)
    if indecimal_save < 1:
        print('Rejecting input, try again')
        print()
        continue
    indecimal = int(indecimal_str)
    exbin = []
    print(indecimal, '<->', exbin)
    while True:
        if indecimal == 0:
            print('Conversion:', indecimal_save, '=', "".join(exbin))
            print()
            break
        indecimal, r = divmod(indecimal, 2)
        if r == 0:
            exbin.insert(0, '0')
        else:
            exbin.insert(0, '1')
        print(indecimal, '<->', exbin)

输出 

Enter positive(decimal) integer: 8
8 <-> []
4 <-> ['0']
2 <-> ['0', '0']
1 <-> ['0', '0', '0']
0 <-> ['1', '0', '0', '0']
Conversion: 8 = 1000

Enter positive(decimal) integer: 63
63 <-> []
31 <-> ['1']
15 <-> ['1', '1']
7 <-> ['1', '1', '1']
3 <-> ['1', '1', '1', '1']
1 <-> ['1', '1', '1', '1', '1']
0 <-> ['1', '1', '1', '1', '1', '1']
Conversion: 63 = 111111

Enter positive(decimal) integer: 409
409 <-> []
204 <-> ['1']
102 <-> ['0', '1']
51 <-> ['0', '0', '1']
25 <-> ['1', '0', '0', '1']
12 <-> ['1', '1', '0', '0', '1']
6 <-> ['0', '1', '1', '0', '0', '1']
3 <-> ['0', '0', '1', '1', '0', '0', '1']
1 <-> ['1', '0', '0', '1', '1', '0', '0', '1']
0 <-> ['1', '1', '0', '0', '1', '1', '0', '0', '1']
Conversion: 409 = 110011001
相关问题
最新问题