Python Bitwise Operators

Python Bitwise Operators werden verwendet, um Bitwise Berechnungen an Ganzzahlen durchzuführen. Die Ganzzahlen werden in das Binärformat konvertiert und dann werden Operationen Bit für Bit durchgeführt, daher der Name Bitwise Operators. Python Bitwise Operators funktionieren nur mit Ganzzahlen und der finale Output wird im Dezimalformat zurückgegeben. Python Bitwise Operators werden auch binäre Operators genannt.

Arten von Python Bitwisen Operators

Es gibt 6 Bitwise Operators in Python. Die folgende Tabelle bietet kurze Details über sie.

Lassen Sie uns diese Operators einzeln anschauen und verstehen, wie sie funktionieren.

1. Bitwiser AND-Operator

Der Bitwise AND-Operator in Python gibt 1 zurück, wenn beide Bits 1 sind, andernfalls 0.

>>> 10&7
2
>>>

2. Bitwiser OR-Operator

Der Bitwise OR-Operator in Python gibt 1 zurück, wenn eines der Bits 1 ist. Sind beide Bits 0, dann gibt er 0 zurück.

>>> 10|7
15
>>>

3. Bitwiser XOR-Operator

Der Bitwise XOR-Operator in Python gibt 1 zurück, wenn eines der Bits 0 und das andere Bit 1 ist. Sind beide Bits 0 oder 1, dann gibt er 0 zurück.

>>> 10^7
13
>>>

4. Bitwiser Ones’ Complement Operator

Der Ones’ Complement eines Zahlenwertes ‘A’ in Python ist gleich -(A+1).

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

5. Bitwiser Left Shift Operator

Der Bitwise Left Shift Operator in Python verschiebt die Bits des linken Operanden nach links um die angegebene Anzahl von Malen des rechten Operanden. Einfach ausgedrückt wird die Binärzahl am Ende mit 0en ergänzt.

>>> 10 << 2
40
>>>

6. Bitwiser Right Shift Operator

Der Bitwise Right Shift Operator in Python ist genau das Gegenteil des Left Shift Operators. Die Bits des linken Operanden werden nach rechts um die angegebene Anzahl von Malen verschoben. Einfach ausgedrückt werden die rechten Bits entfernt.

>>> 10 >> 2
2
>>>

Python Bitwise Operator-Überladung

Python unterstützt Operator-Überladung. Es gibt verschiedene Methoden, die wir implementieren können, um Bitwise Operators für unsere benutzerdefinierten Objekte zu unterstützen.

Hier ist ein Beispiel für eine Operator-Überladung eines Bitwisen Operators für unser benutzerdefiniertes Objekt.

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]

Zusammenfassung

Python Bitwise Operators werden meistens in mathematischen Berechnungen verwendet. Wir können spezifische Methoden implementieren, um Bitwise Operators auch für unsere benutzerdefinierten Klassenimplementierungen zu unterstützen.