En Complément à deux Binaires en Python?

Il fonctionne mieux si vous fournissez un masque. De cette façon, vous spécifiez la façon dont la mesure de signer étendre.

>>> bin(-27 & 0b1111111111111111)
'0b1111111111100101'

Ou peut-être de manière plus générale:

def bindigits(n, bits):
    s = bin(n & int("1"*bits, 2))[2:]
    return ("{0:0>%s}" % (bits)).format(s)

>>> print bindigits(-31337, 24)
111111111000010110010111

Dans la théorie de base, la largeur réelle de la le nombre est fonction de la taille de l'espace de stockage. Si c'est un nombre de 32 bits, puis un nombre négatif a un 1 dans le bit de poids fort d'un jeu de 32. Si c'est une valeur 64 bits, alors il y a 64 bits pour l'affichage.

Mais en Python, entier précision est limitée seulement aux contraintes de votre matériel. Sur mon ordinateur, ce fonctionne réellement, mais il consomme 9GO de RAM juste pour stocker la valeur de x. Quelque chose de plus élevé et je reçois un MemoryError. Si j'avais plus de RAM, je pourrais stocker un plus grand nombre.

>>> x = 1 << (1 << 36)

Donc, avec cela à l'esprit, ce nombre binaire représente -1? Python est bien capable d'interpréter littéralement des millions (et même des milliards) de bits de précision, comme l'exemple précédent le montre. En complément de 2, le bit de signe s'étend tout le chemin à gauche, mais en Python il n'y a pas de pré-définir le nombre de bits; il y en a autant que vous avez besoin.

Mais puis que vous exécutez dans l'ambiguïté: est-ce binaire 1 représentent 1, ou -1? Eh bien, il pourrait être. Ne 111 représentent 7 ou -1? Encore une fois, il pourrait être. Donc ne 111111111 représentent 511, ou -1... eh bien, à la fois, en fonction de votre précision.

Python a besoin d'un moyen de représenter ces nombres en binaire, de sorte qu'il n'y a aucune ambiguïté de leur sens. Le 0b préfixe juste dit "ce nombre est en binaire". Tout comme 0x signifie "ce nombre est en hexadécimal". Donc si je dis 0b1111, comment puis-je savoir si l'utilisateur veut -1 ou 15? Il y a deux options:

Option A: Le bit de signe

Vous pouvez déclarer que tous les nombres sont signés, et le plus à gauche bit est le bit de signe. Cela signifie que 0b1 est -1, tandis que 0b01 est 1. Cela signifie aussi que 0b111 est également -1, tandis que 0b0111 est 7. En fin de compte, ce n'est probablement plus à confusion qu'utile en particulier parce que la plupart des arithmétique binaire va être unsigned de toute façon, et les gens sont plus susceptibles d'exécuter des erreurs par inadvertance en marquant un nombre négatif parce qu'ils n'ont pas prévoir de façon explicite le bit de signe.

Option B: Le signe indication

Avec cette option, les nombres binaires sont représentées non signés, et les nombres négatifs ont un "-" préfixe, comme ils le font en décimal. C'est (un) plus cohérente avec décimale, (b) plus compatible avec la manière dont les valeurs binaires sont les plus susceptibles va être utilisé. Vous perdez la possibilité de spécifier un nombre négatif à l'aide de son complément à deux de la représentation, mais n'oubliez pas qu'en complément à deux est un de stockage de la mise en œuvre détail, pas une bonne indication de la valeur sous-jacente elle-même. Cela ne devrait pas être quelque chose que l'utilisateur a à comprendre.

En fin de compte, l'Option B qui fait le plus de sens. Il y a moins de confusion et l'utilisateur n'est pas nécessaire pour comprendre le stockage de détails.

tobin = lambda x, count=8: "".join(map(lambda y:str((x>>y)&1), range(count-1, -1, -1)))

par exemple

tobin(5)      # =>  '00000101'
tobin(5, 4)   # =>      '0101'
tobin(-5, 4)  # =>      '1011'

Ou désactivez les fonctions:

# Returns bit y of x (10 base).  i.e. 
# bit 2 of 5 is 1
# bit 1 of 5 is 0
# bit 0 of 5 is 1
def getBit(y, x):
    return str((x>>y)&1)

# Returns the first `count` bits of base 10 integer `x`
def tobin(x, count=8):
    shift = range(count-1, -1, -1)
    bits = map(lambda y: getBit(y, x), shift)
    return "".join(bits)

(Adapté de W. J. Van de Laan du commentaire)

def tobin(data, width):
    data_str = bin(data & (2**width-1))[2:].zfill(width)
    return data_str

Pour les nombres positifs, il suffit d'utiliser:

bin(x)[2:].zfill(4)

Pour les nombres négatifs, c'est un peu différent:

bin((eval("0b"+str(int(bin(x)[3:].zfill(4).replace("0","2").replace("1","0").replace("2","1"))))+eval("0b1")))[2:].zfill(4)

Comme un ensemble de script, c'est comment il devrait ressembler à:

def binary(number):
    if number < 0:
        return bin((eval("0b"+str(int(bin(number)[3:].zfill(4).replace("0","2").replace("1","0").replace("2","1"))))+eval("0b1")))[2:].zfill(4)
    return bin(number)[2:].zfill(4)      
x=input()
print binary(x)

Pas besoin, elle ne l'est déjà. C'est juste python qui choisissent de se représenter les choses différemment. Si vous lancez l'impression, chaque grignoter séparément, il va montrer ses vraies couleurs.

checkNIB = '{0:04b}'.format
checkBYT = lambda x: '-'.join( map( checkNIB, [ (x>>4)&0xf, x&0xf] ) ) 
checkBTS = lambda x: '-'.join( [ checkBYT( ( x>>(shift*8) )&0xff ) for shift in reversed( range(4) ) if ( x>>(shift*8) )&0xff ] )


print( checkBTS(-0x0002) )

De sortie est simple:

>>>1111-1111-1111-1111-1111-1111-1111-1110  

Maintenant, il revient à l'origine de la représentation lorsque vous souhaitez afficher un complément à deux de grignoter, mais il est encore possible si vous le divisez en deux moitiés de grignoter et ainsi de. Juste avoir à l'esprit que le meilleur résultat est négatif hexadécimal et en binaire entier interprétations chiffres simples pas tellement, aussi avec hex vous pouvez définir la taille en octets.

J'espère que cela résout votre problème`

num = input("Enter number : ")
bin_num=bin(num)
binary = '0' + binary_num[2:]
print binary