XOR en Python

XOR, ou OU exclusif, compare deux valeurs et est vrai lorsqu’une seule d’entre elles est vraie. En Python, l’opérateur ^ effectue un XOR sur les entiers et les booléens. Utilisez-le lorsque vous avez besoin de l’une des deux valeurs, mais pas des deux, ou lorsque vous devez comparer directement des bits.

Qu’est-ce que le XOR ?

Le XOR compare deux bits et renvoie 1 lorsqu’ils sont différents, et 0 lorsqu’ils sont identiques :

• 0 XOR 0 = 0
• 0 XOR 1 = 1
• 1 XOR 0 = 1
• 1 XOR 1 = 0

La même règle s’applique aux valeurs booléennes : une seule valeur True produit True. Pour les entiers, Python applique cette règle indépendamment à chaque paire de bits. Le XOR booléen et le XOR bit à bit sont donc liés, mais répondent à des besoins différents.

Utiliser le XOR avec des entiers

Utilisez l’opérateur ^ pour calculer le XOR bit à bit de deux entiers :

a = 5  # Binary: 0101
b = 3  # Binary: 0011

result = a ^ b
print(result)

6

La représentation binaire de 5 est 0101, et celle de 3 est 0011. La comparaison des bits correspondants donne :

• 0 XOR 0 = 0
• 1 XOR 0 = 1
• 0 XOR 1 = 1
• 1 XOR 1 = 0

Le résultat est 0110, soit 6 en notation décimale. Le zéro initial sert uniquement à aligner les deux opérandes ; il ne modifie pas la valeur représentée.

Utiliser le XOR avec des booléens

Python applique également ^ aux valeurs booléennes. Le programme suivant présente les quatre combinaisons d’entrées ainsi qu’une implémentation orientée booléens, construite avec and, or et not :

def xor(left, right):
    return (left and not right) or (not left and right)

for left, right in ((False, False), (False, True), (True, False), (True, True)):
    print(f"{left} ^ {right} -> {left ^ right}; xor() -> {xor(left, right)}")

False ^ False -> False; xor() -> False
False ^ True -> True; xor() -> True
True ^ False -> True; xor() -> True
True ^ True -> False; xor() -> False

Cette fonction est utile lorsqu’une expression booléenne doit exprimer une opération nommée. Pour des entrées booléennes, left ^ right et xor(left, right) produisent les quatre mêmes résultats. La forme logique est destinée aux conditions booléennes ; utilisez ^ pour manipuler les bits d’entiers.

Applications pratiques du XOR

Le module operator expose la même opération sous forme de fonction xor(). Cette forme peut être pratique lorsqu’un objet fonction est nécessaire, et elle fonctionne aussi bien avec des opérandes booléens qu’avec des opérandes entiers :

from operator import xor

print(xor(True, False))
print(xor(5, 3))

True
6

Une autre technique bit à bit bien connue permet d’échanger deux variables entières sans variable temporaire :

x = 10
y = 20

x = x ^ y
y = x ^ y
x = x ^ y

print(x, y)

20 10

Avec deux entiers comme valeurs initiales, les trois opérations se déroulent ainsi :

1. x devient le XOR de x et y.
2. y est ensuite mis à jour pour prendre la valeur initiale de x, en effectuant un XOR entre le nouveau x et y.
3. Enfin, x est mis à jour pour prendre la valeur initiale de y, selon la même logique.

Cette technique est correcte pour les variables entières, mais le code Python courant est généralement plus clair avec une affectation par déballage d’un tuple : x, y = y, x. La forme utilisant le XOR sert surtout à comprendre les opérations bit à bit ou lorsqu’une contrainte impose précisément cette technique.

Conclusion

En Python, utilisez ^ pour effectuer un XOR : cet opérateur compare directement les valeurs booléennes et compare chaque bit lorsque ses opérandes sont des entiers. La fonction operator.xor() fournit la même opération sous forme de fonction, tandis que and, or et not permettent d’exprimer explicitement la règle booléenne. Choisissez la forme qui indique le mieux si votre tâche est logique ou bit à bit.

FAQ

1. Que signifie XOR en Python ?
   XOR signifie « OU exclusif » : le résultat est vrai lorsqu’une seule des deux entrées est vraie. Avec des opérandes entiers, cette règle est appliquée à chaque paire de bits correspondants.

2. Comment effectuer une opération XOR sur deux entiers en Python ?
   Utilisez l’opérateur ^ : result = a ^ b.

3. Puis-je utiliser le XOR avec des valeurs booléennes en Python ?
   Oui. True ^ False et False ^ True valent True, tandis que deux entrées booléennes identiques produisent False.

4. Quelle est une application pratique du XOR en programmation ?
   Le XOR peut échanger deux variables entières au moyen de trois opérations bit à bit. Dans le code Python courant, le déballage de tuple est généralement plus clair.

5. Le XOR est-il commutatif en Python ?
   Oui. Le XOR est commutatif : a ^ b est égal à b ^ a pour des opérandes compatibles.