Operatoren#
Clarity in thought, like elegance in mathematics, arises not from abundance but from precision.
— Blaise Pascal
Folien/PDF#
Anweisungen#
Bei der Programmierung schreibt man Code der formal aus einem Syntax und Semantik besteht. Dieser Code wird formal weiter unterteil in:
Eine Anweisung (engl. statement) stellt eine in dem Syntax einer Programmiersprache formulierte einzelne Vorschrift dar, die im Programm nacheinander auszuführen ist.
Eine besondere Form von Anweisungen sind Ausdrücke (engl. expression) welche immer einen Wert zurückgeben und somit einen Datentypen haben.
Ein Operator sind Teile von Ausdrücke und sind ein Symbol oder ein Schlüsselwort, das dem Compiler oder Interpreter mitteilt, eine bestimmte Operation auf Werte auszuführen.
Bei einer einer einfachen Variablenzuweisung steht der Ausdruck zum Beispiel auf der rechten Seite des Zuweisungsoperators und der Variablenname auf der linken Seite, zum Beispiel:
Variablenname = Ausdruck
Arithmetische Operatoren#
Arithmetische Operatoren führen die bekannten mathematischen Operationen aus. Sie werden mit numerischen Werten verwendet, um allgemeine mathematische Operationen auszuführen.
Operator |
Beispiel |
Wirkung |
|---|---|---|
Addition |
|
|
Subtraktion |
|
|
Multiplikation |
|
|
Division |
|
|
Ganzzahl-Division |
|
|
Modulo-Operator |
|
|
Potenzierung |
|
|
Zuweisungsperatoren#
Zuweisungsoperatoren weisen Variablen Werte zu. Python verwendet für alle arithmetischen Operatoren die abkürzende Zuweisung, es gibt jedoch keine Inkrementierung oder Dekrementierung wie in anderen Sprachen.
Bei der Zuweisung x = y wird der Wert der Variablen y (rechte Seite) der Variablen x (linke Seite) zugewiesen. Bei abkürzenden Zuweisungen wird jeweils eine Operation auf dem Wert einer Variablen ausgeführt und dieser neue Wert erneut der Variablen zugewiesen.
Operator |
Beispiel |
Wirkung |
|---|---|---|
Zuweisung |
|
Variable |
Abkürzende Addition |
|
|
Abkürzende Multiplikation |
|
|
Abkürzende Division |
|
|
Abkürzende Ganzzahl-Division |
|
|
Abkürzende Modulo |
|
|
Anwendung von Zuweisungs- und arithmetischen Operatoren#
Operatoren werden in Programmiersprachen verwendet um zwei oder mehrere Werte oder Variablen miteinander zu verknüpfen. Die arithmetischen Operatoren *, -, *, / aus der Mathematik gibt es auch in Python.
a = 1 + 1
print(a)
2
Die Operationen funktionieren genauso mit Variablen oder gemischt.
a = a + 1
print(a)
3
In diesem Beispiel ist die erste Eingangsvariable a identisch mit der Ergebnisvariable. In diesem Fall bietet Python auch die Kurzform an wo der Operator vor dem Zuweisungsoperator =
a += 1
print(a)
4
a *= 2
print(a)
8
Hierbei bestimmen Klammern auch die Berechnungsreihenfolge, genauso wie in der Mathematik und können das Ergebnis beeinflussen. So, sind die folgenden beiden Ausdrücke nicht identisch:
c1 = (6 + a) * (-2)
print(c1)
-28
c2 = 6 + a * -2
print(c2)
-10
Vergleichsoperatoren#
Vergleichsoperatoren vergleichen zwei Werte und liefern wahr oder falsch als Ergebnis. Zum Beispiel testet a == b ob a gleich b ist, und liefert je nachdem wahr oder falsch zurück, und a != b testet, ob a ungleich b ist.
Vergleichsoperatoren verknüpfen zwei Variablen / Werte, und das Ergebnis wird als wahr oder falsch ausgewertet.
Bei der Zuweisung x = y wird der Wert der Variablen y (rechte Seite) der Variablen x (linke Seite) zugewiesen. Bei abkürzenden Zuweisungen wird jeweils eine Operation auf dem Wert einer Variablen ausgeführt und dieser neue Wert erneut der Variablen zugewiesen.
Operator |
Beispiel |
Wirkung |
|---|---|---|
Gleich |
|
wahr, wenn |
Ungleich |
|
wahr, wenn |
Größer |
|
wahr, wenn |
Kleiner |
|
wahr, wenn |
Größer gleich |
|
wahr, wenn |
Kleiner gleich |
|
wahr, wenn |
Identitätsoperatoren#
Identitätsoperatoren vergleichen Objekte. Falls z.B. x = [1, 2, 3] gilt, also x eine Liste ist, dann liefert type(x) is list wahr, und type(x) is not list ist falsch. Sie prüfen dabei, ob zwei Objekte auf denselben Speicherbereich zeigen. x is y gibt wahr zurück, wenn beide Variablen dasselbe Objekt sind, d.h. auf denselben Speicherbereich zeigen.
Operator |
Beispiel |
Wirkung |
|---|---|---|
Gleich |
|
wahr, wenn beide Variablen dasselbe Objekt sind. |
Nicht gleich |
|
wahr, wenn die Variablen nicht dasselbe Objekt sind. |
Logische Operatoren#
Logische Operatoren kombinieren boolesche Ausdrücke, die dann als wahr oder falsch ausgewertet werden. Z.B. wird hier die Variable is_teenager = (alter > 13) and (alter < 19) als wahr ausgewertet, wenn der Wert der Variablen alter gleich 14 ist.
P und Q stehen für logische Ausdrücke, z.B. P = (x > 10) und Q = (x < 20).
Operator |
Beispiel |
Wirkung |
|---|---|---|
Logisches Und |
|
Gibt wahr (1) zurück, wenn die Ausdrücke |
Logisches Oder |
|
Gibt wahr (1) zurück, wenn einer der Ausdrücke |
Logische Verneinung |
|
Verneint den Ausdruck |
Anwendung von Vergleichs- und Logischen Operatoren#
Um zu prüfen, ob der Wert zweier Variablen gleich ist, wird in den meisten Programmiersprachen nicht das Gleichheitszeichen = verwendet, das es dort meist als Zuweisungsoperator definiert ist (und somit die erste Variable überschreiben würde). In Python nutzt man deshalb ein doppeltes Gleichheitszeichen == (mathematisch für exakt das gleiche). In unserem Beispiel ist c1 nicht gleich c2, also die folgende Aussage falsch.
c1 == c2
False
Für Ungleichheit wird in Python der != Operator verwendet
c1 != c2
True
Auch die mathematischen Operatoren für kleiner <, kleiner gleich ≤, größer <, und größer gleich ≥ werden unterstützt
c1 < c2
True
c1 <= c2
True
c1 > c2
False
c1 >= c2
False
Boolesche (logische) Werte werden in Python nicht durch die üblichen Operatoren für UND &, ODER |, NOT ~ kombiniert, sondern als and, or, not ausgeschrieben. Das Größergleich ≥ ist z.B. identisch mit der Bedingung
c1 > c2 or c1 == c2
False
Bitweise Operatoren#
Bitweise Operatoren führen bitweise Operationen auf ganzzahligen Operanden aus. D.h. die Operanden werden in ihre bitweise Darstellung konvertiert, z.B. x = 5 = 0101, y = 3 = 0011, und dann wird jedes Bit im Operanden x mit dem Bit an der passenden Position im Operanden y verknüpft.
Operator |
Beispiel |
Wirkung |
|---|---|---|
Bitweises Und |
|
Ergebnisbit ist 1, wenn beide Bits 1 sind. |
Bitweises Oder |
|
Ergebnisbit ist 1, wenn mindestens eines der Bits 1 ist. |
Bitweises Entweder-Oder (XOR) |
|
Ergebnisbit ist 1, wenn genau eines der Bits 1 ist. |
Bitweises Nicht |
|
Gibt das Einerkomplement von |
Shift-right |
|
Bits in |
Shift-left |
|
Bits in |
Die üblichen logischen Operatoren UND &, ODER |, sowie XOR ^ sind für bitweise Verknüpfung reserviert. Dies benutzt man nur sehr selten, bei bestimmten Berechnungen oder beim Masking.
a = 10 # binär 1010
b = 4 # binär 0100
c = a & b
print(c) # binär 0000
0
c = a | b
print(c) # binär 1110
14
Mit den Linksverschiebungs- << und Rechtsverschiebungs-Operatoren >> lassen sich auch sehr schnelle Berechnungen realisieren. Eine Multiplikation mit 4 ist zum Beispiel eine Linksverschiebung um 2, eine Division um 4 hingegen eine Rechtsverschiebung um 2. Dies nuten Compiler intern, um Berechnungen zu optimieren.
c = a << 2
print(c)
40
d = c >> 2
print(d)
10
Überladen von Operatoren#
Die arithmetischen Operatoren + und - sind in Python überladen, d.h. man kann sie auch auf nicht numerische Datentypen anwenden. Um mehrere Strings zu verbinden kann man zum Beispiel schreiben:
satz = "Der "+ "Ball " + "ist " + "rund."
print(satz)
Der Ball ist rund.
Dies funktioniert auch für Listen
liste1 = [1,2,3]
liste2 = [2,3,4]
liste12 = liste1 + liste2
print(liste12)
[1, 2, 3, 2, 3, 4]
oder als Subtraktion für Mengen
menge1 = {1,2,3}
menge2 = {2,3,4}
menge12 = menge1 - menge2
print(menge12)
{1}
Ferner müssen bei Python beide verknüpften Werte immer den gleichen Datentypen haben. So kann man nicht, wie in Java oder JavaScript, ein String und eine Nummer kombinieren, sondern muss die Nummer zuerst in einen String konvertieren (casting).
"Der Wert ist " + 1 # geht nicht
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Cell In[22], line 1
----> 1 "Der Wert ist " + 1 # geht nicht
TypeError: can only concatenate str (not "int") to str
"Der Wert ist " + str(1) # geht
'Der Wert ist 1'
Dies hat damit zu tun, dass bestimmte Statements sonst mehrdeutig wären. So ist hier unklar, ob das Ergebnis ein String sein soll oder eine Zahl.
"1" + 1 # geht nicht
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Cell In[24], line 1
----> 1 "1" + 1 # geht nicht
TypeError: can only concatenate str (not "int") to str
Durch Casting der Werte in den richtigen Typ wird das Statement eindeutig
int("1") + 1 # geht
2
Mitgliedsoperatoren#
Mitgliedsoperatoren prüfen, ob ein Objekt Mitglied einer Liste ist, z.B. prüft 4 in [1,2,3], ob 4 in der Liste enthalten ist.
x steht hier für ein beliebiges Objekt, list für eine Auflistung.
Operator |
Beispiel |
Wirkung |
|---|---|---|
enthalten in |
|
wahr, wenn x in der Liste |
nicht enthalten |
|
wahr, wenn x nicht in der Liste |
Tips zur Anwendung#
Mathematische Operatoren haben auch eine Kurzversion die vor dem Zuweisungsoperator = stehen kann: z.B. a += 1 entspricht a = a + 1, a *= 2 ist äquivalent zu a = a*2.
i = 1
i *= 2
i *= 3
i # 6
6
Logische Operationen funktionieren meistens wie erwartet. Insbesondere >, <, >= und <=. Wie in mehreren anderen Sprachen wird Gleichheit mit doppelten Gleichheitszeichen == getestet. Ungleichheit kann mit != getestet werden, und die logische Negation ist not:
a = 1
a > 1 # False
a >= 1 # True
a == 1 # True
a != 1 # False
not a == 1 # False
False
Python unterstützt auch etwas weniger verbreitete, aber äußerst praktische Mehrweg-Vergleichsoperationen, zum Beispiel
0 < a < 2 # true
True