¿Qué hace el operador de intercalación (^) en Python?

Me encontré con el operador de intercalación en python hoy y, al probarlo, obtuve el siguiente resultado:

>>> 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
>>>

Parece estar basado en 8, así que supongo que es algún tipo de operación de byte. Parece que no puedo encontrar mucho sobre estos sitios de búsqueda aparte de que se comporta de manera extraña para los flotadores, ¿alguien tiene un enlace a lo que hace este operador o puede explicarlo aquí?

Es un XOR bit a bit (OR exclusivo).

Resulta verdadero si uno (y solo uno) de los operandos (se evalúa como) verdadero.

Demostrar:

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

Para explicar uno de sus propios ejemplos:

>>> 8^3
11

Piensa en ello de esta manera:

1000 # 8 (binario)
0011 # 3 (binario)
---- # APLICAR XOR ('verticalmente')
1011 # resultado = 11 (binario)

Invoca el método __xor__()o __rxor__()del objeto según sea necesario, que para los tipos enteros hace un exclusivo-or bit a bit.

Es un poco exclusivo-o. Los operadores binarios bit a bit están documentados en el capítulo 5 de la Referencia del lenguaje Python .

En términos generales, el símbolo ^es una versión infija de los métodos __xor__o __rxor__. Cualquier tipo de datos que se coloque a la derecha e izquierda del símbolo debe implementar esta función de una manera compatible. Para enteros, es la XORoperación común , pero por ejemplo, no hay una definición incorporada de la función para el tipo floatcon tipo 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'

Una cosa interesante de Python es que puede anular este comportamiento en una clase propia. Por ejemplo, en algunos idiomas, el ^símbolo significa exponenciación. Puede hacerlo de esta manera, solo como un ejemplo:

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

Entonces algo como esto va a funcionar, y ahora, para casos de Fooúnica , el ^símbolo significa exponenciación.

In [16]: x = Foo(3)

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

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

Cuando usa el ^operador, detrás de las cortinas __xor__se llama al método .

a^bes equivalente a a.__xor__(b).

Además, a ^= bes equivalente a a = a.__ixor__(b)(donde __xor__se usa como respaldo cuando __ixor__se llama implícitamente mediante using ^=pero no existe).

En principio, lo que __xor__hace depende completamente de su implementación. Los casos de uso comunes en Python son:

• Diferencia simétrica de conjuntos (todos los elementos presentes en exactamente uno de dos conjuntos)

Manifestación:

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

• Bitwise Non-Equal para los bits de dos enteros

Manifestación:

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

Explicación:

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