Operatoren in Python verstehen

Einleitung

In diesem Lab erhalten Sie ein umfassendes Verständnis verschiedener Operatoren in Python, einem grundlegenden Konzept für das Schreiben effektiver Codes. Wir werden arithmetische, Vergleichs-, Zuweisungs-, logische, bitweise, Mitgliedschafts- und Identitätsoperatoren untersuchen und üben.

Durch praktische Übungen mit dem VS Code Editor lernen Sie, Berechnungen durchzuführen, Vergleiche anzustellen, Werte zuzuweisen, Bedingungen zu kombinieren, Bits zu manipulieren, auf Mitgliedschaft zu prüfen und Objektidentitäten zu vergleichen. Am Ende dieses Labs werden Sie im Umgang mit diesen Operatoren versiert sein, um komplexere und funktionalere Python-Programme zu erstellen.

Arithmetische und Vergleichsoperatoren erkunden

In diesem Schritt werden wir die grundlegenden arithmetischen und Vergleichsoperatoren in Python untersuchen. Diese Operatoren sind unerlässlich für die Durchführung von Berechnungen und Entscheidungen in Ihren Programmen.

Zuerst wiederholen wir die arithmetischen Operatoren, die wir bereits kurz angesprochen haben. Wir verwenden den VS Code Editor, um eine Python-Datei zu erstellen und unseren Code zu schreiben.

Öffnen Sie das integrierte Terminal in VS Code, indem Sie zu Terminal > New Terminal navigieren. Stellen Sie sicher, dass Ihr aktuelles Verzeichnis ~/project ist.

Erstellen Sie nun eine neue Datei namens operators.py im Verzeichnis ~/project. Sie können dies tun, indem Sie auf das Symbol "Neue Datei" im VS Code Dateiexplorer klicken oder das Terminal verwenden:

touch ~/project/operators.py

Öffnen Sie die Datei operators.py im Editor und fügen Sie den folgenden Python-Code hinzu:

## Arithmetic Operators
a = 21
b = 5
print(f'{a} + {b} = ', a + b)
print(f'{a} - {b} = ', a - b)
print(f'{a} * {b} = ', a * b)
print(f'{a} / {b} = ', a / b)
print(f'{a} // {b} = ', a // b)  ## Integer division, rounds down
print(f'{a} divided by {b} remainder is ', a % b)  ## Modulo operation, returns the remainder of a divided by b
print(f'{a} to the power of {b} is', a ** b)  ## Exponentiation

Speichern Sie die Datei (Strg + S oder Cmd + S).

Führen Sie nun das Skript im Terminal aus:

python ~/project/operators.py

Sie sollten eine Ausgabe ähnlich dieser sehen:

21 + 5 =  26
21 - 5 =  16
21 * 5 =  105
21 / 5 =  4.2
21 // 5 =  4
21 divided by 5 remainder is  1
21 to the power of 5 is 4084101

Als Nächstes untersuchen wir die Vergleichsoperatoren. Diese Operatoren vergleichen zwei Werte und geben entweder True oder False zurück.

Fügen Sie den folgenden Code zu Ihrer Datei operators.py hinzu, unterhalb der Beispiele für arithmetische Operatoren:

## Comparison Operators
a = 6
b = 5
print(f'{a} == {b} is', a == b)  ## Checks if objects are equal
print(f'{a} != {b} is', a != b)  ## Checks if objects are not equal
print(f'{a} > {b} is', a > b)  ## Checks if a is greater than b
print(f'{a} < {b} is', a < b)  ## Checks if a is less than b
print(f'{a} >= {b} is', a >= b)  ## Checks if a is greater than or equal to b
print(f'{a} <= {b} is', a <= b)  ## Checks if a is less than or equal to b

Speichern Sie die Datei und führen Sie sie erneut aus:

python ~/project/operators.py

Die Ausgabe sollte nun die Ergebnisse der Vergleichsoperationen enthalten:

21 + 5 =  26
21 - 5 =  16
21 * 5 =  105
21 / 5 =  4.2
21 // 5 =  4
21 divided by 5 remainder is  1
21 to the power of 5 is 4084101
6 == 5 is False
6 != 5 is True
6 > 5 is True
6 < 5 is False
6 >= 5 is True
6 <= 5 is False

Sie haben erfolgreich arithmetische und Vergleichsoperatoren in Python erkundet, indem Sie ein Python-Skript in der VS Code-Umgebung geschrieben und ausgeführt haben.

Übung zu Zuweisungs- und logischen Operatoren

In diesem Schritt üben wir die Verwendung von Zuweisungsoperatoren und logischen Operatoren in Python. Zuweisungsoperatoren werden verwendet, um Variablen Werte zuzuweisen, während logische Operatoren zum Kombinieren von bedingten Anweisungen verwendet werden.

Arbeiten Sie weiterhin mit der Datei operators.py, die Sie im vorherigen Schritt erstellt haben. Öffnen Sie sie im VS Code Editor.

Zuerst fügen wir Beispiele für Zuweisungsoperatoren hinzu. Diese Operatoren bieten eine Kurzschreibweise, um eine Operation durchzuführen und das Ergebnis der Variablen wieder zuzuweisen.

Fügen Sie den folgenden Code zu Ihrer Datei operators.py hinzu, unterhalb der vorherigen Beispiele:

## Assignment Operators
print("\n--- Assignment Operators ---")

a = 4
b = 2
print(f'Initial a: {a}, b: {b}')

a += b
print(f'a += b: {a}')

a = 4 ## Reset a for the next example
a -= b
print(f'a -= b: {a}')

a = 4 ## Reset a
a *= b
print(f'a *= b: {a}')

a = 4 ## Reset a
a /= b
print(f'a /= b: {a}')

a = 4 ## Reset a
a //= b
print(f'a //= b: {a}')

a = 4 ## Reset a
a %= b
print(f'a %= b: {a}')

a = 4 ## Reset a
a **= b
print(f'a **= b: {a}')

## Walrus operator (Python 3.8+)
print("\n--- Walrus Operator ---")
text = 'abcdefg'
if (length := len(text)) > 3:
    print(f'The length of string "{text}" is {length}')

Speichern Sie die Datei und führen Sie sie im Terminal aus:

python ~/project/operators.py

Sie sollten die Ausgabe für die Zuweisungsoperatoren und den Walrus-Operator sehen:

... (output from previous step) ...

--- Assignment Operators ---
Initial a: 4, b: 2
a += b: 6
a -= b: 2
a *= b: 8
a /= b: 2.0
a //= b: 2
a %= b: 0
a **= b: 16

--- Walrus Operator ---
The length of string "abcdefg" is 7

Fügen wir nun Beispiele für logische Operatoren (and, or, not) hinzu. Denken Sie daran, dass in Python 0, None, '', [], {} und () als False gelten, während andere Werte als True gelten.

Fügen Sie den folgenden Code zu Ihrer Datei operators.py hinzu:

## Logical Operators
print("\n--- Logical Operators ---")

a = 10
b = 20
print(f'{a} or {b} is', a or b)
print(f'0 or {b} is', 0 or b)

print(f'{a} and {b} is', a and b)
print(f'0 and {b} is', 0 and b)

c = 5
d = 0
print(f'not {c} is', not c)
print(f'not {d} is', not d)

Speichern Sie die Datei und führen Sie sie erneut aus:

python ~/project/operators.py

Die Ausgabe enthält nun die Ergebnisse der logischen Operationen:

... (output from previous examples) ...

--- Logical Operators ---
10 or 20 is 10
0 or 20 is 20
10 and 20 is 20
0 and 20 is 0
not 5 is False
not 0 is True

Sie haben erfolgreich die Verwendung von Zuweisungs- und logischen Operatoren in Python geübt.

Bitweise Operatoren lernen

In diesem Schritt lernen wir Bitwise-Operatoren in Python kennen. Bitwise-Operatoren führen Operationen direkt auf der binären Darstellung von ganzen Zahlen durch.

Verwenden Sie weiterhin die Datei operators.py im Verzeichnis ~/project. Öffnen Sie sie im VS Code Editor.

Bevor wir uns den Operatoren widmen, verwenden wir die Funktion bin(), um die binäre Darstellung einiger Zahlen anzuzeigen. Fügen Sie den folgenden Code zu Ihrer Datei operators.py hinzu:

## Bitwise Operators
print("\n--- Bitwise Operators ---")
print("Binary representation of 5:", bin(5))
print("Binary representation of 9:", bin(9))

Speichern Sie die Datei und führen Sie sie aus:

python ~/project/operators.py

Sie sehen die binären Formen:

... (output from previous steps) ...

--- Bitwise Operators ---
Binary representation of 5: 0b101
Binary representation of 9: 0b1001

Fügen wir Auffüllungen hinzu, um sie zur einfacheren Verständlichkeit auf 8 Bits zu bringen:
5 in Binärform ist 00000101
9 in Binärform ist 00001001

Nun erkunden wir die Bitwise-Operatoren:

Bitwise OR (|)

Der Bitwise OR-Operator vergleicht die entsprechenden Bits zweier Zahlen. Wenn eines der Bits 1 ist, ist das resultierende Bit 1.

Bei unserem Beispiel von 5 (00000101) und 9 (00001001) würde die Bitwise OR-Operation 5 | 9 zu 00001101 führen, was dezimal 13 ist.

Fügen Sie dies zu operators.py hinzu:

print(f'5 | 9 =', 5 | 9)

Speichern und führen Sie die Datei aus:

python ~/project/operators.py

Ausgabe:

... (previous output) ...
5 | 9 = 13

Bitwise AND (&)

Der Bitwise AND-Operator vergleicht die entsprechenden Bits zweier Zahlen. Wenn beide Bits 1 sind, ist das resultierende Bit 1; andernfalls ist es 0.

Für 5 (00000101) und 9 (00001001) würde die Bitwise AND-Operation 5 & 9 zu 00000001 führen, was dezimal 1 ist.

Fügen Sie dies zu operators.py hinzu:

print(f'5 & 9 =', 5 & 9)

Speichern und ausführen:

python ~/project/operators.py

Ausgabe:

... (previous output) ...
5 & 9 = 1

Bitwise XOR (^)

Der Bitwise XOR-Operator vergleicht die entsprechenden Bits zweier Zahlen. Wenn die Bits unterschiedlich sind, ist das resultierende Bit 1; andernfalls ist es 0.

Für 5 (00000101) und 9 (00001001) würde die Bitwise XOR-Operation 5 ^ 9 zu 00001100 führen, was dezimal 12 ist.

Fügen Sie dies zu operators.py hinzu:

print(f'5 ^ 9 =', 5 ^ 9)

Speichern und ausführen:

python ~/project/operators.py

Ausgabe:

... (previous output) ...
5 ^ 9 = 12

Bitwise NOT (~)

Der Bitwise NOT-Operator invertiert alle Bits einer Zahl. Für eine ganze Zahl x ist ~x äquivalent zu -(x+1).

Fügen Sie dies zu operators.py hinzu:

print(f'~5 =', ~5)

Speichern und ausführen:

python ~/project/operators.py

Ausgabe:

... (previous output) ...
~5 = -6

Left Shift (<<)

Der Left Shift-Operator verschiebt die Bits einer Zahl um eine angegebene Anzahl von Positionen nach links. Eine Linksverschiebung um n Bits ist äquivalent zur Multiplikation mit 2**n.

Für 5 (00000101) führt eine Linksverschiebung um 2 (5 << 2) zu 00010100, was dezimal 20 ist (5 * 2^2).

Fügen Sie dies zu operators.py hinzu:

print(f'5 << 2 =', 5 << 2)

Speichern und ausführen:

python ~/project/operators.py

Ausgabe:

... (previous output) ...
5 << 2 = 20

Right Shift (>>)

Der Right Shift-Operator verschiebt die Bits einer Zahl um eine angegebene Anzahl von Positionen nach rechts. Eine Rechtsverschiebung um n Bits ist äquivalent zur Ganzzahldivision durch 2**n.

Für 5 (00000101) führt eine Rechtsverschiebung um 2 (5 >> 2) zu 00000001, was dezimal 1 ist (5 // 2^2).

Fügen Sie dies zu operators.py hinzu:

print(f'5 >> 2 =', 5 >> 2)

Speichern und ausführen:

python ~/project/operators.py

Ausgabe:

... (previous output) ...
5 >> 2 = 1

Sie haben erfolgreich Bitwise-Operatoren in Python kennengelernt und geübt.

Mitgliedschafts- und Identitätsoperatoren verwenden

In diesem Schritt lernen wir die Mitgliedschaftsoperatoren (in und not in) und Identitätsoperatoren (is und is not) in Python kennen. Mitgliedschaftsoperatoren testen die Zugehörigkeit zu einer Sequenz, während Identitätsoperatoren die Speicheradressen zweier Objekte vergleichen.

Arbeiten Sie weiterhin mit der Datei operators.py im Verzeichnis ~/project. Öffnen Sie sie im VS Code Editor.

Zuerst fügen wir Beispiele für Mitgliedschaftsoperatoren hinzu. Der Operator in gibt True zurück, wenn ein Element in einer Sequenz (wie einer Liste, einem Tupel, einem String oder einem Dictionary) gefunden wird, andernfalls False. Der Operator not in ist das Gegenteil.

Fügen Sie den folgenden Code zu Ihrer Datei operators.py hinzu:

## Membership Operators
print("\n--- Membership Operators ---")

a = 6
b = [2, 4, 6, 8]
print(f'{a} in {b} is', a in b)
print(f'9 not in {b} is', 9 not in b)

text = "hello world"
print(f'"hello" in "{text}" is', "hello" in text)
print(f'"goodbye" not in "{text}" is', "goodbye" not in text)

Speichern Sie die Datei und führen Sie sie aus:

python ~/project/operators.py

Sie sollten die Ausgabe für die Mitgliedschaftsoperatoren sehen:

... (output from previous steps) ...

--- Membership Operators ---
6 in [2, 4, 6, 8] is True
9 not in [2, 4, 6, 8] is True
"hello" in "hello world" is True
"goodbye" not in "hello world" is True

Nun erkunden wir Identitätsoperatoren. Der Operator is prüft, ob zwei Variablen auf dasselbe Objekt im Speicher verweisen. Der Operator is not prüft, ob sie nicht auf dasselbe Objekt verweisen. Sie können die Funktion id() verwenden, um die Speicheradresse eines Objekts zu erhalten.

Fügen Sie den folgenden Code zu Ihrer Datei operators.py hinzu:

## Identity Operators
print("\n--- Identity Operators ---")

x = 10
y = 10
print(f'id(x): {id(x)}, id(y): {id(y)}')
print(f'{x} is {y} is', x is y)
print(f'{x} is not {y} is', x is not y)

## Example with different objects
list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(f'id(list1): {id(list1)}, id(list2): {id(list2)}')
print(f'{list1} is {list2} is', list1 is list2)
print(f'{list1} == {list2} is', list1 == list2)

## Example with cached integers
p = 256
q = 256
print(f'id(p): {id(p)}, id(q): {id(q)}')
print(f'{p} is {q} is', p is q)

r = 257
s = 257
print(f'id(r): {id(r)}, id(s): {id(s)}')
print(f'{r} is {s} is', r is s)

Speichern Sie die Datei und führen Sie sie aus:

python ~/project/operators.py

Die Ausgabe zeigt die Ergebnisse der Identitätsvergleiche und die Speicheradressen. Beachten Sie, wie is und == unterschiedliche Ergebnisse liefern können, insbesondere bei veränderlichen Objekten wie Listen oder bei ganzen Zahlen außerhalb des Cache-Bereichs.

... (output from previous examples) ...

--- Membership Operators ---
6 in [2, 4, 6, 8] is True
9 not in [2, 4, 6, 8] is True
"hello" in "hello world" is True
"goodbye" not in "hello world" is True

--- Identity Operators ---
id(x): <memory address>, id(y): <memory address>
10 is 10 is True
10 is not 10 is False
id(list1): <memory address>, id(list2): <memory address>
[1, 2, 3] is [1, 2, 3] is False
[1, 2, 3] == [1, 2, 3] is True
id(p): <memory address>, id(q): <memory address>
256 is 256 is True
id(r): <memory address>, id(s): <memory address>
257 is 257 is False

(Hinweis: Die im Output angezeigten Speicheradressen sind bei jeder Ausführung des Skripts unterschiedlich.)

Sie haben erfolgreich Mitgliedschafts- und Identitätsoperatoren in Python verwendet. Damit ist die Erkundung verschiedener Operatoren in Python abgeschlossen.

Zusammenfassung

In diesem Lab haben wir praktische Erfahrungen mit verschiedenen Arten von Operatoren in Python gesammelt. Wir begannen mit der Erkundung grundlegender arithmetischer Operatoren zur Durchführung von Berechnungen und Vergleichsoperatoren zur Bewertung von Beziehungen zwischen Werten und beobachteten deren Verhalten anhand praktischer Beispiele in der VS Code-Umgebung.

Unsere Erkundung fortsetzend, übten wir die Verwendung von Zuweisungsoperatoren für effiziente Variablenaktualisierungen und logischen Operatoren zum Kombinieren von bedingten Anweisungen. Anschließend befassten wir uns mit Bitwise-Operatoren, um Operationen auf der binären Ebene zu verstehen. Schließlich lernten wir Mitgliedschaftsoperatoren kennen, um die Anwesenheit von Elementen in Sequenzen zu überprüfen, und Identitätsoperatoren, um die Speicheradressen von Objekten zu vergleichen, wodurch unser Verständnis dieser wesentlichen Python-Konstrukte gefestigt wurde.