Python int en chaîne binaire?

Existe-t-il des méthodes Python prédéfinies pour convertir un entier (ou long) en chaîne binaire en Python?

Il existe une myriade de fonctions dec2bin () sur Google ... Mais j'espérais pouvoir utiliser une fonction / bibliothèque intégrée.

La méthode de format de chaîne de Python peut prendre une spécification de format.

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

Formater les documents de spécification pour Python 2

Formater les documents de spécification pour Python 3

Si vous recherchez bin()un équivalent àhex() , il a été ajouté en python 2.6.

Exemple:

>>> bin(10)
'0b1010'

Python a en fait quelque chose de déjà intégré pour cela, la possibilité d'effectuer des opérations telles que '{0:b}'.format(42), qui vous donnera le modèle de bits (dans une chaîne) pour 42, ou 101010.

Pour une philosophie plus générale, aucune langue ou bibliothèque ne donnera à sa base d'utilisateurs tout ce qu'elle désire. Si vous travaillez dans un environnement qui ne fournit pas exactement ce dont vous avez besoin, vous devez collecter des extraits de code au fur et à mesure de votre développement pour vous assurer de ne jamais avoir à écrire deux fois la même chose. Tels que, par exemple, le pseudo-code:

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

qui construira votre chaîne binaire en fonction de la valeur décimale. Gardez à l'esprit que c'est un peu générique de pseudo-code qui n'est peut-être pas le plus efficace de le faire, avec les itérations que vous semblez proposer, cela ne fera pas beaucoup de différence. Il s'agit simplement d'une ligne directrice sur la façon de le faire.

L'idée générale est d'utiliser du code de (par ordre de préférence):

• la langue ou les bibliothèques intégrées.
• bibliothèques tierces avec des licences appropriées.
• votre propre collection.
• quelque chose de nouveau que vous devez écrire (et enregistrer dans votre propre collection pour plus tard).

Si vous voulez une représentation textuelle sans le préfixe 0b, vous pouvez utiliser ceci:

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

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

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

Lorsque vous souhaitez une représentation à n bits:

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

Alternativement, si vous préférez avoir une fonction:

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)

Pour référence:

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

Cette fonction peut convertir un entier positif aussi grand que 18446744073709551615, représenté par une chaîne '1111111111111111111111111111111111111111111111111111111111111111'.

Il peut être modifié pour servir un entier beaucoup plus grand, bien qu'il ne soit pas aussi pratique que "{0:b}".format()ou bin().

Un moyen simple de le faire est d'utiliser le format de chaîne, voir cette page .

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

Et si vous voulez avoir une longueur fixe de la chaîne binaire, vous pouvez utiliser ceci:

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

Si le complément à deux est requis, la ligne suivante peut être utilisée:

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

où n est la largeur de la chaîne binaire.

C'est pour python 3 et il garde les zéros de tête!

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

one-liner avec lambda :

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

tester:

>>> binary(5)
'101'

ÉDITER :

mais alors :(

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

en comparaison avec

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

Résumé des alternatives:

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.

Les contributeurs incluent John Fouhy , Tung Nguyen , mVChr , Martin Thoma . et Martijn Pieters.

Comme les réponses précédentes utilisaient principalement le format (), voici une implémentation de f-string.

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

Production:

00111

Pour plus de commodité, voici le lien des documents python pour les littéraux de chaîne formatés: https://docs.python.org/3/reference/lexical_analysis.html#f-strings .

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

Utilisant numpy pack / unpackbits, ils sont vos meilleurs amis.

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)

Pour ceux d'entre nous qui ont besoin de convertir des entiers signés (plage -2 ** (chiffres-1) en 2 ** (chiffres-1) -1) en chaînes binaires complémentaires de 2, cela fonctionne:

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

Cela produit:

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

À moins que je ne comprenne mal ce que vous entendez par chaîne binaire, je pense que le module que vous recherchez est struct

Encore une autre solution avec un autre algorithme, en utilisant des opérateurs au niveau du bit.

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

Une version plus rapide sans inverser la chaîne.

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)

production:

1010

vous pouvez faire comme ça:

bin(10)[2:]

ou :

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

Voici le code que je viens d'implémenter. Ce n'est pas une méthode mais vous pouvez l'utiliser comme une fonction prête à l'emploi !

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

voici une solution simple utilisant la fonction divmod () qui retourne le rappel et le résultat d'une division sans la fraction.

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)

Exemples du lien de documentation ci-dessus:

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

Le complément à deux est renvoyé lorsque le nombre d'entrée est négatif et que la largeur est spécifiée:

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

Solution assez similaire

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 

Voici encore une autre façon d'utiliser les mathématiques régulières, pas de boucles, seulement la récursivité. (Le cas trivial 0 ne renvoie rien).

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

Calculatrice avec toutes les fonctions nécessaires pour DEC, BIN, HEX: (fabriqué et testé avec Python 3.5)

Vous pouvez modifier les numéros de test d'entrée et obtenir ceux convertis.

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

Pour calculer un binaire de nombres:

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

Pour calculer la décimale hexa d'un nombre :

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

Pour calculer tous les no binaires jusqu'à 16 ::

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

Pour calculer Hexa décimal 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

Si vous êtes prêt à abandonner Python "pur" mais à gagner beaucoup de puissance de feu, il y a Sage - exemple ici :

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

Vous remarquerez qu'il retourne sous forme de chaîne, donc pour l'utiliser comme un nombre, vous voudriez faire quelque chose comme

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

J'ai trouvé une méthode utilisant une opération matricielle pour convertir des décimales en binaires.

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)

Eest l'entrée des données décimales, Mest les ordres binaires. bindataest une sortie de données binaires, au format 1 par M matrice binaire.

Voici un simple convertisseur binaire en décimal qui boucle en continu

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

    print(convertedNumber)

print("")

C'est ma réponse ça marche bien ..!

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