Python Bitwise Operatoren

Python bitgewijze operatoren worden gebruikt voor het uitvoeren van bitgewijze berekeningen op gehele getallen. De getallen worden omgezet naar binaire formaat en vervolgens worden bewerkingen bit voor bit uitgevoerd, vandaar de naam bitgewijze operatoren. Python bitgewijze operatoren werken alleen op gehele getallen en de uiteindelijke uitvoer wordt weergegeven in decimale notatie. Python bitgewijze operatoren worden ook wel binaire operatoren genoemd.

Python Bitwise Operators

Er zijn 6 bitgewijze operatoren in Python. De onderstaande tabel geeft korte details over hen.

Laten we deze operatoren één voor één bekijken en begrijpen hoe ze werken.

1. Bitgewijze EN-operator

Python bitgewijze en-operator geeft 1 terug als beide bits 1 zijn, anders 0.

>>> 10&7
2
>>> 

2. Bitgewijze OF-operator

Python bitgewijze of-operator geeft 1 terug als een van de bits 1 is. Als beide bits 0 zijn, geeft het 0 terug.

>>> 10|7
15
>>> 

3. Bitwijze XOR-operator

De bitwijze XOR-operator in Python geeft 1 terug als één van de bits 0 is en de andere bit 1 is. Als beide bits 0 of 1 zijn, geeft het 0 terug.

>>> 10^7
13
>>> 

4. Bitwijze complementeer-operator

De complementeer-operator van een getal ‘A’ in Python is gelijk aan -(A+1).

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

5. Bitwijze linksverschuivingsoperator

De bitwijze linksverschuivingsoperator in Python verschuift de bits van het linker operand naar links voor het opgegeven aantal keren in het rechter operand. In eenvoudige bewoordingen wordt het binaire getal aangevuld met 0’en aan het einde.

>>> 10 << 2
40
>>> 

6. Bitwijze rechtsverschuivingsoperator

De rechtsverschuivingsoperator van Python is precies het tegenovergestelde van de linksverschuivingsoperator. Dan worden de bits van de linkerkantoperand naar de rechterkant verplaatst voor het opgegeven aantal keren. In eenvoudige bewoordingen worden de bits aan de rechterkant verwijderd.

>>> 10 >> 2
2
>>>  

Overbelasting van de bitgewijze operator in Python

Python ondersteunt operatoroverbelasting. Er zijn verschillende methoden die we kunnen implementeren om bitgewijze operatoren te ondersteunen voor onze aangepaste objecten.

Hier is een voorbeeld van overbelasting van een bitgewijze operator voor ons aangepaste object.

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]

Als u niet bekend bent met de nieuwe string formattering, lees dan f-strings in Python.

Samenvatting

Bitgewijze operatoren in Python worden voornamelijk gebruikt in wiskundige berekeningen. We kunnen specifieke methoden implementeren om bitgewijze operatoren te ondersteunen voor onze aangepaste klassenimplementaties ook.