Python int in stringa binaria?

Esistono metodi Python predefiniti per convertire un numero intero (o Long) in una stringa binaria in Python?

Esistono una miriade di funzioni di dec2bin () su Google ... Ma speravo di poter usare una funzione / libreria integrata.

Il metodo di formato stringa di Python può richiedere una specifica di formato.

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

Formatta i documenti delle specifiche per Python 2

Formatta i documenti delle specifiche per Python 3

Se stai cercando bin() come equivalente ahex() , è stato aggiunto in Python 2.6.

Esempio:

>>> bin(10)
'0b1010'

Python in realtà ha qualcosa già costruito in per questo, la capacità di fare operazioni come '{0:b}'.format(42), che vi darà la sequenza di bit (in una stringa) per 42o 101010.

Per una filosofia più generale, nessuna lingua o biblioteca fornirà alla sua base di utenti tutto ciò che desiderano. Se lavori in un ambiente che non fornisce esattamente ciò di cui hai bisogno, dovresti raccogliere frammenti di codice mentre sviluppi per assicurarti di non dover mai scrivere la stessa cosa due volte. Come, ad esempio, lo pseudo-codice:

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

che costruirà la tua stringa binaria in base al valore decimale. Tieni presente che è un po 'di pseudo-codice generico che potrebbe non essere il più efficiente di farlo, tuttavia, con le iterazioni che sembra stia proponendo, non farà molta differenza. In realtà è solo inteso come una linea guida su come potrebbe essere fatto.

L'idea generale è di usare il codice da (in ordine di preferenza):

• la lingua o le librerie integrate.
• librerie di terze parti con licenze adeguate.
• la tua collezione.
• qualcosa di nuovo che devi scrivere (e salvare nella tua raccolta per dopo).

Se si desidera una rappresentazione testuale senza il prefisso 0b, è possibile utilizzare questo:

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

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

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

Quando si desidera una rappresentazione n-bit:

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

In alternativa, se preferisci avere una funzione:

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)

Come referenza:

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

Questa funzione può convertire un numero intero positivo grande come 18446744073709551615, rappresentato come stringa'1111111111111111111111111111111111111111111111111111111111111111' .

Può essere modificato per servire un numero intero molto più grande, anche se potrebbe non essere utile come "{0:b}".format()o bin().

Un modo semplice per farlo è usare il formato stringa, vedi questa pagina .

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

E se vuoi avere una lunghezza fissa della stringa binaria, puoi usare questo:

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

Se è richiesto il complemento a due, è possibile utilizzare la seguente riga:

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

dove n è la larghezza della stringa binaria.

Questo è per Python 3 e mantiene gli zeri iniziali!

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

one-liner con lambda :

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

test:

>>> binary(5)
'101'

MODIFICARE :

ma allora :(

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

in confronto a

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

Riepilogo delle alternative:

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.

Tra i collaboratori ci sono John Fouhy , Tung Nguyen , mVChr , Martin Thoma . e Martijn Pieters.

Poiché le risposte precedenti utilizzavano principalmente il formato (), ecco un'implementazione di f-string.

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

Produzione:

00111

Per comodità, ecco il link dei documenti di Python per i letterali di stringa formattati: https://docs.python.org/3/reference/lexical_analysis.html#f-strings .

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

Usando numpy pack / unpackbits, sono i tuoi migliori amici.

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)

Per quelli di noi che hanno bisogno di convertire numeri interi con segno (intervallo -2 ** (cifre-1) in 2 ** (cifre-1) -1) nelle stringhe binarie del complemento di 2, questo funziona:

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

Questo produce:

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

A meno che non fraintenda cosa intendi per stringa binaria, penso che il modulo che stai cercando sia struct

Ancora un'altra soluzione con un altro algoritmo, usando operatori bit per bit.

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

Una versione più veloce senza invertire la stringa.

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)

produzione:

1010

puoi fare così:

bin(10)[2:]

o :

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

Ecco il codice che ho appena implementato. Questo non è un metodo ma puoi usarlo come una funzione pronta per l'uso !

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

qui è una soluzione semplice che utilizza il fucmtion divmod () che restituisce il promemoria e il risultato di una divisione senza la frazione.

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)

Esempi dal link della documentazione sopra:

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

Il complemento a due viene restituito quando il numero di input è negativo e viene specificata la larghezza:

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

Soluzione un po 'simile

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 

Ecco un altro modo di usare la matematica normale, nessun loop, solo la ricorsione. (Il caso Trivial 0 non restituisce nulla).

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

Calcolatrice con tutte le funzioni necessarie per DEC, BIN, HEX: (realizzata e testata con Python 3.5)

È possibile modificare i numeri dei test di input e ottenere quelli convertiti.

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

Per calcolare il numero binario di numeri:

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

Per calcolare il decimale Hexa di un numero :

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

Per calcolare tutto il numero binario fino a 16 ::

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

Per calcolare il decimale Hexa no fino a 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

Se sei disposto a rinunciare a Python "puro" ma ottieni molta potenza di fuoco, c'è Sage - esempio qui :

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

Noterai che ritorna come una stringa, quindi per usarlo come numero vorresti fare qualcosa del genere

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

Ho trovato un metodo che utilizza l'operazione matrice per convertire i decimali in binari.

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)

Evengono inseriti dati decimali, Msono gli ordini binari. bindatavengono emessi dati binari, che è in un formato 1 con matrice binaria M.

Ecco un semplice convertitore da binario a decimale che esegue un loop continuo

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

    print(convertedNumber)

print("")

Questa è la mia risposta funziona bene ..!

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