Python Language
Opérateurs sur les bits
Recherche…
Introduction
Les opérations binaires modifient les chaînes binaires au niveau des bits. Ces opérations sont incroyablement simples et sont directement prises en charge par le processeur. Ces quelques opérations sont nécessaires pour travailler avec des pilotes de périphériques, des graphiques bas niveau, la cryptographie et les communications réseau. Cette section fournit des connaissances et des exemples utiles des opérateurs de bits de Python.
Syntaxe
x << y # Décalage bit à gauche
x >> y # Changement binaire droit
x & y # bit à bit ET
x | y # bit à bit OU
~ x # bitwise non
x ^ y # bit à bit
Bitwise AND
L'opérateur & exécutera un AND binaire, où un bit est copié s'il existe dans les deux opérandes. Cela signifie:
# 0 & 0 = 0
# 0 & 1 = 0
# 1 & 0 = 0
# 1 & 1 = 1
# 60 = 0b111100
# 30 = 0b011110
60 & 30
# Out: 28
# 28 = 0b11100
bin(60 & 30)
# Out: 0b11100
Bit à bit OU
Le | l'opérateur effectuera un "ou" binaire où un bit est copié s'il existe dans l'un des opérandes. Cela signifie:
# 0 | 0 = 0
# 0 | 1 = 1
# 1 | 0 = 1
# 1 | 1 = 1
# 60 = 0b111100
# 30 = 0b011110
60 | 30
# Out: 62
# 62 = 0b111110
bin(60 | 30)
# Out: 0b111110
Bit à bit XOR (OU exclusif)
L'opérateur ^ exécutera un XOR binaire dans lequel un binaire 1 est copié si et seulement si c'est la valeur de exactement un opérande. Une autre manière de dire ceci est que le résultat est 1 seulement si les opérandes sont différents. Les exemples comprennent:
# 0 ^ 0 = 0
# 0 ^ 1 = 1
# 1 ^ 0 = 1
# 1 ^ 1 = 0
# 60 = 0b111100
# 30 = 0b011110
60 ^ 30
# Out: 34
# 34 = 0b100010
bin(60 ^ 30)
# Out: 0b100010
Décalage bit à gauche
L'opérateur << effectuera un "décalage vers la gauche" au niveau du bit, la valeur de l'opérande gauche étant déplacée par le nombre de bits fournis par l'opérande droit.
# 2 = 0b10
2 << 2
# Out: 8
# 8 = 0b1000
bin(2 << 2)
# Out: 0b1000
L'exécution d'un décalage de 1 gauche équivaut à une multiplication par 2 :
7 << 1
# Out: 14
Effectuer un décalage de n de gauche équivaut à une multiplication par 2**n :
3 << 4
# Out: 48
Changement bit à bit droit
L'opérateur >> effectuera un "décalage à droite" au niveau du bit, où la valeur de l'opérande gauche est déplacée vers la droite par le nombre de bits fournis par l'opérande droit.
# 8 = 0b1000
8 >> 2
# Out: 2
# 2 = 0b10
bin(8 >> 2)
# Out: 0b10
L'exécution d'un décalage de 1 droite équivaut à une division entière par 2 :
36 >> 1
# Out: 18
15 >> 1
# Out: 7
Effectuer un décalage de bit droit de n est équivalent à une division entière de 2**n :
48 >> 4
# Out: 3
59 >> 3
# Out: 7
Pas au bit
L'opérateur ~ retournera tous les bits du numéro. Puisque les ordinateurs utilisent des représentations de nombres signés - plus particulièrement, la notation de complément à deux pour encoder des nombres binaires négatifs où les nombres négatifs sont écrits avec un premier (1) au lieu d'un zéro initial (0).
Cela signifie que si vous utilisiez 8 bits pour représenter vos deux nombres complémentaires, vous traiteriez les modèles de 0000 0000 à 0111 1111 pour représenter les nombres de 0 à 127 et réserver 1xxx xxxx pour représenter les nombres négatifs.
Les nombres de complément à deux bits de huit bits
| Morceaux | Valeur non signée | Valeur du complément à deux |
|---|---|---|
| 0000 0000 | 0 | 0 |
| 0000 0001 | 1 | 1 |
| 0000 0010 | 2 | 2 |
| 0111 1110 | 126 | 126 |
| 0111 1111 | 127 | 127 |
| 1000 0000 | 128 | -128 |
| 1000 0001 | 129 | -127 |
| 1000 0010 | 130 | -126 |
| 1111 1110 | 254 | -2 |
| 1111 1111 | 255 | -1 |
Essentiellement, cela signifie que 1010 0110 a une valeur non signée de 166 (obtenue en ajoutant (128 * 1) + (64 * 0) + (32 * 1) + (16 * 0) + (8 * 0) + (4 * 1) + (2 * 1) + (1 * 0) ), il a une valeur de complément à deux de -90 (obtenue en ajoutant (128 * 1) - (64 * 0) - (32 * 1) - (16 * 0) - (8 * 0) - (4 * 1) - (2 * 1) - (1 * 0) , et en complément de la valeur).
De cette manière, les nombres négatifs sont réduits à -128 ( 1000 0000 ). Zéro (0) est représenté par 0000 0000 et moins un (-1) que 1111 1111 .
En général, cependant, cela signifie ~n = -n - 1 .
# 0 = 0b0000 0000
~0
# Out: -1
# -1 = 0b1111 1111
# 1 = 0b0000 0001
~1
# Out: -2
# -2 = 1111 1110
# 2 = 0b0000 0010
~2
# Out: -3
# -3 = 0b1111 1101
# 123 = 0b0111 1011
~123
# Out: -124
# -124 = 0b1000 0100
Notez que l'effet global de cette opération, appliqué aux nombres positifs, peut être résumé:
~n -> -|n+1|
Et puis, appliqué aux nombres négatifs, l'effet correspondant est:
~-n -> |n-1|
Les exemples suivants illustrent cette dernière règle ...
# -0 = 0b0000 0000
~-0
# Out: -1
# -1 = 0b1111 1111
# 0 is the obvious exception to this rule, as -0 == 0 always
# -1 = 0b1000 0001
~-1
# Out: 0
# 0 = 0b0000 0000
# -2 = 0b1111 1110
~-2
# Out: 1
# 1 = 0b0000 0001
# -123 = 0b1111 1011
~-123
# Out: 122
# 122 = 0b0111 1010
Opérations en place
Tous les opérateurs Bitwise (sauf ~ ) ont leurs propres versions
a = 0b001
a &= 0b010
# a = 0b000
a = 0b001
a |= 0b010
# a = 0b011
a = 0b001
a <<= 2
# a = 0b100
a = 0b100
a >>= 2
# a = 0b001
a = 0b101
a ^= 0b011
# a = 0b110