Python int đến chuỗi nhị phân?

Có phương thức Python đóng hộp nào để chuyển đổi một Integer (hoặc Long) thành một chuỗi nhị phân trong Python không?

Có vô số hàm dec2bin () trên Google ... Nhưng tôi đã hy vọng mình có thể sử dụng hàm / thư viện tích hợp.

Phương pháp định dạng chuỗi của Python có thể lấy thông số định dạng.

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

Định dạng tài liệu đặc tả cho Python 2

Định dạng tài liệu đặc tả cho Python 3

Nếu bạn đang tìm kiếm bin()tương đương hex(), nó đã được thêm vào python 2.6.

Thí dụ:

>>> bin(10)
'0b1010'

Python thực sự không có một cái gì đó đã được xây dựng trong cho điều này, khả năng làm các hoạt động như '{0:b}'.format(42), mà sẽ cung cấp cho bạn các mẫu bit (trong một chuỗi) cho 42hay 101010.

Đối với một triết lý tổng quát hơn, không có ngôn ngữ hoặc thư viện sẽ cung cấp cho người dùng cơ sở mọi thứ mà họ mong muốn. Nếu bạn đang làm việc trong một môi trường không cung cấp chính xác những gì bạn cần, bạn nên thu thập các đoạn mã khi bạn phát triển để đảm bảo bạn không bao giờ phải viết điều tương tự hai lần. Chẳng hạn như, ví dụ, mã giả:

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

sẽ xây dựng chuỗi nhị phân của bạn dựa trên giá trị thập phân. Chỉ cần ghi nhớ đó là một chút chung của pseudo-code có thể không phải là hầu hết các cách hiệu quả để làm việc đó tuy nhiên, với sự lặp đi lặp lại bạn dường như được đề xuất, nó sẽ không làm cho nhiều sự khác biệt. Nó thực sự chỉ là một hướng dẫn về cách nó có thể được thực hiện.

Ý tưởng chung là sử dụng mã từ (theo thứ tự ưu tiên):

• ngôn ngữ hoặc thư viện tích hợp.
• thư viện bên thứ ba với giấy phép phù hợp.
• bộ sưu tập của riêng bạn.
• một cái gì đó mới bạn cần viết (và lưu trong bộ sưu tập của riêng bạn cho sau này).

Nếu bạn muốn một biểu diễn văn bản không có tiền tố 0b, bạn có thể sử dụng:

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

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

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

Khi bạn muốn một đại diện n-bit:

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

Ngoài ra, nếu bạn thích có một chức năng:

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)

Để tham khảo:

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

Hàm này có thể chuyển đổi một số nguyên dương lớn bằng 18446744073709551615, được biểu diễn dưới dạng chuỗi '1111111111111111111111111111111111111111111111111111111111111111'.

Nó có thể được sửa đổi để phục vụ một số nguyên lớn hơn nhiều, mặc dù nó có thể không tiện dụng bằng "{0:b}".format()hoặc bin().

Một cách đơn giản để làm điều đó là sử dụng định dạng chuỗi, xem trang này .

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

Và nếu bạn muốn có một chuỗi nhị phân có độ dài cố định, bạn có thể sử dụng:

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

Nếu bổ sung hai là bắt buộc, thì dòng sau có thể được sử dụng:

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

Trong đó n là chiều rộng của chuỗi nhị phân.

Đây là cho python 3 và nó giữ các số không hàng đầu!

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

một lớp lót với lambda :

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

kiểm tra:

>>> binary(5)
'101'

CHỈNH SỬA :

nhưng sau đó :(

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

so với

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

Tóm tắt các lựa chọn thay thế:

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.

Những người đóng góp bao gồm John Fouhy , Tung Nguyen , mVChr , Martin Thoma . và Martijn Pieters.

Như các câu trả lời trước chủ yếu được sử dụng định dạng (), đây là một triển khai chuỗi f.

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

Đầu ra:

00111

Để thuận tiện ở đây là liên kết tài liệu python cho các chuỗi ký tự được định dạng: https://docs.python.org/3/reference/lexical_analysis.html#f-strings .

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

Sử dụng gói numpy / unpackbits, họ là những người bạn tốt nhất của bạn.

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)

Đối với những người trong chúng ta, những người cần chuyển đổi số nguyên đã ký (phạm vi -2 ** (chữ số-1) thành 2 ** (chữ số-1) -1) thành chuỗi nhị phân bổ sung của 2, điều này hoạt động:

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

Điều này tạo ra:

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

Trừ khi tôi hiểu nhầm ý của bạn về chuỗi nhị phân, tôi nghĩ mô-đun bạn đang tìm kiếm là struct

Một giải pháp khác với thuật toán khác, bằng cách sử dụng các toán tử bitwise.

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

Một phiên bản nhanh hơn mà không đảo ngược chuỗi.

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

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

print binary(10)

đầu ra:

1010

bạn có thể làm như thế:

bin(10)[2:]

hoặc là :

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

Đây là mã tôi vừa thực hiện. Đây không phải là một phương pháp nhưng bạn có thể sử dụng nó như một chức năng sẵn sàng để sử dụng !

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

đây là giải pháp đơn giản sử dụng fucntion divmod () trả về lời nhắc và kết quả của phép chia không có phân số.

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

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

numpy.binary_repr(num, width=None)

Ví dụ từ liên kết tài liệu ở trên:

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

Phần bù của hai được trả về khi số đầu vào là âm và chiều rộng được chỉ định:

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

Giải pháp tương tự

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 

Đây là một cách khác để sử dụng toán học thông thường, không có vòng lặp, chỉ đệ quy. (Trường hợp tầm thường 0 không trả về gì).

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

Máy tính có tất cả các chức năng cần thiết cho DEC, BIN, HEX: (được tạo và thử nghiệm với Python 3.5)

Bạn có thể thay đổi số kiểm tra đầu vào và lấy số đã chuyển đổi.

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

Để tính nhị phân của các số:

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

Để tính số thập phân Hexa của một số :

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

Để tính tất cả các nhị phân cho đến 16 ::

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

Để tính thập phân Hexa cho đến 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

Nếu bạn sẵn sàng từ bỏ Python "thuần túy" nhưng có được nhiều hỏa lực, thì có Sage - ví dụ ở đây :

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

Bạn sẽ lưu ý rằng nó trả về dưới dạng một chuỗi, vì vậy, để sử dụng nó như một số bạn muốn làm một cái gì đó như

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

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

Tôi tìm thấy một phương pháp sử dụng ma trận hoạt động để chuyển đổi thập phân thành nhị phân.

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)

Elà dữ liệu thập phân đầu vào, Mlà các lệnh nhị phân. bindatalà dữ liệu nhị phân đầu ra, có định dạng 1 ma trận nhị phân M.

Đây là một công cụ chuyển đổi nhị phân sang thập phân đơn giản liên tục lặp

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

    print(convertedNumber)

print("")

Đây là câu trả lời của tôi nó hoạt động tốt ..!

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