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]

Fehlerbehandlung bei bitweisen Operatoren in Python

Bei der Arbeit mit bitweisen Operatoren in Python können verschiedene Fehler auftreten, die die Funktionalität Ihres Codes beeinträchtigen. Eine sorgfältige Fehlerbehandlung ist daher unerlässlich, um die Robustheit und Zuverlässigkeit Ihrer Programme sicherzustellen.

Häufige Fehlerquellen:

1. Falsche Operanden-Typen: Bitweise Operatoren erwarten Ganzzahlen als Operanden. Wenn stattdessen andere Datentypen wie Fließkommazahlen oder Zeichenketten verwendet werden, führt dies zu einem TypeError.
2. Überlauf bei Verschiebungsoperationen: Bei Links- oder Rechtsschiebungen kann es zu Überläufen kommen, wenn die Anzahl der Verschiebungsstellen größer ist als die Bitlänge des Operanden.
3. Unbeabsichtigte negative Ergebnisse: Die Verwendung des bitweisen NOT-Operators (~) kann zu negativen Zahlen führen, da er alle Bits invertiert und das Vorzeichenbit umkehrt.

Empfehlungen zur Fehlervermeidung:

• Typprüfung: Stellen Sie sicher, dass die Operanden die erwarteten Datentypen haben, bevor Sie bitweise Operationen durchführen. Verwenden Sie dazu die Funktion isinstance().
• Grenzwerte beachten: Achten Sie bei Verschiebungsoperationen darauf, dass die Anzahl der Verschiebungsstellen innerhalb des gültigen Bereichs liegt, um Überläufe zu vermeiden.
• Ergebnisse überprüfen: Nach der Anwendung von bitweisen Operatoren sollten Sie die Ergebnisse auf Plausibilität prüfen, insbesondere wenn negative Werte unerwünscht sind.

Beispiel für eine Fehlerbehandlung:

def sichere_bitweise_und(a, b):

if not isinstance(a, int) or not isinstance(b, int):

raise TypeError(„Beide Operanden müssen Ganzzahlen sein.“)

return a & b
try:

ergebnis = sichere_bitweise_und(10, ‚7‘)

except TypeError as e:

print(f“Fehler: {e}“)

In diesem Beispiel wird vor der Durchführung der bitweisen UND-Operation überprüft, ob beide Operanden Ganzzahlen sind. Andernfalls wird ein TypeError ausgelöst, der im try-except-Block abgefangen und entsprechend behandelt wird.

Durch die Implementierung solcher Prüfungen und die sorgfältige Handhabung potenzieller Fehlerquellen können Sie die Zuverlässigkeit und Stabilität Ihrer Python-Programme verbessern.

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.