bit-wise opération unaire ~ (inverser)

Je suis un peu confus par la ~ de l'opérateur. Code de passe ci-dessous:

a = 1
~a  #-2
b = 15
~b  #-16

Comment ~ faire le travail?

J'ai pensé, ~a serait quelque chose comme:

0001 = a
1110 = ~a

pourquoi pas?

InformationsquelleAutor Alcott | 2011-09-02
  1. 52

    Vous êtes au bon endroit. Il s'agit d'un artefact de en complément à deux représentation entière.

    En 16 bits, 1 est représenté comme 0000 0000 0000 0001. Inversé, vous obtenez 1111 1111 1111 1110, qui est de -2. De même, 15 est 0000 0000 0000 1111. Inversé, vous obtenez 1111 1111 1111 0000, qui est de -16.

    En général, ~n = -n - 1

    • comment puis-je obtenir que peu de représentation de chaîne de caractères en python 3?
    • En python shell interactif, essayer d'impression(int('0001', 2)) référence:wiki.python.org/moin/BitManipulation
    • C'est la fonction inverse de ce Janus veut je crois.
    InformationsquelleAutor NullUserException
  2. 29

    Le '~' opérateur est défini comme:
    "Le bit d'inversion de x est définie comme(x+1). Elle ne s'applique qu'à l'intégrale des numéros."Python Doc - 5.5

    La partie importante de cette phrase est que cela est lié à "l'ensemble des nombres" (également appelé entiers). Votre exemple représente un 4 nombre de bits.

    '0001' = 1

    De l'intervalle entier de 4 bits est '-8..0..7'. Sur l'autre main, vous pouvez utiliser 'des entiers non signés", qui ne comprennent pas de nombre négatif et la gamme pour votre 4 nombre de bits serait "0..15'.

    Depuis Python fonctionne sur des entiers le comportement que vous avez décrit est prévu. Les entiers sont représentés en utilisant en complément à deux. Dans le cas d'une 4 nombre de bits cela ressemble à la suivante. 

     7 = '0111'
 0 = '0000'
-1 = '1111'
-8 = '1000'

    Python utilise 32 bits pour la représentation entière dans le cas où vous avez un 32-bit OS. Vous pouvez vérifier le plus grand entier avec:

    sys.maxint # (2^31)-1 for my system

    Dans le cas où vous souhaitez un entier non signé est retourné pour vous 4 nombre de bits que vous avez à masque.

    '0001' = a   # unsigned '1' /integer '1'
'1110' = ~a  # unsigned '14' /integer -2

(~a & 0xF) # returns 14

    Si vous voulez obtenir un entier non signé de 8 bits (0..255), au lieu juste utiliser:

    (~a & 0xFF) # returns 254
    • entiers ont un nombre illimité de précision dans les deux python 2 et 3
    • Par le temps que vous avez dit, vous ne vous attendiez pas si nombreux upvotes. Je pense qu'il vaut la peine de mentionner les détails comme "est-ce que votre déclaration de changer quoi que ce soit concernant la manipulation de bits?" ou peut-être il vaut la peine de l'édition de la réponse.
    • bon point, et c'est pourquoi j'ai fermé cette question comme un doublon d'une autre Q/A, qui donne la bonne réponse.
    InformationsquelleAutor sebs
  3. 6

    Il semble que j'ai trouvé plus simple solution qui répond à ce qui est souhaité:

    uint8: x ^ 0xFF
uint16: x ^ 0xFFFF
uint32: x ^ 0xFFFFFFFF
uint64: x ^ 0xFFFFFFFFFFFFFFFF
    InformationsquelleAutor user1919695
  4. 4

    Vous pouvez aussi utiliser des entiers non signés (par exemple à partir de la numpy package) pour obtenir le comportement attendu.

    >>> import numpy as np
>>> bin( ~ np.uint8(1))
'0b11111110'
    InformationsquelleAutor user1747134
  5. 1

    Python unaire inversion de l'opérateur ~x = -(x+1), et ce est le même que le retournement chaque bit dans la mémoire:

    par exemple

    >>> 0b110    # an integer defined with a binary literal
# 0|1,1,0    = in sign|magnitude form
# +|4,2,0    = each bit's contribution to the int
# +1*(4+2+0) =>
6            

>>> bin(~0b110) # get the binary representation of inverted 0b110
# 1|001         = each bit simply inverted (invert sign bit too)
# -|4+2+0 +1    = each bit's contribution to the int, ‡See note
# -1*(4+2+0+1)  = -7    (the answer we want that represents each bit flipped)
# -0b111        = binary representation of -7
-0b111          = it resembles 1|111 but it in memory it is actually 1|001

    -0b111 est 1|001 dans la mémoire. Vous ne devriez pas interpréter un -ve nombre binaire de représentation de ce qui est stocké dans la mémoire, contrairement à un positive nombre binaire.

    ‡ Remarque: les nombres Négatifs en binaire compter à rebours, de sorte que chaque -ve position de bit n'est pris en compte pour la composition de la int si c'est 0, et vous devez ajouter de -1 au résultat final:

    # in-memory  = int  (displayed as)
1|11..111    = -1   (-0b1)
1|11..110    = -2   (-0b10)
1|11..101    = -3   (-0b11)
1|11..100    = -4   (-0b100)
# and so on...
    InformationsquelleAutor Riaz Rizvi