Python int到二进制？-Java 学习之路

368

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

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

28 回答

54
如果你正在寻找bin()等同于 hex() ，它是在python 2.6中添加的 .

例：
```
>>> bin(10)
'0b1010'
```
回复于 2024-04-26T16:53:22+08:00
9
Python的字符串格式方法可以采用格式规范 .
```
>>> "{0:b}".format(37)
'100101'
```
Format spec docs for Python 2

Format spec docs for Python 3
回复于 2024-04-26T16:53:22+08:00
4
Python实际上已经内置了一些内容，能够执行 '{0:b}'.format(42) 等操作，它将为您提供 42 或 101010 的位模式（在字符串中） .

对于更一般的哲学，任何语言或图书馆都不会为其用户群提供他们想要的一切 . 如果你提供了你所需要的，你应该在开发时收集代码片段，以确保你永远不必写两次相同的东西 . 例如：
```
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还没有更简单的方法，它将根据十进制值构造二进制字符串 .

一般的想法是使用代码（按优先顺序）：
- 语言或内置库 .
- 具有合适许可证的第三方库 .
- 你自己的收藏 .
- 你需要写一些新内容（并保存在你自己的集合中供以后使用） .
回复于 2024-04-26T16:53:22+08:00
3
作为参考：
```
def toBinary(n):
    return ''.join(str(1 & int(n) >> i) for i in range(64)[::-1])
```
此函数可以转换与 18446744073709551615 一样大的正整数，表示为字符串 '1111111111111111111111111111111111111111111111111111111111111111' .

它可以被修改为提供更大的整数，但它可能不像 "{0:b}".format() 或 bin() 那样方便 .
回复于 2024-04-26T16:53:22+08:00

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

回复于 2024-04-26T16:53:22+08:00

单行与 lambda ：

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

测试：

>>> binary(5)
'101'

EDIT ：

但是之后：（

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

回复于 2024-04-26T16:53:22+08:00

5
一种简单的方法是使用字符串格式，请参阅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是二进制字符串的宽度 .
回复于 2024-04-26T16:53:22+08:00

538

替代方案摘要：

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 . 和Martijn Pieters .

回复于 2024-04-26T16:53:22+08:00

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

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

回复于 2024-04-26T16:53:22+08:00

0

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

回复于 2024-04-26T16:53:22+08:00

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

回复于 2024-04-26T16:53:22+08:00

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

print binary(10)

输出：

1010

回复于 2024-04-26T16:53:22+08:00

这是我刚刚实现的代码 . 这不是 method 但您可以将其用作 ready-to-use function ！

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

回复于 2024-04-26T16:53:22+08:00

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

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

回复于 2024-04-26T16:53:22+08:00

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

回复于 2024-04-26T16:53:22+08:00

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

回复于 2024-04-26T16:53:22+08:00

有点类似的解决方案

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

回复于 2024-04-26T16:53:22+08:00

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

回复于 2024-04-26T16:53:22+08:00

1
如果你愿意放弃"pure" Python但是获得了很多火力，there is Sage - example here：
```
sage: a = 15
sage: a.binary()
'1111'
```
您会注意到它以字符串形式返回，因此要将其用作您想要执行某些操作的数字
```
sage: eval('0b'+b)
15
```
回复于 2024-04-26T16:53:22+08:00

361

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

回复于 2024-04-26T16:53:22+08:00

计算数字的二进制数：

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

回复于 2024-04-26T16:53:22+08:00

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二进制矩阵 .
回复于 2024-04-26T16:53:22+08:00

你可以这样做：

bin(10)[2:]

要么：

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

回复于 2024-04-26T16:53:22+08:00

1
这是为了python 3，它保持领先的零！
```
print(format(0, '08b'))
```
回复于 2024-04-26T16:53:22+08:00

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

回复于 2024-04-26T16:53:22+08:00

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

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

    print(convertedNumber)

print("")

回复于 2024-04-26T16:53:22+08:00

0
```
>>> format(123, 'b')
'1111011'
```
回复于 2024-04-26T16:53:22+08:00

对于我们这些需要将有符号整数（范围-2 **（数字-1）到2 **（数字-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'

回复于 2024-04-26T16:53:22+08:00

Python int到二进制？

28 回答

相关问题