Python-Operatoren verstehen

PythonBeginner
Jetzt üben

Einführung

In diesem Lab erlangen Sie ein umfassendes Verständnis der verschiedenen Operatoren in Python, einem fundamentalen Konzept für das Schreiben effektiven Codes. Wir werden arithmetische, Vergleichs-, Zuweisungs-, logische, bitweise, Mitgliedschafts- (Membership) und Identitätsoperatoren untersuchen und deren Anwendung üben.

Durch praktische Übungen mit dem integrierten VS Code Editor und Terminal lernen Sie, wie man Berechnungen durchführt, Vergleiche anstellt, Werte zuweist, Bedingungen kombiniert, Bits manipuliert, die Mitgliedschaft überprüft und die Identität von Objekten vergleicht. Am Ende dieses Labs werden Sie versiert im Umgang mit diesen Operatoren sein, um komplexere und funktionalere Python-Programme zu erstellen.

Dies ist ein Guided Lab, das schrittweise Anweisungen bietet, um Ihnen beim Lernen und Üben zu helfen. Befolgen Sie die Anweisungen sorgfältig, um jeden Schritt abzuschließen und praktische Erfahrungen zu sammeln. Historische Daten zeigen, dass dies ein Labor der Stufe Anfänger mit einer Abschlussquote von 95% ist. Es hat eine positive Bewertungsrate von 100% von den Lernenden erhalten.

Arithmetische und Vergleichsoperatoren erkunden

In diesem Schritt untersuchen wir die grundlegenden arithmetischen und Vergleichsoperatoren in Python. Diese Operatoren sind unerlässlich für die Durchführung von Berechnungen und das Treffen von Entscheidungen in Ihren Programmen. Die Laborumgebung hat bereits eine Datei namens operators.py für Sie im Verzeichnis ~/project erstellt.

Suchen Sie zunächst die Datei operators.py im Dateiexplorer auf der linken Seite des VS Code Editors und öffnen Sie sie. Wir werden unseren gesamten Code in dieser einen Datei schreiben.

Beginnen wir mit den arithmetischen Operatoren. Fügen Sie den folgenden Python-Code in die Datei operators.py ein:

## 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}') ## Standard division
print(f'{a} // {b} = {a // b}')  ## Floor division, rounds down to the nearest whole number
print(f'{a} % {b} = {a % b}')  ## Modulo, returns the remainder
print(f'{a} ** {b} = {a ** b}')  ## Exponentiation, a to the power of b

Nachdem Sie den Code hinzugefügt haben, speichern Sie die Datei, indem Sie Strg + S drücken.

Um das Skript auszuführen, öffnen Sie das integrierte Terminal in VS Code, indem Sie im oberen Menü Terminal > New Terminal auswählen. Führen Sie dann den folgenden Befehl aus:

python ~/project/operators.py

Sie sollten die folgende Ausgabe im Terminal sehen:

21 + 5 = 26
21 - 5 = 16
21 * 5 = 105
21 / 5 = 4.2
21 // 5 = 4
21 % 5 = 1
21 ** 5 = 4084101

Als Nächstes untersuchen wir die Vergleichsoperatoren (Comparison Operators). Diese Operatoren vergleichen zwei Werte und geben einen Booleschen Wert zurück: True oder False.

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

## Comparison Operators
print("\n--- Comparison Operators ---")
a = 6
b = 5
print(f'{a} == {b} is {a == b}')  ## Equal to
print(f'{a} != {b} is {a != b}')  ## Not equal to
print(f'{a} > {b} is {a > b}')    ## Greater than
print(f'{a} < {b} is {a < b}')    ## Less than
print(f'{a} >= {b} is {a >= b}')  ## Greater than or equal to
print(f'{a} <= {b} is {a <= b}')  ## Less than or equal to

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

python ~/project/operators.py

Die Ausgabe wird nun die Ergebnisse der Vergleichsoperationen enthalten:

21 + 5 = 26
21 - 5 = 16
21 * 5 = 105
21 / 5 = 4.2
21 // 5 = 4
21 % 5 = 1
21 ** 5 = 4084101

--- Comparison Operators ---
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 nun erfolgreich arithmetische und Vergleichsoperatoren in einem Python-Skript verwendet.

Zuweisungs- und logische Operatoren üben

In diesem Schritt üben wir die Verwendung von Zuweisungsoperatoren (Assignment Operators) und logischen Operatoren (Logical Operators). Zuweisungsoperatoren werden verwendet, um den Wert einer Variablen zuzuweisen oder zu aktualisieren, während logische Operatoren dazu dienen, bedingte Anweisungen zu kombinieren.

Arbeiten Sie weiterhin mit der Datei operators.py im VS Code Editor.

Fügen wir zunächst Beispiele für Zuweisungsoperatoren hinzu. Diese bieten eine Kurzform, um eine Operation durchzuführen und das Ergebnis derselben Variablen wieder zuzuweisen.

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

## Assignment Operators
print("\n--- Assignment Operators ---")
a = 10
b = 3
print(f'Initial a: {a}')

c = a
c += b  ## Equivalent to c = c + b
print(f'a += b: {c}')

c = a
c -= b  ## Equivalent to c = c - b
print(f'a -= b: {c}')

c = a
c *= b  ## Equivalent to c = c * b
print(f'a *= b: {c}')

c = a
c /= b  ## Equivalent to c = c / b
print(f'a /= b: {c}')

## Walrus operator (Python 3.8+)
## It assigns a value to a variable as part of a larger expression.
print("\n--- Walrus Operator ---")
text = 'hello python'
if (n := len(text)) > 10:
    print(f'The string is long enough ({n} characters)')

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

python ~/project/operators.py

Sie sollten die Ausgabe für die Zuweisungsoperatoren sehen:

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

--- Assignment Operators ---
Initial a: 10
a += b: 13
a -= b: 7
a *= b: 30
a /= b: 3.3333333333333335

--- Walrus Operator ---
The string is long enough (12 characters)

Fügen wir nun Beispiele für logische Operatoren (and, or, not) hinzu. Diese Operatoren arbeiten mit Booleschen Werten, können aber auch mit anderen Typen arbeiten. In Python gelten Werte wie 0, None und leere Sammlungen ('', [], {}) als False. Alle anderen Werte gelten als True.

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

## Logical Operators
print("\n--- Logical Operators ---")
x = True
y = False

print(f'{x} and {y} is {x and y}')
print(f'{x} or {y} is {x or y}')
print(f'not {x} is {not x}')

## Evaluation with non-boolean values
a = 10  ## True
b = 0   ## False
print(f'{a} and {b} returns {a and b}') ## Returns the first Falsey value or the last Truthy value
print(f'{a} or {b} returns {a or b}')   ## Returns the first Truthy value or the last Falsey value

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

python ~/project/operators.py

Die Ausgabe wird nun die Ergebnisse der logischen Operationen enthalten:

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

--- Logical Operators ---
True and False is False
True or False is True
not True is False
10 and 0 returns 0
10 or 0 returns 10

Sie haben nun das Üben der Verwendung von Zuweisungs- und logischen Operatoren in Python abgeschlossen.

Bitweise Operatoren kennenlernen

In diesem Schritt lernen wir die bitweisen Operatoren (Bitwise Operators) kennen. Diese Operatoren führen Operationen direkt auf der binären (Basis-2) Darstellung von ganzen Zahlen durch. Dies ist nützlich für die Datenmanipulation auf niedriger Ebene (low-level).

Bearbeiten Sie weiterhin die Datei operators.py.

Zuerst sehen wir uns die binäre Darstellung einiger Zahlen mithilfe der Funktion bin() an. Das Präfix 0b zeigt an, dass die folgenden Ziffern binär sind.

Fügen Sie diesen Code am Ende von operators.py hinzu:

## Bitwise Operators
print("\n--- Bitwise Operators ---")
a = 5  ## Binary: 0b101
b = 9  ## Binary: 0b1001
print(f'Binary of {a} is {bin(a)}')
print(f'Binary of {b} is {bin(b)}')

## For clarity, let's align them with 4 bits:
## a = 0101
## b = 1001

## Bitwise AND (&): Sets each bit to 1 if both bits are 1.
## 0101 & 1001 = 0001 (Decimal 1)
print(f'{a} & {b} = {a & b}')

## Bitwise OR (|): Sets each bit to 1 if one of the two bits is 1.
## 0101 | 1001 = 1101 (Decimal 13)
print(f'{a} | {b} = {a | b}')

## Bitwise XOR (^): Sets each bit to 1 if only one of the two bits is 1.
## 0101 ^ 1001 = 1100 (Decimal 12)
print(f'{a} ^ {b} = {a ^ b}')

## Bitwise NOT (~): Inverts all the bits.
## ~a is equivalent to -(a+1)
print(f'~{a} = {~a}')

## Left Shift (<<): Shifts bits to the left, filling with zeros.
## Equivalent to multiplying by 2**n.
## 5 << 2 means 0101 becomes 10100 (Decimal 20)
print(f'{a} << 2 = {a << 2}')

## Right Shift (>>): Shifts bits to the right, discarding bits from the right.
## Equivalent to floor division by 2**n.
## 9 >> 2 means 1001 becomes 10 (Decimal 2)
print(f'{b} >> 2 = {b >> 2}')

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

python ~/project/operators.py

Sie werden die Ausgabe sehen, die jede bitweise Operation demonstriert:

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

--- Bitwise Operators ---
Binary of 5 is 0b101
Binary of 9 is 0b1001
5 & 9 = 1
5 | 9 = 13
5 ^ 9 = 12
~5 = -6
5 << 2 = 20
9 >> 2 = 2

Sie haben nun gelernt, wie man bitweise Operatoren verwendet, um ganze Zahlen auf Bit-Ebene zu manipulieren.

Mitgliedschafts- und Identitätsoperatoren verwenden

In diesem letzten Schritt behandeln wir die Mitgliedschaftsoperatoren (in, not in) und die Identitätsoperatoren (is, is not). Mitgliedschaftsoperatoren prüfen, ob ein Wert in einer Sequenz vorhanden ist, während Identitätsoperatoren prüfen, ob zwei Variablen auf dasselbe Objekt im Speicher verweisen.

Arbeiten Sie weiterhin mit der Datei operators.py.

Fügen wir zunächst Beispiele für Mitgliedschaftsoperatoren hinzu. Diese werden häufig mit Sequenzen wie Listen, Tupeln und Strings verwendet.

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

## Membership Operators
print("\n--- Membership Operators ---")
my_list = [1, 3, 5, 7]
print(f'3 in {my_list} is {3 in my_list}')
print(f'4 not in {my_list} is {4 not in my_list}')

greeting = "hello world"
print(f'"world" in "{greeting}" is {"world" in greeting}')

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

python ~/project/operators.py

Die Ausgabe für die Mitgliedschaftsoperatoren lautet:

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

--- Membership Operators ---
3 in [1, 3, 5, 7] is True
4 not in [1, 3, 5, 7] is True
"world" in "hello world" is True

Nun untersuchen wir die Identitätsoperatoren. Es ist wichtig, den Unterschied zwischen is (Identität) und == (Gleichheit) zu verstehen. == prüft, ob die Werte zweier Objekte gleich sind, während is prüft, ob sie dasselbe Objekt sind (d.h. sie haben dieselbe Speicheradresse).

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

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

## For small integers, Python often reuses the same object.
x = 256
y = 256
print(f'x is y (for 256): {x is y}') ## This is often True

## For larger integers, Python may create separate objects.
a = 257
b = 257
print(f'a is b (for 257): {a is b}') ## This is often False

## For mutable objects like lists, they are different objects even if their content is the same.
list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(f'list1 == list2: {list1 == list2}') ## Checks for equal content (True)
print(f'list1 is list2: {list1 is list2}') ## Checks for same object (False)
print(f'list1 is not list2: {list1 is not list2}') ## Checks for different objects (True)

Speichern Sie die Datei und führen Sie sie ein letztes Mal aus:

python ~/project/operators.py

Die Ausgabe demonstriert den Unterschied zwischen Gleichheit und Identität:

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

--- Identity Operators ---
x is y (for 256): True
a is b (for 257): True
list1 == list2: True
list1 is list2: False
list1 is not list2: True

Sie haben erfolgreich Mitgliedschafts- und Identitätsoperatoren verwendet und damit Ihre Untersuchung der Hauptoperatortypen in Python abgeschlossen.

Zusammenfassung

In diesem Lab haben Sie praktische Erfahrungen mit den verschiedenen Arten von Operatoren in Python gesammelt. Sie begannen mit der Erkundung grundlegender arithmetischer Operatoren und Vergleichsoperatoren, um Berechnungen durchzuführen und Bedingungen auszuwerten. Anschließend übten Sie die Verwendung von Zuweisungsoperatoren (Assignment Operators) für effiziente Variablenaktualisierungen und logischen Operatoren (Logical Operators) zur Kombination bedingter Logik.

Darüber hinaus haben Sie sich mit bitweisen Operatoren (Bitwise Operators) beschäftigt, um Datenmanipulationen auf niedriger Ebene zu verstehen, und dies mit Mitgliedschaftsoperatoren (Membership Operators) und Identitätsoperatoren (Identity Operators) abgeschlossen, um die Anwesenheit von Elementen und die Objektidentität zu überprüfen. Durch das Schreiben und Ausführen von Code für jeden Operatortyp im VS Code Editor haben Sie eine solide Grundlage für die Verwendung dieser wesentlichen Werkzeuge in Ihrer zukünftigen Python-Programmierung geschaffen.