Python operators
Table of Contents
In diesem Tutorial erfahren Sie alles über die verschiedenen Arten von Operatoren in Python, ihre Syntax und ihre Verwendung anhand von Beispielen.
Was sind Operatoren in Python?
Operatoren sind spezielle Symbole in Python, die arithmetische oder logische Berechnungen durchführen. Der Wert, auf dem der Operator operiert, wird Operand genannt.
Zum Beispiel:
>>> 2+3 5
Hier, + ist der Operator, der die Addition durchführt. 2 und 3 sind die Operanden und 5 ist der Ausgang der operation.
Arithmetische Operatoren
Arithmetische Operatoren werden verwendet, um mathematische Operationen wie Addition, Subtraktion, Multiplikation usw. durchzuführen.
| Operator | Bedeutung | Beispiel |
|---|---|---|
| + | Addition zweier Operanden oder unäres Plus | x + y+ 2 |
| – | Rechten Operanden vom linken subtrahieren oder unäres Minus | x – y- 2 |
| * | Zwei Operanden multiplizieren | x * y |
| / | Linken Operanden durch den rechten dividieren (ergibt immer Float) | x / y |
| % | Modulus – Rest der Division des linken Operanden durch den rechten | x % y (remainder of x/y) |
| // | Floor division – Division, die eine ganze Zahl ergibt, die in der Zahlenzeile nach links angepasst wird | x // y |
| ** | Exponent – linker Operand potenziert mit rechts | x**y (x an die Mach y) |
Beispiel 1: Arithmetische Operatoren in Python
x = 21
y = 3
# Output: x + y = 24
print('x + y =',x+y)
# Output: x - y = 18
print('x - y =',x-y)
# Output: x * y = 63
print('x * y =',x*y)
# Output: x / y = 7.0
print('x / y =',x/y)
# Output: x // y = 7
print('x // y =',x//y)
# Output: x ** y = 9261
print('x ** y =',x**y)
Output
x + y = 24 x - y = 18 x * y = 63 x / y = 7.0 x // y = 7 x ** y = 9261
Comparison operators
Vergleichsoperatoren werden verwendet, um Werte zu vergleichen. Es kehrt entweder zurück True oder False je nach Zustand.
| Operator | Bedeutung | Beispiel |
|---|---|---|
| > | Größer als – Wahr, wenn der linke Operand größer als der rechte ist | x > y |
| < | Kleiner als – Wahr, wenn der linke Operand kleiner als der rechte ist | x < y |
| == | Gleich – Wahr, wenn beide Operanden gleich sind | x == y |
| != | Ungleich – Wahr, wenn Operanden ungleich sind | x != y |
| >= | Größer oder gleich – Wahr, wenn der linke Operand größer oder gleich dem rechten ist | x >= y |
| <= | Kleiner oder gleich – Wahr, wenn der linke Operand kleiner oder gleich dem rechten ist | x <= y |
Beispiel 2: Vergleichsoperatoren in Python
x = 6
y = 8
# Output: x > y is False
print('x > y is',x>y)
# Output: x < y is True
print('x < y is',x<y)
# Output: x == y is False
print('x == y is',x==y)
# Output: x != y is True
print('x != y is',x!=y)
# Output: x >= y is False
print('x >= y is',x>=y)
# Output: x <= y is True
print('x <= y is',x<=y)
Output
x > y is False x < y is True x == y is False x != y is True x >= y is False x <= y is True
Logical operators
Logische Operatoren sind die and, or, not operators.
| Operator | Bedeutung | Beispiel |
|---|---|---|
| and | Wahr, wenn beide Operanden wahr sind | x and y |
| or | Wahr, wenn einer der Operanden wahr ist | x or y |
| not | Wahr, wenn Operand falsch ist (ergänzt den Operanden) | not x |
Beispiel 3: Logische Operatoren in Python
x = True
y = False
print('x and y is',x and y)
print('x or y is',x or y)
print('not x is',not x)
Output
x and y is False x or y is True not x is False
Hier ist die Wahrheitstabelle für diese Operatoren.
Bitweise operators
Bitweise Operatoren wirken auf Operanden, als wären sie Zeichenfolgen von Binärziffern. Sie arbeiten nach und nach, daher der Name.
Beispielsweise, 2 ist 10 in binär und 7 ist 111.
In der Tabelle unten: Lassen x = 10 (0000 1010 in binär) und y = 4 (0000 0100 in binär)
| Operator | Bedeutung | Beispiel |
|---|---|---|
| & | Bitweise AND | x & y = 0 (0000 0000) |
| | | Bitweise OR | x | y = 14 (0000 1110) |
| ~ | Bitweise NOT | ~x = -11 (1111 0101) |
| ^ | Bitweise XOR | x ^ y = 14 (0000 1110) |
| >> | Bitweise rechte Shifttaste | x >> 2 = 2 (0000 0010) |
| << | Bitweise Linksverschiebung | x << 2 = 40 (0010 1000) |
Assignment operators
Zuweisungsoperatoren werden in Python verwendet, um Variablen Werte zuzuweisen.
a = 5 is a simple assignment operator that assigns the value 5 on the right to the variable a auf der linken Seite.
Es gibt verschiedene zusammengesetzte Operatoren in Python wie a += 5 das fügt der Variablen hinzu und weist sie später zu. Es ist äquivalent zu a = a + 5.
| Operator | Beispiel | Äquivalent zu |
|---|---|---|
| = | x = 5 | x = 5 |
| += | x += 5 | x = x + 5 |
| -= | x -= 5 | x = x – 5 |
| *= | x *= 5 | x = x * 5 |
| /= | x /= 5 | x = x / 5 |
| %= | x %= 5 | x = x % 5 |
| //= | x //= 5 | x = x // 5 |
| **= | x **= 5 | x = x ** 5 |
| &= | x &= 5 | x = x & 5 |
| |= | x |= 5 | x = x | 5 |
| ^= | x ^= 5 | x = x ^ 5 |
| >>= | x >>= 5 | x = x >> 5 |
| <<= | x <<= 5 | x = x << 5 |
Spezielle Operatoren
Die Sprache Python bietet einige spezielle Typen von Operatoren wie den Identitätsoperator oder den Zugehörigkeitsoperator. Sie werden im Folgenden mit Beispielen beschrieben.
Identity operators
is und is not sind die Identitätsoperatoren in Python. Sie werden verwendet, um zu prüfen, ob sich zwei Werte (oder Variablen) auf demselben Teil des Speichers befinden. Zwei Variablen, die gleich sind, bedeuten nicht, dass sie identisch sind.
| Operator | Bedeutung | Beispiel |
|---|---|---|
| is | True, wenn die Operanden identisch sind (beziehen sich auf dasselbe Objekt) | x ist wahr |
| is not | True, wenn die Operanden nicht identisch sind (beziehen sich nicht auf dasselbe Objekt) | x ist nicht wahr |
Beispiel 4: Identitätsoperatoren in Python
x1 = 7 y1 = 7 x2 = 'Hallo' y2 = 'Hallo' x3 = [3,4,5] y3 = [3,4,5] # Ausgabe: False print(x1 is not y1) # Ausgabe: True print(x2 is y2) # Ausgabe: False print(x3 is y3)
Output
False True False
Hier sehen wir das x1 und y1sind ganze Zahlen mit gleichen Werten, also sind sie sowohl gleich als auch identisch. Genauso ist es bei x2 und y2 (strings).
Aber x3 und y3 sind Listen. Sie sind gleich, aber nicht identisch. Dies liegt daran, dass der Interpreter sie separat im Speicher findet, obwohl sie gleich sind.
Membership operators
in und not in sind die Zugehörigkeitsoperatoren in Python. Sie werden verwendet, um zu testen, ob ein Wert oder eine Variable in einer Folge gefunden wird (string, list, tuple, set and dictionary.
In einem Wörterbuch können wir nur das Vorhandensein des Schlüssels testen, nicht den Wert.
| Operator | Meaning | Example |
|---|---|---|
| in | True, wenn Wert/Variable in der Sequenz gefunden wird | 5 in x |
| not in | True, wenn Wert/Variable in der Sequenz nicht gefunden wird | 5 not in x |
Beispiel 5: Membership operators in Python
x = 'Hello world'
y = {1:'a',2:'b'}
# Output: True
print('H' in x)
# Output: True
print('hello' not in x)
# Output: True
print(1 in y)
# Output: False
print('a' in y)
Output
True True True False
Hier, 'H' is in x aber 'hello'
ist nicht vorhanden in x
(Denken Sie daran, Python unterscheidet zwischen Groß- und Kleinschreibung). Ähnlich, 1
ist der Schlüssel und 'a' ist der Wert im Wörterbuch y.
Daher, 'a' in y kehrt zurück False.
