Les opérations binaires, ou opérations bit-à-bit, permettent d'interagir directement avec les représentations binaires des nombres dans la mémoire d'un ordinateur. Bien qu'elles soient moins fréquentes dans la logique métier quotidienne, leur maîtrise est essentielle pour des tâches spécifiques comme la gestion des permissions, l'optimisation des performances, le traitement d'images, ou certains algorithmes cryptographiques.

Dans un système informatique, chaque nombre est stocké sous forme de séquence de bits (0 et 1). Python offre la fonction intégrée bin() pour visualiser cette représentation binaire.

valeur_a = 5  # 0b101
valeur_b = 3  # 0b011
print(f"Binaire de {valeur_a}: {bin(valeur_a)}")
print(f"Binaire de {valeur_b}: {bin(valeur_b)}")

Opérateur ET Binaire (&)

L'opérateur ET binaire compare bit à bit deux nombres. Le bit résultant est 1 uniquement si les deux bits correspondants sont 1. Autrement, le bit résultant est 0.

• 1 & 1 = 1
• 1 & 0 = 0
• 0 & 0 = 0

nombre1 = 6  # Binaire : 0110
nombre2 = 3  # Binaire : 0011
resultat = nombre1 & nombre2
print(f"{nombre1} & {nombre2} = {resultat}")

Démonstration binaire :

 0110  (6)
& 0011  (3)
-----
 0010  (2)

Opérateur OU Binaire (|)

L'opérateur OU binaire compare bit à bit deux nombres. Le bit résultant est 1 si au moins un des deux bits correspondants est 1. Autrement, le bit résultant est 0.

• 1 | 1 = 1
• 1 | 0 = 1
• 0 | 0 = 0

nombre1 = 6  # Binaire : 0110
nombre2 = 3  # Binaire : 0011
resultat = nombre1 | nombre2
print(f"{nombre1} | {nombre2} = {resultat}")

Démonstration binaire :

 0110  (6)
| 0011  (3)
-----
 0111  (7)

Opérateur NON Binaire (~)

L'opérateur NON binaire inverse chaque bit d'un nombre : les 0 deviennent 1 et les 1 deviennent 0. En Python, qui utilise des entiers signés, l'opération ~x est équivalente à -(x + 1).

valeur_numerique = 7 # Binaire : ...00000111
resultat_non = ~valeur_numerique
print(f"~{valeur_numerique} = {resultat_non}")

Démonstration binaire pour un entier 8 bits (simplifié) :

0000 0111 (7)
----------
1111 1000 (-8 en complément à deux)

Opérateur OU Exclusif (XOR) Binaire (^)

L'opérateur OU Exclusif (XOR) compare bit à bit deux nombres. Le bit résultant est 1 si les deux bits correspondants sont différents. Il est 0 si les bits sont identiques.

• 1 ^ 1 = 0
• 1 ^ 0 = 1
• 0 ^ 0 = 0

Propriétés clés :

• Tout nombre XOR 0 donne le nombre lui-même : x ^ 0 = x
• Tout nombre XOR lui-même donne 0 : x ^ x = 0
• Commutativité et Associativité : (a ^ b) ^ c = a ^ (b ^ c)

valeur_x = 6  # Binaire : 0110
valeur_y = 3  # Binaire : 0011
resultat_xor = valeur_x ^ valeur_y
print(f"{valeur_x} ^ {valeur_y} = {resultat_xor}")

# Démonstration des propriétés
print(f"10 ^ 0 = {10 ^ 0}")
print(f"10 ^ 10 = {10 ^ 10}")

Démonstration binaire :

 0110  (6)
^ 0011  (3)
-----
 0101  (5)

Décalage à Gauche (<<)

L'opérateur de décalage à gauche déplace les bits d'un nombre vers la gauche d'un certain nombre de positinos. Les positions vides à droite sont remplies par des zéros. Cette opération est équivalente à multiplier le nombre par 2 élevé à la puissance du nombre de décalages (x * 2ⁿ).

chiffre = 3  # Binaire : 0011
decalage = 2
resultat_gauche = chiffre << decalage
print(f"{chiffre} << {decalage} = {resultat_gauche}")

Démonstration binaire :

0011 (3)
Décalage de 2 positions vers la gauche :
1100 (12)

Décalage à Droite (>>)

L'opérateur de décalage à droite déplace les bits d'un nombre vers la droite d'un certain nombre de positions. Pour les nombres positifs, les positions vides à gauche sont remplies par des zéros. Pour les nombres négatifs, les systèmes utilisent souvent le bit de signe (décalage arithmétique). Cette opération est équivalente à une division entière par 2 élevé à la puissance du nombre de décalages (x // 2ⁿ).

nombre_initial = 12
print(f"{nombre_initial} >> 1 = {nombre_initial >> 1}")
print(f"{nombre_initial} >> 2 = {nombre_initial >> 2}")

valeur_entier = 15
print(f"{valeur_entier} >> 1 = {valeur_entier >> 1}")

valeur_negative = -10
print(f"{valeur_negative} >> 1 = {valeur_negative >> 1}")

Récapitulatif des Opérateurs Binaires

Voici un tableau récpaitulatif des opérations bit-à-bit couramment utilisées :