파이썬 정수를 이진 문자열로?

파이썬 정수를 이진 문자열로?

---

Integer (또는 Long)를 Python에서 바이너리 문자열로 변환하는 미리 준비된 Python 메서드가 있습니까?

Google에는 무수히 많은 dec2bin () 함수가 있습니다.하지만 내장 함수 / 라이브러리를 사용할 수 있기를 바랐습니다.

---

Python의 문자열 형식 메서드는 형식 사양을 취할 수 있습니다.

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

Python 2 용 형식 사양 문서

Python 3 용 형식 사양 문서

---

에 bin()상응하는 것을 찾고 있다면 hex()파이썬 2.6에 추가되었습니다.

예:

>>> bin(10)
'0b1010'

---

파이썬은 실제로 않습니다 이미 이것에 대한 내장 무언가가, 같은 작업을 할 수있는 능력 '{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

파이썬이 이미 더 쉬운 방법을 가지고 있지 않다고 가정하면 십진수 값을 기반으로 바이너리 문자열을 구성합니다.

일반적인 아이디어는 (선호 순서대로) 코드를 사용하는 것입니다.

• 언어 또는 내장 라이브러리.
• 적절한 라이센스가있는 타사 라이브러리.
• 자신의 컬렉션.
• 작성해야 할 새로운 것 (나중을 위해 자신의 컬렉션에 저장).

---

참고로 :

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

이 함수는 18446744073709551615문자열로 표시되는 만큼 큰 양의 정수를 변환 할 수 있습니다 '1111111111111111111111111111111111111111111111111111111111111111'.

"{0:b}".format()또는 만큼 편리하지는 않지만 훨씬 더 큰 정수를 제공하도록 수정할 수 있습니다 bin().

---

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)

---

람다가있는 한 줄짜리 :

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

---

이를 수행하는 간단한 방법은 문자열 형식을 사용하는 것입니다 . 이 페이지를 참조 하십시오 .

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

이진 문자열의 고정 된 길이를 원한다면 다음을 사용할 수 있습니다.

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

2의 보수가 필요한 경우 다음 행을 사용할 수 있습니다.

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

여기서 n은 이진 문자열의 너비입니다.

---

대안 요약 :

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.

---

이것은 파이썬 3 용이며 선행 0을 유지합니다!

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

---

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)

---

이진 문자열이 의미하는 바를 오해하지 않는 한 찾고있는 모듈이 struct 라고 생각합니다.

---

방금 구현 한 코드는 다음과 같습니다. 이것은 방법이 아니지만 바로 사용할 수있는 기능으로 사용할 수 있습니다 !

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

---

비트 연산자를 사용하는 또 다른 알고리즘의 또 다른 솔루션입니다.

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 

---

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

print binary(10)

산출:

1010 년

---

여기에 분수없이 나누기의 결과와 미리 알림을 반환하는 divmod () 함수를 사용하는 간단한 솔루션이 있습니다.

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

---

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

---

부호있는 정수 (범위 -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'

---

앞의 답변에서 주로 format ()을 사용 했으므로 여기에 f-string 구현이 있습니다.

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 .

---

다소 유사한 솔루션

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 

---

여기에 규칙적인 수학, 루프없이 재귀 만 사용하는 또 다른 방법이 있습니다. (인용 사례 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']

---

이진수를 계산하려면 :

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

숫자의 Hexa 십진수를 계산하려면 다음을 수행하십시오 .

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

16까지의 모든 바이너리를 계산하려면 :

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

To calculate Hexa decimal no till 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

---

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

---

If you are willing to give up "pure" Python but gain a lot of firepower, there is Sage - example here:

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

You'll note that it returns as a string, so to use it as a number you'd want to do something like

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

---

I found a method using matrix operation to convert decimal to binary.

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)

Eis input decimal data,M is the binary orders. bindata is output binary data, which is in a format of 1 by M binary matrix.

---

you can do like that :

bin(10)[2:]

or :

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

---

numpy.binary_repr(num, width=None)

Examples from the documentation link above:

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

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

---

Along a similar line to Yusuf Yazici's answer

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]

I adjusted it so that the only variable being mutated is result (and n of course).

이 기능을 다른 곳에서 사용해야하는 경우 (즉, 다른 모듈에서 결과를 사용) 다음 조정을 고려하십시오.

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은 전환이 실패했음을 나타내는 센티널 값 입니다. (이것은 정수이든 long이든 양수 만 변환한다고 가정합니다.)

---

다음은 계속 반복되는 간단한 2 진수에서 10 진수로의 변환기입니다.

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

    print(convertedNumber)

print("")

참조 URL : https://stackoverflow.com/questions/699866/python-int-to-binary-string