Umfassender Leitfaden zu Python Operatoren: Arithmetisch, Logisch, Vergleich, Zuweisung, Bitweise und Präzedenz

Was sind logische Operatoren in Python?

Logische Operatoren in Python evaluieren boolesche Ausdrücke und geben True oder False zurück. Die drei primären logischen Operatoren sind and, or und not. Sie sind unverzichtbar für die Steuerung des Flusses mit if, while und anderen bedingten Anweisungen.

In diesem Tutorial erkunden wir das gesamte Spektrum der Python-Operatoren, einschließlich:

• Arithmetische Operatoren
• Vergleichsoperatoren
• Zuweisungsoperatoren
• Logische & Bitweise Operatoren
• Mitgliedschaftsoperatoren
• Identitätsoperatoren
• Operator-Präzedenz

Arithmetische Operatoren

Arithmetische Operatoren führen numerische Berechnungen durch. Python unterstützt die üblichen Operatoren: + (Addition), - (Subtraktion), * (Multiplikation), / (echte Division), // (Ganzzahldivision), % (Modulo) und ** (Potenz). Diese können direkt in Ausdrücken oder via der eingebauten eval()-Funktion für dynamische Evaluation verwendet werden.

Beispiel: Einfache Addition

x = 4
y = 5
print(x + y) # Ausgabe: 9

Andere Operatoren funktionieren analog; z. B. ergibt 4 * 5 20, 4 / 2 gibt 2.0, und 4 ** 2 resultiert in 16.

Vergleichsoperatoren

Vergleichsoperatoren (relationale Operatoren) bewerten die Beziehung zwischen zwei Werten und geben ein boolesches Ergebnis zurück. Sie umfassen:

• == (gleich)
• != (ungleich)
• < (kleiner als)
• <= (kleiner oder gleich)
• > (größer als)
• >= (größer oder gleich)

Beispiel: Zwei Variablen vergleichen

x = 4
y = 5
print('x > y ist', x > y) # Ausgabe: False

Zuweisungsoperatoren

Zuweisungsoperatoren speichern Werte in Variablen. Die Basisform ist =, während zusammengesetzte Operatoren eine Operation mit Zuweisung kombinieren, wie +=, -=, *=, /= und **=.

Beispiel: Basis- und zusammengesetzte Zuweisung

num1 = 4
num2 = 5
print('Line 1 - Wert von num1:', num1)
print('Line 2 - Wert von num2:', num2)
# Zusammengesetzte Addition
res = num1 + num2
res += num1
print('Line 3 - Ergebnis nach res += num1:', res) # Ausgabe: 13

Logische und bitweise Operatoren

Logische Operatoren (and, or, not) evaluieren boolesche Ausdrücke. Bitweise Operatoren (&, |, ^, ~, <<, >>) führen Bit-Manipulation durch.

Beispiel: Logische Operationen

a = True
b = False
print('a and b ist', a and b) # Ausgabe: False
print('a or b ist', a or b) # Ausgabe: True
print('not a ist', not a) # Ausgabe: False

Mitgliedschaftsoperatoren

Mitgliedschaftsoperatoren testen das Vorhandensein eines Werts in einer Sequenz: in und not in.

Beispiel: Mitgliedschaft in einer Liste prüfen

x = 4
y = 8
sample_list = [1, 2, 3, 4, 5]
if x in sample_list:
    print('Line 1 - x ist in der Liste verfügbar')
else:
    print('Line 1 - x ist nicht in der Liste verfügbar')
if y not in sample_list:
    print('Line 2 - y ist nicht in der Liste verfügbar')
else:
    print('Line 2 - y ist in der Liste verfügbar')

Identitätsoperatoren

Identitätsoperatoren vergleichen die Speicheradressen von Objekten: is und is not. Sie sind essenziell, um zwischen Objekten zu unterscheiden, die gleich im Wert, aber distinct in der Identität sind.

Beispiel: Identitätsvergleich

x = 20
y = 20
if x is y:
    print('x & y haben die gleiche Identität')
y = 30
if x is not y:
    print('x & y haben unterschiedliche Identitäten')

Operator-Präzedenz

Python folgt einer strikten Präzedenz-Hierarchie, um Ausdrücke ohne Klammern aufzulösen. Die höchste Präzedenz hat Potenzierung (**), gefolgt von unären Operatoren, Multiplikation/Division/Modulo, Addition/Subtraktion, Vergleichsoperatoren, Identitätsoperatoren, Mitgliedschaftsoperatoren, logischen Operatoren und schließlich Zuweisungsoperatoren.

Klammern überschreiben die Standard-Präzedenz und machen Ausdrücke explizit.

Beispiel: Präzedenz in Aktion

v = 4
w = 5
x = 8
y = 2
z = (v + w) * x / y
print('Wert von (v + w) * x / y ist', z) # Ausgabe: 28.0

Python 2 Kompatibilität

Unten sind äquivalente Snippets für Python 2, das print-Statements ohne Klammern nutzt.

# Arithmetische Operatoren
x = 4
y = 5
print x + y
# Vergleichsoperatoren
x = 4
y = 5
print 'x > y ist', x > y
# Zuweisungsoperatoren
num1 = 4
num2 = 5
print 'Line 1 - Wert von num1:', num1
print 'Line 2 - Wert von num2:', num2
# Zusammengesetzte Zuweisung
num1 = 4
num2 = 5
res = num1 + num2
res += num1
print 'Line 3 - Ergebnis nach res += num1:', res
# Logische Operatoren
a = True
b = False
print 'a and b ist', a and b
print 'a or b ist', a or b
print 'not a ist', not a
# Mitgliedschaftsoperatoren
x = 4
y = 8
sample_list = [1, 2, 3, 4, 5]
if x in sample_list:
    print 'Line 1 - x ist in der Liste verfügbar'
else:
    print 'Line 1 - x ist nicht in der Liste verfügbar'
if y not in sample_list:
    print 'Line 2 - y ist nicht in der Liste verfügbar'
else:
    print 'Line 2 - y ist in der Liste verfügbar'
# Identitätsoperatoren
x = 20
y = 20
if x is y:
    print 'x & y haben die gleiche Identität'
y = 30
if x is not y:
    print 'x & y haben unterschiedliche Identitäten'
# Operator-Präzedenz
v = 4
w = 5
x = 8
y = 2
z = (v + w) * x / y
print 'Wert von (v + w) * x / y ist', z

Zusammenfassung

• Arithmetische Operatoren handhaben numerische Berechnungen.
• Vergleichsoperatoren bestimmen relationale Wahrheitswerte.
• Zuweisungsoperatoren speichern Werte; zusammengesetzte Varianten kombinieren Operationen.
• Logische Operatoren steuern Flusskontrolle; bitweise Operatoren manipulieren Bits.
• Mitgliedschaftsoperatoren testen Sequenz-Enthaltenheit.
• Identitätsoperatoren vergleichen Objektidentitäten.
• Operator-Präzedenz bestimmt Auswertungsreihenfolge; Klammern können sie überschreiben.