Operatori bitwise di Python

Gli operatori bitwise di Python vengono utilizzati per eseguire calcoli bitwise su interi. Gli interi vengono convertiti nel formato binario e poi le operazioni vengono eseguite bit per bit, da qui il nome operatori bitwise. Gli operatori bitwise di Python funzionano solo su interi e l’output finale viene restituito nel formato decimale. Gli operatori bitwise di Python sono anche chiamati operatori binari.

Operatori Bitwise di Python

Ci sono 6 operatori bitwise in Python. La tabella sottostante fornisce brevi dettagli su di essi.

Esaminiamo questi operatori uno per uno e capiamo come funzionano.

1. Operatore AND Bitwise

L’operatore and bitwise di Python restituisce 1 se entrambi i bit sono 1, altrimenti 0.

>>> 10&7
2
>>> 

2. Operatore OR Bitwise

L’operatore or bitwise di Python restituisce 1 se uno qualsiasi dei bit è 1. Se entrambi i bit sono 0, restituisce 0.

>>> 10|7
15
>>> 

3. Operatore XOR bit a bit

L’operatore XOR bit a bit di Python restituisce 1 se uno dei bit è 0 e l’altro bit è 1. Se entrambi i bit sono 0 o 1, restituisce 0.

>>> 10^7
13
>>> 

4. Operatore di complemento a uno bit a bit

Il complemento a uno di un numero ‘A’ in Python è uguale a -(A+1).

>>> ~10
-11
>>> ~-10
9
>>> 

5. Operatore di spostamento bit a sinistra

L’operatore di spostamento bit a sinistra di Python sposta i bit dell’operando sinistro verso sinistra per il numero di volte specificato nell’operando destro. In termini semplici, il numero binario viene esteso con 0 alla fine.

>>> 10 << 2
40
>>> 

6. Operatore di spostamento bit a destra

L’operatore di spostamento a destra di Python è esattamente l’opposto dell’operatore di spostamento a sinistra. Quindi i bit del lato sinistro dell’operando vengono spostati verso il lato destro per il numero dato di volte. In termini semplici, i bit del lato destro vengono rimossi.

>>> 10 >> 2
2
>>>  

Sovraccarico degli operatori bitwise in Python

Python supporta il sovraccarico degli operatori. Ci sono vari metodi che possiamo implementare per supportare gli operatori bitwise per i nostri oggetti personalizzati.

Ecco un esempio di sovraccarico dell’operatore bitwise per il nostro oggetto personalizzato.

class Data:
    id = 0

    def __init__(self, i):
        self.id = i

    def __and__(self, other):
        print('Bitwise AND operator overloaded')
        if isinstance(other, Data):
            return Data(self.id & other.id)
        else:
            raise ValueError('Argument must be object of Data')

    def __or__(self, other):
        print('Bitwise OR operator overloaded')
        if isinstance(other, Data):
            return Data(self.id | other.id)
        else:
            raise ValueError('Argument must be object of Data')

    def __xor__(self, other):
        print('Bitwise XOR operator overloaded')
        if isinstance(other, Data):
            return Data(self.id ^ other.id)
        else:
            raise ValueError('Argument must be object of Data')

    def __lshift__(self, other):
        print('Bitwise Left Shift operator overloaded')
        if isinstance(other, int):
            return Data(self.id << other)
        else:
            raise ValueError('Argument must be integer')

    def __rshift__(self, other):
        print('Bitwise Right Shift operator overloaded')
        if isinstance(other, int):
            return Data(self.id >> other)
        else:
            raise ValueError('Argument must be integer')

    def __invert__(self):
        print('Bitwise Ones Complement operator overloaded')
        return Data(~self.id)

    def __str__(self):
        return f'Data[{self.id}]'


d1 = Data(10)
d2 = Data(7)

print(f'd1&d2 = {d1&d2}')
print(f'd1|d2 = {d1|d2}')
print(f'd1^d2 = {d1^d2}')
print(f'd1<<2 = {d1<<2}')
print(f'd1>>2 = {d1>>2}')
print(f'~d1 = {~d1}')

Output:

Bitwise AND operator overloaded
d1&d2 = Data[2]
Bitwise OR operator overloaded
d1|d2 = Data[15]
Bitwise XOR operator overloaded
d1^d2 = Data[13]
Bitwise Left Shift operator overloaded
d1<<2 = Data[40]
Bitwise Right Shift operator overloaded
d1>>2 = Data[2]
Bitwise Ones Complement operator overloaded
~d1 = Data[-11]

Se non sei familiare con la nuova formattazione delle stringhe, leggi le f-string in Python.

Riepilogo

Gli operatori bitwise di Python sono principalmente utilizzati in calcoli matematici. Possiamo implementare metodi specifici per supportare gli operatori bitwise anche per le implementazioni delle nostre classi personalizzate.