O que o operador circunflexo (^) em Python faz?

Encontrei o operador circunflexo em python hoje e, ao experimentá-lo, obtive a seguinte saída:

>>> 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 ser baseado em 8, então estou supondo que algum tipo de operação de byte? Não consigo encontrar muito sobre esses sites de busca, exceto se ele se comporta de forma estranha para flutuadores, alguém tem um link para o que este operador faz ou você pode explicar isso aqui?

É um XOR bit a bit (OU exclusivo).

Resulta verdadeiro se um (e apenas um) dos operandos (avalia como) verdadeiro.

Para demonstrar:

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

Para explicar um de seus próprios exemplos:

>>> 8^3
11

Pense nisso desta maneira:

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

Ele invoca o método __xor__()ou __rxor__()do objeto conforme necessário, que para tipos inteiros faz um ou exclusivo bit a bit.

É um pouco exclusivo - ou. Operadores binários bit a bit são documentados no capítulo 5 da Referência de linguagem Python .

De um modo geral, o símbolo ^é uma versão infixa dos métodos __xor__ou __rxor__. Quaisquer tipos de dados colocados à direita e à esquerda do símbolo devem implementar essa função de maneira compatível. Para inteiros, é a XORoperação comum , mas por exemplo não há uma definição embutida da função para tipo floatcom 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'

Uma coisa legal sobre Python é que você pode sobrescrever esse comportamento em uma classe própria. Por exemplo, em alguns idiomas, o ^símbolo significa exponenciação. Você poderia fazer isso desta forma, apenas como um exemplo:

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

Em seguida, algo como isso vai funcionar, e agora, para instâncias de Fooúnica , o ^símbolo significa exponenciação.

In [16]: x = Foo(3)

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

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

Quando você usa o ^operador, nos bastidores, o método __xor__é chamado.

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

Além disso, a ^= bé equivalente a a = a.__ixor__(b)(onde __xor__é usado como substituto quando __ixor__é implicitamente chamado por meio de^= mas não existe).

Em princípio, __xor__depende totalmente de sua implementação. Casos de uso comuns em Python são:

• Diferença simétrica de conjuntos (todos os elementos presentes em exatamente um dos dois conjuntos)

Demo:

>>> 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 os bits de dois inteiros

Demo:

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

Explicação:

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