Cosa fa l'operatore caret (^) in Python?

Oggi mi sono imbattuto nell'operatore caret in Python e provandolo, ho ottenuto il seguente output:

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

Sembra essere basato su 8, quindi immagino una sorta di operazione sui byte? Non riesco a trovare molto su questo sito di ricerca diverso da quello che si comporta in modo strano per i float, qualcuno ha un collegamento a ciò che fa questo operatore o puoi spiegarlo qui?

È uno XOR bit per bit (OR esclusivo).

Risulta vero se uno (e solo uno) degli operandi (restituisce) vero.

Dimostrare:

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

Per spiegare uno dei tuoi esempi:

>>> 8^3
11

Pensaci in questo modo:

1000 # 8 (binario)
0011 # 3 (binario)
---- # APPLICA XOR ('verticalmente')
1011 # risultato = 11 (binario)

Richiama il metodo __xor__()or __rxor__()dell'oggetto secondo necessità, che per i tipi interi esegue un'esclusiva or bit per bit.

È un po 'per volta esclusivo. Gli operatori binari bit per bit sono documentati nel capitolo 5 del Python Language Reference .

In generale, il simbolo ^è una versione infissa dei metodi __xor__o __rxor__. Qualunque tipo di dato sia posizionato a destra ea sinistra del simbolo deve implementare questa funzione in modo compatibile. Per gli interi, è l' XORoperazione comune , ma ad esempio non esiste una definizione incorporata della funzione per il 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 interessante di Python è che puoi sovrascrivere questo comportamento in una tua classe. Ad esempio, in alcune lingue il ^simbolo significa esponenziazione. Puoi farlo in questo modo, proprio come un esempio:

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

Poi qualcosa di simile a questo lavoro, e ora, per le istanze di Foosolo , la^ simbolo significherà elevamento a potenza.

In [16]: x = Foo(3)

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

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

Quando usi l' ^operatore, dietro le quinte __xor__viene chiamato il metodo .

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

Inoltre, a ^= bè equivalente a a = a.__ixor__(b)(dove __xor__viene utilizzato come fallback quando __ixor__viene chiamato implicitamente tramite using^= ma non esiste).

In linea di principio, ciò che __xor__fa dipende completamente dalla sua attuazione. I casi d'uso comuni in Python sono:

• Differenza simmetrica di insiemi (tutti gli elementi presenti esattamente in uno di due insiemi)

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 uguale per i bit di due numeri interi

demo:

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

Spiegazione:

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