Python int zu binärem String?

Gibt es vordefinierte Python-Methoden, um eine Ganzzahl (oder Long) in Python in eine Binärzeichenfolge zu konvertieren?

Es gibt eine Vielzahl von dec2bin () -Funktionen bei Google ... Aber ich hatte gehofft, ich könnte eine integrierte Funktion / Bibliothek verwenden.

Die String-Formatmethode von Python kann eine Formatspezifikation annehmen.

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

Formatieren Sie die Spezifikationsdokumente für Python 2

Formatieren Sie die Spezifikationsdokumente für Python 3

Wenn Sie nach bin()einem Äquivalent suchen hex(), wurde es in Python 2.6 hinzugefügt.

Beispiel:

>>> bin(10)
'0b1010'

Python tatsächlich tut etwas dafür gebaut hat bereits die Fähigkeit , Operationen, wie zu tun '{0:b}'.format(42), was Ihnen das Bitmuster geben (in einem String) für 42oder 101010.

Für eine allgemeinere Philosophie gibt keine Sprache oder Bibliothek ihrer Benutzerbasis alles , was sie sich wünschen. Wenn Sie in einer Umgebung arbeiten, die nicht genau das bietet, was Sie benötigen, sollten Sie während der Entwicklung Codeausschnitte sammeln, um sicherzustellen, dass Sie nie zweimal dasselbe schreiben müssen. Wie zum Beispiel der Pseudocode:

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

Dadurch wird Ihre Binärzeichenfolge basierend auf dem Dezimalwert erstellt. Denken Sie daran , dass ein generisch bisschen Pseudo-Code ist das nicht das sein kann , am meisten jedoch effiziente Art und Weise tun, mit den Iterationen Sie scheinen zu schlagen, wird es nicht viel Unterschied machen. Es ist wirklich nur als Richtlinie gedacht, wie es gemacht werden könnte.

Die allgemeine Idee ist, Code von (in der Reihenfolge der Präferenz) zu verwenden:

• die Sprache oder die eingebauten Bibliotheken.
• Bibliotheken von Drittanbietern mit geeigneten Lizenzen.
• Ihre eigene Sammlung.
• etwas Neues, das Sie schreiben müssen (und für später in Ihrer eigenen Sammlung speichern müssen).

Wenn Sie eine Textdarstellung ohne das Präfix 0b wünschen, können Sie Folgendes verwenden:

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

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

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

Wenn Sie eine n-Bit-Darstellung wünschen:

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

Alternativ, wenn Sie eine Funktion bevorzugen:

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)

Als Referenz:

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

Diese Funktion kann eine positive Ganzzahl konvertieren, die so groß wie 18446744073709551615ist und als Zeichenfolge dargestellt wird '1111111111111111111111111111111111111111111111111111111111111111'.

Es kann geändert werden, um eine viel größere Ganzzahl zu liefern, obwohl es möglicherweise nicht so praktisch ist wie "{0:b}".format()oder bin().

Eine einfache Möglichkeit hierfür ist die Verwendung des Zeichenfolgenformats (siehe diese Seite) .

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

Und wenn Sie eine feste Länge der Binärzeichenfolge haben möchten, können Sie Folgendes verwenden:

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

Wenn das Zweierkomplement erforderlich ist, kann die folgende Zeile verwendet werden:

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

Dabei ist n die Breite der Binärzeichenfolge.

Dies ist für Python 3 und es behält die führenden Nullen!

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

Einzeiler mit Lambda :

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

Prüfung:

>>> binary(5)
'101'

BEARBEITEN :

aber dann :(

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

im Vergleich zu

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

Zusammenfassung der Alternativen:

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.

Zu den Mitwirkenden gehören John Fouhy , Tung Nguyen , mVChr und Martin Thoma . und Martijn Pieters.

Da die vorhergehenden Antworten meistens format () verwendeten, ist hier eine F-String-Implementierung.

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

Ausgabe:

00111

Der Einfachheit halber finden Sie hier den Python-Dokument-Link für formatierte Zeichenfolgenliterale: https://docs.python.org/3/reference/lexical_analysis.html#f-strings .

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

Mit Numpy Pack / Unpackbits sind sie Ihre besten Freunde.

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)

Für diejenigen von uns, die vorzeichenbehaftete Ganzzahlen (Bereich -2 ** (Ziffern-1) in 2 ** (Ziffern-1) -1) in 2-Komplement-Binärzeichenfolgen konvertieren müssen, funktioniert dies:

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

Dies erzeugt:

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

Es sei denn, ich verstehe falsch, was Sie unter Binärzeichenfolge verstehen. Ich denke, das Modul, nach dem Sie suchen, ist struct

Noch eine Lösung mit einem anderen Algorithmus unter Verwendung bitweiser Operatoren.

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

Eine schnellere Version ohne Umkehrung der Zeichenfolge.

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)

Ausgabe:

1010

Sie können so tun:

bin(10)[2:]

oder :

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

Hier ist der Code, den ich gerade implementiert habe. Dies ist keine Methode, aber Sie können sie als gebrauchsfertige Funktion verwenden !

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

Hier ist eine einfache Lösung mit der Funktion divmod (), die die Erinnerung und das Ergebnis einer Division ohne den Bruch zurückgibt.

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)

Beispiele aus dem obigen Dokumentationslink:

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

Das Zweierkomplement wird zurückgegeben, wenn die Eingabenummer negativ ist und die Breite angegeben wird:

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

Etwas ähnliche Lösung

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 

Hier ist noch eine andere Möglichkeit, normale Mathematik zu verwenden, keine Schleifen, nur Rekursion. (Trivialfall 0 gibt nichts zurück).

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

Rechner mit allen notwendigen Funktionen für DEC, BIN, HEX: (erstellt und getestet mit Python 3.5)

Sie können die eingegebenen Testnummern ändern und die konvertierten erhalten.

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

So berechnen Sie die Binärzahl von Zahlen:

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

So berechnen Sie die Hexa-Dezimalstelle einer Zahl :

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

Um alle binären Nr. Bis 16 zu berechnen ::

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

Zur Berechnung der Hexa-Dezimalzahl Nr. Bis 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

Wenn Sie bereit sind, "reines" Python aufzugeben, aber viel Feuerkraft zu gewinnen, gibt es hier Sage - Beispiel :

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

Sie werden feststellen, dass es als Zeichenfolge zurückgegeben wird. Wenn Sie es also als Zahl verwenden möchten, möchten Sie so etwas tun

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

Ich habe eine Methode gefunden, die eine Matrixoperation verwendet, um Dezimalzahlen in Binärzahlen umzuwandeln.

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)

Eist eingegebene Dezimaldaten, Mist die binäre Reihenfolge. bindataEs werden Binärdaten ausgegeben, die in einem Format von 1 mal M Binärmatrix vorliegen.

Hier ist ein einfacher Binär-Dezimal-Konverter, der sich kontinuierlich wiederholt

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

    print(convertedNumber)

print("")

Dies ist meine Antwort, es funktioniert gut ..!

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