Detaillierte Erklärung der bitweisen Python-Operatoren

Die Python-Bitoperation basiert auf dem Binärbit (Bit) der Daten im Speicher und wird im Allgemeinen in der zugrunde liegenden Entwicklung (Algorithmusdesign, Treiber, Bildverarbeitung, Einzelchip-Mikrocomputer usw.) und in der Entwicklung der Anwendungsschicht (Webentwicklung) verwendet , Linux-Betrieb und -Wartung usw.) sind nicht üblich. Leser, die den Lernprozess beschleunigen möchten oder der zugrunde liegenden Entwicklung keine Aufmerksamkeit schenken, können diesen Abschnitt zunächst überspringen und ihn bei Bedarf später lernen.

Bitweise Operatoren von Python können nur zum Bearbeiten von Ganzzahltypen verwendet werden, die gemäß der binären Form von Ganzzahlen im Speicher berechnet werden. Die von Python unterstützten bitweisen Operatoren sind in Tabelle 1 aufgeführt.

Tabelle 1 Liste der bitweisen Python-Operatoren

bitweiser Operator	veranschaulichen	Form der Nutzung	Beispiel
&	bitweises UND	a & b	4 & 5
|	bitweise oder	ein | B	4 | 5
^	bitweises XOR	a ^ b	4 ^ 5
~	bitweise Inversion	~a	~4
<<	bitweise Linksverschiebung	a << b	4 << 2 bedeutet, dass die Ganzzahl 4 um 2 Bits nach links verschoben wird
>>	bitweise Rechtsverschiebung	a >> b	4 >> 2 bedeutet, dass die Ganzzahl 4 bitweise um 2 Bits nach rechts verschoben wird

& bitweiser UND-Operator

Die Operationsregel des bitweisen UND-Operators &lautet: Nur &wenn die beiden an der Operation beteiligten Bits 1 sind, ist das Ergebnis 1, andernfalls ist es 0. Zum Beispiel 1&1ist es 1, 0&0es ist 0 1&0und es ist auch 0, was logischen Operatoren sehr ähnlich ist &&.
 

Tabelle 2 Regeln für den Python &-Operator

erstes Stück	Das zweite Stück	Ergebnis
0	0	0
0	1	0
1	0	0
1	1	1

Es kann beispielsweise 9&5in die folgende Operation umgewandelt werden:

  0000 0000 – 0000 0000 – 0000 0000 – 0000 1001 (9 im Speicher gespeichert)
& 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 im Speicher gespeichert)
-------------------------------------------------- ---------------------------------
  0000 0000 – 0000 0000 – 0000 0000 – 0000 0001 (1 im Speicher gespeichert)

&Der Operator verarbeitet alle Binärbits der beiden an der Operation beteiligten Ganzzahlen &und 9&5das Ergebnis ist 1.

Als weiteres Beispiel -9&5kann es in die folgende Operation umgewandelt werden:

  1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 im Speicher gespeichert)
& 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 im Speicher gespeichert)
-------------------------------------------------- ---------------------------------
  0000 0000 – 0000 0000 – 0000 0000 – 0000 0101 (5 im Speicher gespeichert)

 

-9&5Das Ergebnis ist 5.

Auch hier &operieren die Operatoren mit den rohen Binärbits der Daten, wie sie im Speicher gespeichert sind, und nicht mit der Binärform der Daten selbst; das Gleiche gilt für andere bitweise Operatoren. Beispielsweise -9&5unterscheidet sich die speicherinterne Speicherung von -9 deutlich von der binären Form von -9:

1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 im Speicher gespeichert)
-0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (die binäre Form von -9, die zusätzliche 0 davor kann gelöscht werden)

Bitweise UND-Operationen werden normalerweise verwendet, um bestimmte Bits auf 0 zu löschen oder bestimmte Bits zu reservieren. Um beispielsweise die oberen 16 Bits von n auf 0 zu löschen und die niedrigen 16 Bits beizubehalten, können Sie n & 0XFFFFOperationen ausführen (die Speicherform von 0XFFFF im Speicher ist 0000 0000 – 0000 0000 – 1111 1111 – 1111 1111).

Verwenden Sie den Python-Code, um die obige Analyse zu überprüfen:

n = 0X8FA6002D
print("%X" % (9&5) )
print("%X" % (-9&5) )
print("%X" % (n&0XFFFF) )

 Operationsergebnis:

1
5
2d

| Bitweiser ODER-Operator

Die Operationsregel des bitweisen ODER-Operators |lautet: Wenn eines der beiden Binärbits 1 ist, ist das Ergebnis 1, und wenn beide 0 sind, ist das Ergebnis 0. Beispielsweise ist 1|11, 0|00, 1|0 1, was logischen Operationen sehr ähnlich ist ||.
 

Tabelle 3 Regeln für den Python |-Operator

erstes Stück	Das zweite Stück	Ergebnis
0	0	0
0	1	1
1	0	1
1	1	1

Es kann beispielsweise 9 | 5in die folgende Operation umgewandelt werden:

  0000 0000 – 0000 0000 – 0000 0000 – 0000 1001 (9 im Speicher gespeichert)
| 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 im Speicher gespeichert)
-------------------------------------------------- ---------------------------------
  0000 0000 – 0000 0000 – 0000 0000 – 0000 1101 (13 im Speicher gespeichert)

9 | 5Das Ergebnis ist 13.

Als weiteres Beispiel -9 | 5kann es in die folgende Operation umgewandelt werden:

  1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 im Speicher gespeichert)
| 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 im Speicher gespeichert)
-------------------------------------------------- ---------------------------------
  1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 im Speicher gespeichert)

 

-9 | 5Das Ergebnis ist -9.

Mit der bitweisen ODER-Verknüpfung können bestimmte Bits auf 1 gesetzt oder bestimmte Bits reserviert werden. Wenn beispielsweise die oberen 16 Bits von n auf 1 gesetzt sind und die niedrigen 16 Bits reserviert sind, n | 0XFFFF0000können Operationen ausgeführt werden (die Speicherform von 0XFFFF0000 im Speicher ist 1111 1111 – 1111 1111 – 0000 0000 – 0000 0000). .

Verwenden Sie den Python-Code, um die obige Analyse zu überprüfen:

n = 0X2D
print("%X" % (9|5) )
print("%X" % (-9|5) )
print("%X" % (n|0XFFFF0000) )

 Operationsergebnis:

D
-9
FFFF002D

 

^ bitweiser XOR-Operator

Die Operationsregel der bitweisen XOR-Operation ^lautet: Wenn die beiden an der Operation beteiligten Binärbits unterschiedlich sind, ist das Ergebnis 1, und wenn sie gleich sind, ist das Ergebnis 0. Zum Beispiel 0^11, 0^00, 1^10.
 

Tabelle 4 Regeln für den Python-Operator ^

erstes Stück	Das zweite Stück	Ergebnis
0	0	0
0	1	1
1	0	1
1	1	0

Es kann beispielsweise 9 ^ 5in die folgende Operation umgewandelt werden:

  0000 0000 – 0000 0000 – 0000 0000 – 0000 1001 (9 im Speicher gespeichert)
^ 0000 0000 – 0000 0000 – 0000 0000 – 0000 0101 (5 im Speicher gespeichert)
-------------------------------------------------- ---------------------------------
  0000 0000 – 0000 0000 – 0000 0000 – 0000 1100 (12 im Speicher gespeichert)

 9 ^ 5Das Ergebnis ist 12.

Als weiteres Beispiel -9 ^ 5kann es in die folgende Operation umgewandelt werden:

  1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 im Speicher gespeichert)
^ 0000 0000 – 0000 0000 – 0000 0000 – 0000 0101 (5 im Speicher gespeichert)
-------------------------------------------------- ---------------------------------
  1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0010 (-14 im Speicher gespeichert)

-9 ^ 5Das Ergebnis ist -14.

Mit der bitweisen XOR-Operation können bestimmte Binärbits invertiert werden. Um beispielsweise die oberen 16 Bits von n zu invertieren und die niedrigen 16 Bits beizubehalten, können Sie n ^ 0XFFFF0000Operationen ausführen (die Speicherform von 0XFFFF0000 im Speicher ist 1111 1111 – 1111 1111 – 0000 0000 – 0000 0000).

Verwenden Sie den Python-Code, um die obige Analyse zu überprüfen:

n = 0X0A07002D
print("%X" % (9^5) )
print("%X" % (-9^5) )
print("%X" % (n^0XFFFF0000) )

 Operationsergebnis:

C
-E
F5F8002D

~ bitweiser Negationsoperator

Der bitweise Inversionsoperator ~ist ein unärer Operator (nur ein Operand), rechtsassoziativ, und seine Funktion besteht darin, die an der Operation beteiligten Binärbits zu invertieren. Beispielsweise ~1ist es 0 ~0und 1, was dem bei logischen Operationen sehr ähnlich ist !.

Es kann beispielsweise ~9in die folgende Operation umgewandelt werden:

~ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (9 im Speicher gespeichert)
-------------------------------------------------- ---------------------------------
  1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0110 (-10 im Speicher gespeichert)

 

~9Das Ergebnis ist also -10.

Es kann beispielsweise ~-9in die folgende Operation umgewandelt werden:

~ 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 im Speicher gespeichert)
-------------------------------------------------- ---------------------------------
  0000 0000 – 0000 0000 – 0000 0000 – 0000 1000 (8 im Speicher gespeichert)

 

~-9Das Ergebnis ist also 8.

Verwenden Sie den Python-Code, um die obige Analyse zu überprüfen:

print("%X" % (~9) )
print("%X" % (~-9) )

 Operationsergebnis:

-A
8

<< Linksverschiebungsoperator

Der Linksverschiebungsoperator von Python <<wird verwendet, um alle binären Bits des Operanden um mehrere Bits nach links zu verschieben, die hohen Bits werden verworfen und die niedrigen Bits werden mit 0 aufgefüllt.

Es kann beispielsweise 9<<3in die folgende Operation umgewandelt werden:

<< 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (9 im Speicher gespeichert)
-------------------------------------------------- ---------------------------------
   0000 0000 – 0000 0000 – 0000 0000 – 0100 1000 (72 im Speicher gespeichert)

 

Das Ergebnis ist also 9<<372.

Als weiteres Beispiel (-9)<<3kann es in die folgende Operation umgewandelt werden:

<< 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 im Speicher gespeichert)
-------------------------------------------------- ---------------------------------
   1111 1111 -- 1111 1111 -- 1111 1111 -- 1011 1000 (-72 im Speicher gespeichert)

 

Das Ergebnis ist also (-9)<<3-72.

Wenn die Daten klein sind und die verworfenen High-Bits nicht 1 enthalten, dann entspricht die Verschiebung um n Bits nach links einer Multiplikation mit 2 hoch n.

Verwenden Sie den Python-Code, um die obige Analyse zu überprüfen:

print("%X" % (9<<3) )
print("%X" % ((-9)<<3) )

 Operationsergebnis:

48
-48

>> rechter Shift-Operator

Der Python-Rechtsverschiebungsoperator >>wird verwendet, um alle binären Bits des Operanden um mehrere Bits nach rechts zu verschieben, die niedrigen Bits zu verwerfen und die hohen Bits mit 0 oder 1 zu füllen. Wenn das höchste Bit der Daten 0 ist, addieren Sie 0; wenn das höchste Bit 1 ist, addieren Sie 1.

Es kann beispielsweise 9>>3in die folgende Operation umgewandelt werden:

>> 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (9 im Speicher gespeichert)
-------------------------------------------------- ---------------------------------
   0000 0000 – 0000 0000 – 0000 0000 – 0000 0001 (1 im Speicher gespeichert)

 

9>>3Das Ergebnis ist also 1.

Als weiteres Beispiel (-9)>>3kann es in die folgende Operation umgewandelt werden:

>> 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 im Speicher gespeichert)
-------------------------------------------------- ---------------------------------
   1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 1110 (-2 im Speicher gespeichert)

 

Das Ergebnis ist also (-9)>>3-2.

Wenn die verworfenen Bits niedriger Ordnung keine Einsen enthalten, dann entspricht das Verschieben um n Bits nach rechts einer Division durch 2 hoch n (die entfernten Bits enthalten jedoch häufig Einsen).

Verwenden Sie den Python-Code, um die obige Analyse zu überprüfen:

print("%X" % (9>>3) )
print("%X" % ((-9)>>3) )

 Operationsergebnis:

1
-2