Que fait l'opérateur caret (^) ?

Question

Je suis tombé sur l'opérateur caret en python aujourd'hui et en l'essayant, j'ai obtenu le résultat suivant :

>>> 8^3
11
>>> 8^4
12
>>> 8^1
9
>>> 8^0
8
>>> 7^1
6
>>> 7^2
5
>>> 7^7
0
>>> 7^8
15
>>> 9^1
8
>>> 16^1
17
>>> 15^1
14
>>>

Il semble être basé sur 8, donc je suppose qu'il s'agit d'une sorte d'opération sur les octets ? Je n'arrive pas à trouver grand chose à propos de cet opérateur sur les sites de recherche, si ce n'est qu'il se comporte bizarrement pour les flottants. Quelqu'un a-t-il un lien vers ce que fait cet opérateur ou pouvez-vous l'expliquer ici ?

Answer 1

Il s'agit d'un bitwise XOR (OU exclusif).

Il est évalué à True si et seulement si ses arguments diffèrent (l'un est True l'autre est False ).

A démontrer :

>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1

Expliquer un de vos propres exemples :

>>> 8^3
11

Pensez-y de la manière suivante :

1000  # 8 (binary)
0011  # 3 (binary)
----  # APPLY XOR ('vertically')
1011  # result = 11 (binary)

Answer 2

Il invoque le __xor__() o __rxor__() de l'objet si nécessaire, ce qui, pour les types entiers, permet d'effectuer un OU exclusif dans le sens des bits.

Answer 3

Il s'agit d'un ou exclusif bit par bit. Les opérateurs binaires bit à bit sont documentés dans chapitre 5 de la référence au langage Python .

Answer 4

D'une manière générale, le symbole ^ es un infixe de la version __xor__ o __rxor__ des méthodes. Les types de données placés à droite et à gauche du symbole doivent implémenter cette fonction de manière compatible. Pour les entiers, il s'agit de la fonction commune XOR mais, par exemple, il n'existe pas de définition intégrée de la fonction pour le type float avec type int :

In [12]: 3 ^ 4
Out[12]: 7

In [13]: 3.3 ^ 4
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-13-858cc886783d> in <module>()
----> 1 3.3 ^ 4

TypeError: unsupported operand type(s) for ^: 'float' and 'int'

Ce qui est intéressant avec Python, c'est que vous pouvez remplacer ce comportement dans une classe de votre choix. Par exemple, dans certains langages, la classe ^ signifie exponentiation. Vous pouvez le faire de cette manière, à titre d'exemple :

class Foo(float):
    def __xor__(self, other):
        return self ** other

Alors, quelque chose comme ceci fonctionnera, et maintenant, pour les instances de Foo seulement , le ^ signifie qu'il s'agit d'une exponentiation.

In [16]: x = Foo(3)

In [17]: x
Out[17]: 3.0

In [18]: x ^ 4
Out[18]: 81.0

Answer 5

Lorsque vous utilisez la fonction ^ l'opérateur, derrière les rideaux, la méthode __xor__ est appelé.

a^b est équivalent à a.__xor__(b) .

En outre, a ^= b est équivalent à a = a.__ixor__(b) (où __xor__ est utilisé comme solution de repli lorsque __ixor__ est implicitement appelé via l'utilisation de ^= mais n'existe pas).

En principe, ce que __xor__ dépend entièrement de sa mise en œuvre. Les cas d'utilisation courants en Python sont les suivants :

• Différence symétrique d'ensembles (tous les éléments présents dans exactement un des deux ensembles)

Démonstration :

>>> a = {1, 2, 3}
>>> b = {1, 4, 5}
>>> a^b
{2, 3, 4, 5}
>>> a.symmetric_difference(b)
{2, 3, 4, 5}

• Non-égalité binaire pour les bits de deux entiers

Démonstration :

>>> a = 5
>>> b = 6
>>> a^b
3

Explication :

    101 (5 decimal)
XOR 110 (6 decimal)
-------------------
    011 (3 decimal)