HOWTO zu den Operatoren von Python
(C) 2016-2025 T.Birnthaler/H.Gottschalk <howtos(at)ostc.de>
OSTC Open Source Training and Consulting GmbH
www.ostc.de
Dieses Dokument beschreibt die 55 Operatoren von Python und ihren Vorrang. Die
Operatoren sind von oben nach unten mit fallendem Vorrang aufgelistet (OBEN
stehen die Operatoren mit HÖHEREM VORRANG, UNTEN stehen diejenigen mit
NIEDRIGEREM VORRANG).
Doku --> docs.python.org/3/reference/expressions.html
docs.python.org/3/reference/expressions.html#operator-precedence
docs.python.org/3/reference/lexical_analysis.html#operators
HINWEIS: Bis Python 3.8 war die Vorrangtabelle der Operatoren in der Python
Dokumentation "aufsteigend" dargestellt (d.h. niedriger Vorrang oben, hoher
Vorrang unten). Seit Python 3.9 wir diese Tabelle "absteigend" dargestellt
(d.h. hoher Vorrang oben, niedriger Vorrang unten).
+====+=============================+===========================================+
| | Operator | Beschreibung |
+====+=============================+===========================================+
| | ( EXPR ) | Gruppierung (kein Komma!) |
| | ( EXPR,... ) | Tupel (mind. 1 Komma notwendig) |
| 17 | [ EXPR,... ] | Liste |
| | { KEY:VALUE,... } | Dictionary |
| | { EXPR,...} | Set |
+----+-----------------------------+-------------------------------------------+
| | X[INDEX] X[BEGIN:END:STEP] | Indizierung, Slicing |
| 16 | X(ARGS...) X.ATTR | Funktionsaufruf, Attribut-Referenz |
| | OBJ.X(ARGS...) | Methodenaufruf für Objekt |
+----+-----------------------------+-------------------------------------------+
| 15 | await X | Await Ausdruck (asynchrone Prog.) PY3.5 |
| 14 | ** | Potenzierung ("hoch") |
| 13 | +X -X ~X | Vorzeichen, Bitweise INVERT (Tilde) |
+----+-----------------------------+-------------------------------------------+
| | * @ | Multiplikation, Matrix-Multipl. @ PY3.5 |
| 12 | / // | FK-Division, GZ-Div. ohne Rest // PY2.2 |
| | % | Divisions-Rest (Modulo) |
+----+-----------------------------+-------------------------------------------+
| 11 | + - | Addition, Subtraktion (Diff bei Set) |
| 10 | << >> | Bitweise Shift nach links + rechts |
| 9 | & | Bitweise AND (Schnittmenge bei Set) |
| 8 | ^ | Bitweise XOR (Symm. Diff. bei Set) |
| 7 | | | Bitweise OR (Vereinigung bei Set) |
+----+-----------------------------+-------------------------------------------+
| 6 | < <= > >= == != | Wert-Vergleich (Werte gleich) |
| | in not in | Elem/String in Container/String enthalten |
| | is is not | Identitäts-Vergleich (Obj. identisch) |
+----+-----------------------------+-------------------------------------------+
| 5 | not X | Logisch NOT |
| 4 | and | Logisch AND |
| 3 | or | Logisch OR |
| 2 | EXPR1 if COND else EXPR2 | Bedingter Ausdruck |
| 1 | lambda EXPR | Lambda Ausdruck (unbenannte Funktion) |
+----+-----------------------------+-------------------------------------------+
| 0 | := | Zuweisungsausdruck ("Walrus") PY3.8 |
+----+-----------------------------+-------------------------------------------+
* Es gibt ZWEI Divisionen, Modulo "%" liefert Rest bei ganzzahliger Division
(FK=Fließkomma, GZ=Ganzzahl):
11 / 4 # --> 2.75 (Fließkomma-Division)
11 // 4 # --> 2 (Ganzzahl-Division ohne Rest)
11 % 4 # --> 3 (Rest bei Ganzzahl-Division)
* Alle Operatoren in obiger Tabelle sind BINÄR außer ein X (Variable) steht
bei UNÄREN Operatoren (d.h. +X, -X, ~X, not X, await X)
* Vorrang/Precedence: Gemischte Op. werden gemäß Vorrangtabelle ausgewertet:
1 & 2 | ~3 < 1 + 2 * 4 ** 5 # Ohne Klammern ergibt sich die
((1 & 2) | (~3)) < (1 + (2 * (3 ** 4))) # Reihenfolge wie mit Klammern
* Assoziativität: ALLE Operatoren gruppieren von LINKS NACH RECHTS,
AUSSER dem Potenz-Operator "**", er gruppiert von RECHTS NACH LINKS:
1 + 2 + 3 + 4 + 5 # analog ((((1 + 2) + 3) + 4) + 5)
1 - 2 - 3 - 4 - 5 # analog ((((1 - 2) - 3) - 4) - 5)
1 * 2 * 3 * 4 * 5 # analog ((((1 * 2) * 3) * 4) * 5)
1 / 2 / 3 / 4 / 5 # analog ((((1 / 2) / 3) / 4) / 5)
1 ** 2 ** 3 ** 4 ** 5 # analog (1 ** (2 ** (3 ** (4 ** 5))))
* Zuweisung "=" und verkürzte Zuweisung "OP=" sind KEINE Operatoren!
Sie können daher auch KEIN Teil von Ausdrücken sein und haben KEINEN Vorrang!
Durch sie wird ein NAME per REFERENZ an ein OBJEKT/einen WERT gebunden.
+------+------------------------------------------------------------+
| = | Zuweisung |
+------+------------------------------------------------------------+
| += | Addition |
| -= | Subtraktion (Differenz bei Set) |
| *= | Multiplikation |
| /= | Division (Fließkomma-Ergebnis) |
| //= | Division ohne Rest (Ganzzahliges Ergebnis) |
| %= | Divisions-Rest (Modulo) |
| **= | Potenzierung |
+------+------------------------------------------------------------+
| |= | Bitweise ODER (Vereinigung bei Set, auch Dict seit PY3.9!) |
| &= | Bitweise AND (Schnittmenge bei Set) |
| ^= | Bitweise XOR (Symmetrische Differenz bei Set) |
| <<= | Bitweise Shift nach links |
| >>= | Bitweise Shift nach rechts |
+------+------------------------------------------------------------+
| @= | Matrix-Multiplikation PY3.5 |
+------+------------------------------------------------------------+
* Seit Python 3.8 ist der Operator ":=" (Assignment Expression, auch
"Walrus"-Operator) als ZUWEISUNGS-OPERATOR in einem AUSDRUCK (Expression)
erlaubt. D.h. folgende Konstrukte sind damit möglich:
if fin := open("datei.txt", "r"):
...
while zeile := fin.readline():
...
Eine einfache Zuweisung damit ist allerdings syntaktisch nicht erlaubt:
fin := open("datei.txt", "r") # SyntaxError: invalid syntax
fin = open("datei.txt", "r") # OK
(fin := open("datei.txt", "r")) # OK
* Folgende Syntax ist erlaubt/verboten:
a = 123 # OK --> 123
a == 123 # OK --> True (Ergebnis wird verworfen)
erg = a == 123 # OK --> True
erg == a = 123 # SyntaxError: cannot assign to comparison
erg = a + 3 # OK --> 126
erg := a + 3 # SyntaxError: invalid syntax
(erg := a + 3) # OK --> 126
erg := (a + 3) # SyntaxError: invalid syntax
print(erg := a + 3) # OK --> 126
erg = erg := a + 3 # SyntaxError: invalid syntax
erg = (erg := a + 3) # OK --> 126
erg = erg = a + 3 # OK --> 126
erg := erg = a + 3 # SyntaxError: invalid syntax
* HINWEIS: Neue Operatoren werden extrem selten zu Python hinzugefügt,
(entfernt werden Operatoren gar nicht). Bevor so etwas passiert, wird
auf jeden Fall ein PEP erstellt, es findet eine Diskussion und eine
Abstimmung/Entscheidung sowie die Festlegung der Python-Version statt,
ab der dieser Operator eingebaut wird. D.h. man hat mehrere Jahre Zeit,
um seinen Quellcode daran anzupassen.
* Folgende Sonderzeichen sind keine Operatoren, sondern "Delimiter":
+----+-----------------------------------------------------------------------+
| , | Element-Trennzeichen Tuple/List/Set/Dict, Funktion-Def/Aufruf, ... |
| ; | Abschlusszeichen Anweisung (überflüssig) |
| : | Block-Beginn, Dict-Trennzeichen, Type Hint/Annotation VAR : TYP |
| -> | Type Hint/Annotation Funktions-Ergebnis-Typ |
| . | Qualified Name: Objekt.Attribut, Modul.SubModul.SubSubModul... |
+----+-----------------------------------------------------------------------+
| \ | Zeilenfortsetzung (Line Continuation, Zeile in nächster Zeile weiter) |
| # | Kommentarbeginn (bis Zeilenende) |
+----+-----------------------------------------------------------------------+
* String-Begrenzer sind (die Präfixe können auch groß geschrieben werden):
+-----------+--------------------------------------------------------------+
| " ' | Unicode-String (nur einzeilig) |
| """ ''' | Unicode-String (mehrzeilig erlaubt) |
+-----------+--------------------------------------------------------------+
| b" b' | Byte/Binär-String b"deadbeefaffe..." |
| f" f' | Format-String mit Platzhaltern f"...{...}..." |
| r" r' | Raw-String ("\" ist normales Zeichen, keine Escape-Sequenzen |
| u" u' | Unicode-String (Std in PY3, notwendig in PY2) |
+-----------+--------------------------------------------------------------+
| br" rb" | Binär + Raw |
| fr" rf" | Format + Raw |
+-----------+--------------------------------------------------------------+