Operatoren in Python

Dieser Artikel erklärt Operatoren in Python.

YouTube Video

Operatoren in Python

Python verfügt über verschiedene Operatoren, die grob wie folgt kategorisiert werden können. Wir werden repräsentative Operatoren für jede Kategorie erklären.

Arithmetische Operatoren

Arithmetische Operatoren sind Operatoren, die zur Durchführung von Berechnungen mit Zahlen verwendet werden.

 1a = 10
 2b = 3
 3
 4print(f"{a} + {b} = {a + b}")     # Addition
 5print(f"{a} - {b} = {a - b}")     # Subtraction
 6print(f"{a} * {b} = {a * b}")     # Multiplication
 7print(f"{a} / {b} = {a / b}")     # Division (float)
 8print(f"6 / 3 = {6 / 3}")         # Division (float)
 9print(f"{a} // {b} = {a // b}")   # Floor Division
10print(f"{a} % {b} = {a % b}")     # Modulo (remainder)
11print(f"{a} ** {b} = {a ** b}")   # Exponentiation

• Zusätzlich zu den vier grundlegenden arithmetischen Operationen bietet Python Operatoren für Division (/), Ganzzahldivision (//), Modulo (%) und Exponentiation (**) an. Die Division gibt eine Fließkommazahl zurück, selbst wenn ganze Zahlen dividiert werden.

Zuweisungsoperatoren

Zuweisungsoperatoren werden verwendet, um Variablen Werte zuzuweisen.

 1x = 5           # x = 5
 2
 3x += 3          # x = x + 3
 4x -= 2          # x = x - 2
 5x *= 4          # x = x * 4
 6x /= 3          # x = x / 3
 7x //= 2         # x = x // 2
 8x %= 5          # x = x % 5
 9x **= 3         # x = x ** 3
10
11x = 0b1100      # x = 0b1100 (12)
12
13x &= 0b1010     # x = x & 0b1010
14x |= 0b0011     # x = x | 0b0011
15x ^= 0b0101     # x = x ^ 0b0101
16x <<= 2         # x = x << 2
17x >>= 1         # x = x >> 1
18
19print(bin(x))   # Display in binary
20print(x)        # Display in decimal
21
22# Walrus operator
23if (n := len("hello")) > 3:
24    print(f"Length is {n}")

• Zuweisungsoperatoren ermöglichen es, die Standardzuweisung mit verschiedenen Operatoren zu kombinieren, um das Ergebnis zuzuweisen.
• Der Walross-Operator (:=) ist ein Zuweisungsausdruck, der in Python 3.8 und höher verfügbar ist.
• Während die Standardzuweisung nur als Anweisung verwendet werden kann, ermöglicht der Walross-Operator die Zuweisung innerhalb eines Ausdrucks.

Vergleichsoperatoren

Vergleichsoperatoren vergleichen Werte und geben True oder False zurück.

 1a = 10
 2b = 20
 3
 4# Equal to (==)
 5print(f"{a} == {b} -> {a == b}")      # False: a and b are not equal
 6print(f"3 == 3.0 -> {3 == 3.0}")      # True: int and float with the same value are equal
 7print(f"3 == '3' -> {3 == '3'}")      # False: different types (int vs str)
 8print(f"True == 1 -> {True == 1}")    # True: True is equivalent to 1
 9print(f"False == 0 -> {False == 0}")  # True: False is equivalent to 0
10print(f"None == 0 -> {None == 0}")    # False: None is not equal to 0
11
12# Not equal to (!=)
13print(f"{a} != {b} -> {a != b}")      # True: a and b are not equal
14
15# Greater than (>)
16print(f"{b} > {a} -> {b > a}")        # True: 20 > 10
17
18# Less than (<)
19print(f"{a} < {b} -> {a < b}")        # True: 10 < 20
20
21# Greater than or equal to (>=)
22print(f"{a} >= 10 -> {a >= 10}")      # True: a is greater than or equal to 10
23
24# Less than or equal to (<=)
25print(f"{a} <= 10 -> {a <= 10}")      # True: a is less than or equal to 10

• Vergleichsoperatoren vergleichen zwei Werte auf Reihenfolge oder Gleichheit und geben als Ergebnis True oder False zurück.
• In Python sollte man beim Vergleichen unterschiedlicher Datentypen vorsichtig sein. Einige Typen können miteinander verglichen werden, aber die Ergebnisse sind möglicherweise nicht intuitiv.

Logische Operatoren

Logische Operatoren werden verwendet, um logische Ausdrücke zu kombinieren.

1x = 10
2print(x > 5 and x < 20)  # True
3print(x < 5 or x > 20)   # False
4print(not x == 10)       # False

• and ist ein logischer Operator, der nur dann True zurückgibt, wenn sowohl die linke als auch die rechte Bedingung True ist.
• or ist ein logischer Operator, der True zurückgibt, wenn entweder die linke oder die rechte Bedingung True ist.
• not ist ein logischer Operator, der den Wahrheitswert einer Bedingung umkehrt. Wenn er Wahr ist, wird er Falsch, und wenn er Falsch ist, wird er Wahr.

Vorrang von logischen Operatoren

Operatoren haben eine Vorrangregel. Dies ist die Regel, die bestimmt, welcher Operator in einem Ausdruck zuerst ausgewertet wird. Logische Operatoren werden in folgender Reihenfolge ausgewertet: not, dann and, dann or.

1result = True or False and False
2print(result)  # True
3
4result = (True or False) and False
5print(result)  # False

たとえば、

Im ersten Beispiel wird and zuerst ausgewertet, daher wird False and False zu False, und als Ergebnis wird True or False zu True. Sie können die Auswertungsreihenfolge auch mit Klammern ändern, wie im zweiten Beispiel gezeigt.

Bitweise Operatoren

Bitoperatoren führen Operationen auf Bit-Ebene durch.

 1# Sample code for bitwise operators
 2
 3# Define two integers
 4a = 5  # Binary: 0101
 5b = 3  # Binary: 0011
 6
 7# Bitwise AND
 8result_and = a & b  # Binary: 0001 -> Decimal: 1
 9print(f"{a} & {b} = {result_and}")
10
11# Bitwise OR
12result_or = a | b  # Binary: 0111 -> Decimal: 7
13print(f"{a} | {b} = {result_or}")
14
15# Bitwise XOR
16result_xor = a ^ b  # Binary: 0110 -> Decimal: 6
17print(f"{a} ^ {b} = {result_xor}")
18
19# Bitwise NOT (inverting bits)
20result_not = ~a  # Binary: -(0101 + 1) -> Decimal: -6
21print(f"~{a} = {result_not}")
22
23# Left shift
24shift_left = a << 1  # Binary: 1010 -> Decimal: 10
25print(f"{a} << 1 = {shift_left}")
26
27# Right shift
28shift_right = a >> 1  # Binary: 0010 -> Decimal: 2
29print(f"{a} >> 1 = {shift_right}")

• Sie können bitweise AND-, OR-, XOR-, NOT-Operationen sowie Bitverschiebungsoperationen durchführen. Sie können diese auch mit Zuweisungsoperatoren wie &= kombinieren.

Zugehörigkeitsoperatoren

Mitgliedschaftsoperatoren werden mit Sammlungen wie Listen und Wörterbüchern verwendet.

 1x = [1, 2, 3]
 2y = 2
 3z = 4
 4
 5print("y in x : ", y in x)  # Result is True
 6print("z in x : ", z in x)  # Result is False
 7
 8print("y not in x : ", y not in x)  # Result is False
 9print("z not in x : ", z not in x)  # Result is True
10
11text = "hello world"
12print("'world' in 'hello world' : ",      "world" in text)      # True
13print("'python' not in 'hello world' : ", "python" not in text) # True

• Der Operator in wird verwendet, um festzustellen, ob ein bestimmter Wert in einer Sequenz wie einer Liste oder einem String oder in einer Sammlung wie einem Dictionary enthalten ist.
• Der Operator not in wird verwendet, um festzustellen, ob ein bestimmter Wert nicht in einer Sequenz oder Sammlung enthalten ist.

Identitätsoperatoren

Identitätsoperatoren überprüfen die Identität von Objekten.

 1x = [1, 2, 3]
 2y = x
 3z = x.copy()
 4
 5print("x is y : ", x is y)  # Result is True
 6print("x is z : ", x is z)  # Result is False
 7
 8print("x is not y : ", x is not y)  # Result is False
 9print("x is not z : ", x is not z)  # Result is True
10
11print("x == y : ", x == y)  # Result is True
12print("x == z : ", x == z)  # Result is True

• Der Operator is prüft, ob zwei Objekte identisch sind (d.h., auf denselben Speicherort verweisen).
• Der Operator is not prüft, ob zwei Objekte verschiedene Objekte sind.
• Zum Beispiel unterscheidet sich x is y von x == y dadurch, dass Objektidentität und nicht Wertgleichheit geprüft wird.

Typüberprüfung

In Python verwendet man die Funktion isinstance(), um zu prüfen, ob ein Wert von einem bestimmten Typ ist. Man kann auch die Funktion type() verwenden, um den genauen Typ einer Variable zu überprüfen. Auch wenn dies keine Operatoren sind, sind sie grundlegende Mechanismen zur Typüberprüfung.

 1x = 10
 2print(isinstance(x, int))  # True
 3
 4y = "hello"
 5print(isinstance(y, str))  # True
 6
 7z = [1, 2, 3]
 8print(isinstance(z, list))  # True
 9
10print(type(10))        # <class 'int'>
11print(type("hello"))   # <class 'str'>
12
13print("isinstance(3, int) : ", isinstance(3, int))  # True
14print("type(3) is int : ", type(3) is int)          # True
15print("type(True) is bool : ", type(True) is bool)  # True

• isinstance() ist eine Funktion, die prüft, ob ein Objekt eine Instanz einer bestimmten Klasse oder deren Unterklasse ist.
• type() ist eine Funktion, die den exakten Typ (die Klasse) eines Objekts zurückgibt. Sie wird üblicherweise verwendet, wenn man einen strikten Typvergleich durchführen möchte.
• isinstance() berücksichtigt Vererbungsbeziehungen, während type() nur exakte Übereinstimmungen prüft.

Zusammenfassung

Bei der Verwendung jedes Operators müssen Sie entsprechend seinem Zweck und Typ sorgfältig auswählen. Da Python eine dynamisch typisierte Sprache ist, kann das Ergebnis einer Operation je nach Typ der berechneten Werte variieren.

Sie können den obigen Artikel mit Visual Studio Code auf unserem YouTube-Kanal verfolgen. Bitte schauen Sie sich auch den YouTube-Kanal an.

YouTube Video