Opération et utilisation au niveau des bits

Question

 x = 1        # 0001
x << 2       # Shift left 2 bits: 0100
# Result: 4

x | 2        # Bitwise OR: 0011
# Result: 3

x & 1        # Bitwise AND: 0001 
# Result: 1
 

Je peux comprendre les opérateurs arithmétiques en Python (et dans d’autres langs), mais je n’ai jamais très bien compris les opérateurs «au niveau du bit». Dans l'exemple ci-dessus (tiré d'un livre Python), je comprends le décalage gauche, mais pas les deux autres.

Aussi, à quoi servent réellement les opérateurs de bits? J'apprécierais quelques exemples.

Merci!

Answer 1

Au niveau du bit les opérateurs sont des opérateurs qui travaillent sur multi-bits des valeurs, mais, conceptuellement, un peu à la fois.

• AND est de 1 seulement si deux de ses entrées sont à 1, sinon c'est 0.
• OR 1 si un ou deux de ses entrées sont à 1, sinon c'est 0.
• XOR est de 1 seulement si exactement une de ses entrées sont à 1, sinon c'est 0.
• NOT est de 1 seulement si son entrée est 0, sinon c'est 0.

Ceux-ci peuvent souvent être mieux illustré que la table de vérité. Entrée possibilités sont sur le haut et la gauche, la résultante de bits est l'un des quatre (deux dans le cas de ne PAS car il ne comporte qu'une entrée), les valeurs affichées à l'intersection des entrées.

AND | 0 1     OR | 0 1     XOR | 0 1    NOT | 0 1
----+-----    ---+----     ----+----    ----+----
 0  | 0 0      0 | 0 1       0 | 0 1        | 1 0
 1  | 0 1      1 | 1 1       1 | 1 0

Un exemple est si vous voulez seulement le bas 4 bits d'un entier, vous ET avec 15 (binaire 1111) donc:

    201: 1100 1001
AND  15: 0000 1111
------------------
 IS   9  0000 1001

Le zéro des bits à 15 dans ce cas, effectivement agir comme un filtre, forçant les bits du résultat à zéro.

En outre, >> et << sont souvent inclus comme opérateurs au niveau du bit, et ils "shift" une valeur respectivement à droite et à gauche par un certain nombre de bits de jeter les bits qui n'roll de la fin, vous êtes déplace vers l', et l'alimentation en zéro des bits à l'autre extrémité.

Ainsi, par exemple:

1001 0101 >> 2 gives 0010 0101
1111 1111 << 4 gives 1111 0000

Avec cela à l'esprit, un autre exemple d'opérateurs au niveau du bit est que si vous avez deux 4 bits les valeurs que vous souhaitez emballer dans un 8-bits, vous pouvez utiliser tous les trois de vos opérateurs (left-shift, and et or):

packed_val = ((val1 & 15) << 4) | (val2 & 15)

• L' & 15 opération assurez-vous que les deux valeurs seulement ont le plus faible de 4 bits.
• L' << 4 4-décalage de bits à gauche pour déplacer val1 dans les 4 premiers bits d'une valeur de 8 bits.
• L' | simplement combine ces deux ensemble.

Si val1 est de 7, et val2 est de 4:

                val1            val2
                ====            ====
 & 15 (and)   xxxx-0111       xxxx-0100  & 15
 << 4 (left)  0111-0000           |
                  |               |
                  +-------+-------+
                          |
| (or)                0111-0100

Answer 2

Une utilisation typique :

| est utilisé pour définir certains bits à 1

& est utilisé pour tester ou effacer un certaint peu

• Définir un peu (où n est le nombre de bits, et 0 est le bit le moins significatif):

  unsigned char a |= (1 << n);

• Clair un peu:

  unsigned char b &= ~(1 << n);

• Bascule un peu:

  unsigned char c ^= (1 << n);

• Test un peu:

  unsigned char e = d & (1 << n);

Prenons le cas de votre liste par exemple:

x | 2 est utilisé pour définir le bit 1 de l' x 1

x & 1 est utilisé pour tester si le bit 0 de l' x est 1 ou 0

Answer 3

quels sont les opérateurs sur les bits utilisé pour? J'apprécierais quelques exemples.

L'une des utilisations les plus courantes des opérations bit à bit est pour l'analyse hexadécimal des couleurs.

Par exemple, voici une fonction python qui accepte une Chaîne de caractères comme #FF09BE et renvoie un tuple de Rouge, de Vert et de Bleu valeurs.

def hexToRgb(value):
    //convert string to hexadecimal number (base 16)
    num = (int(value.lstrip("#"), 16))
    //shift 16 bits to the right, and then binary AND to obtain 8 bits representing red
    r = ((num >> 16) & 0xFF)
    //shift 8 bits to the right, and then binary AND to obtain 8 bits representing green
    g = ((num >> 8) & 0xFF)
    //simply binary AND to obtain 8 bits representing blue
    b = (num & 0xFF)
    return (r, g, b)

Je sais qu'il y a des moyens plus efficaces pour réaliser cela, mais je crois que c'est vraiment un très concis exemple illustrant à la fois les quarts de et bit à bit des opérations booléennes.

Answer 4

J'espère que cela clarifie les deux:

 x | 2

0001 //x
0010 //2

0011 //result = 3
 

---

 x & 1

0001 //x
0001 //1

0001 //result = 1
 

Answer 5

Cet exemple vous montrera les opérations pour les quatre valeurs à 2 bits:

 10 | 12

1010 #decimal 10
1100 #decimal 12

1110 #result = 14
 

---

 10 & 12

1010 #decimal 10
1100 #decimal 12

1000 #result = 8
 

Voici un exemple d'utilisation:

 x = raw_input('Enter a number:')
print 'x is %s.' % ('even', 'odd')[x&1]