HOWTO zu den Operatoren von Python

(C) 2016-2020 T.Birnthaler/H.Gottschalk <howtos(at)ostc.de>
              OSTC Open Source Training and Consulting GmbH
              www.ostc.de

$Id: python-operator.txt,v 1.5 2020/04/28 09:39:27 tsbirn Exp $

Dieses Dokument beschreibt die 54 Operatoren von Python und ihren Vorrang.
Die Operatoren sind von oben nach unten mit fallendem Vorrang aufgelistet
(oben stehen die Operatoren mit höchstem Vorrang, unten mit niedrigstem)

Doku --> docs.python.org/3/reference/lexical_analysis.html#operators
     --> docs.python.org/3/reference/expressions.html#operator-precedence

+====+===============================+=========================================+
|    | Operator                      | Beschreibung                            |
+====+===============================+=========================================+
|    | ( EXPR )                      | Gruppierung (kein Komma!)               |
|    | ( EXPR,... )                  | Tupel (mind. 1 Komma notwendig)         |
| 17 | [ EXPR,... ]                  | Liste                                   |
|    | { KEY:VALUE,... }             | Dictionary                              |
|    | { EXPR,...}                   | Set                                     |
+----+-------------------------------+-----------------------------------------+
|    | X[INDEX]  X[INDEX:INDEX:STEP] | Indizierung, Slicing                    |
| 16 | X(ARGS...)       X.ATTR       | Funktionsaufruf, Attribut-Referenz      |
|    | OBJ.X(ARGS...)                | Methodenaufruf für Objekt               |
+----+-------------------------------+-----------------------------------------+
| 15 | await X                       | Await Ausdruck                    PY3.5 |
| 14 | **                            | Potenzierung ("hoch")                   |
| 13 | +X   -X   ~X                  | Vorzeichen, Bitweise NOT (Tilde)        |
+----+-------------------------------+-----------------------------------------+
|    | *   @                         | Multiplikation, Matrix-Multipl. @ PY3.5 |
| 12 | /   //                        | Division, Divison 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 enthalt.|
|    | is    is not                  | Identitäts-Vergleich (Obj. identisch)   |
+----+-------------------------------+-----------------------------------------+
|  5 | not X                         | Logisch NOT                             |
|  4 | and                           | Logisch AND                             |
|  3 | or                            | Logisch OR                              |
|  2 | ... if ... else ...           | Bedingter Ausdruck                      |
|  1 | lambda ...                    | Lambda Ausdruck (unbenannte Funktion)   |
+----+-------------------------------+-----------------------------------------+
|  0 | :=                            | Zuweisungsausdruck ("Walrus")     PY3.8 |
+----+-------------------------------+-----------------------------------------+

* Alle Operatoren sind BINÄR ausser ein X steht bei einem UNÄREN Operator
  (d.h. +X   -X   ~X   not X   await X)

* 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 sind keine Operatoren und können daher
  auch KEIN Teil von Ausdrücken sein!

  +------+-------------------------------+
  |   =  | Zuweisung                     |
  +------+-------------------------------+
  |  +=  | Addition                      |
  |  -=  | Subtraktion                   |
  |  *=  | Multiplikation                |
  |  /=  | Division (Fließkomma-Ergebnis |
  | //=  | Division ohne Rest            |
  |  %=  | Divisions-Rest (Modulo)       |
  | **=  | Potenzierung                  |
  |  |=  | Bitweise ODER (auch Set!)     |
  |  &=  | Bitweise AND (auch Set!)      |
  |  ^=  | Bitweise XOR (auch Set!)      |
  | <<=  | Bitweise Shift nach links     |
  | >>=  | Bitweise Shift nach rechts    |
  |  @=  | Matrix-Multiplikation         |
  +------+-------------------------------+

* Seit Python 3.8 ist der Operator ":=" (sogenannter "Walrus"-Operator) als
  Zuweisungs-Operator in einem Ausdruck erlaubt. D.h. folgende Konstrukte
  sind damit möglich:

    if fin := open("datei.txt", "r"):
        ...

    while zeile := fin.readline():
        ...

  HINWEIS: Neue Operatoren werden extrem selten zu Python hinzugefügt,
  (gestrichen 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
  dieses Schlüsselwort verfügbar sein wird. D.h. man hat mehrere Jahre Zeit,
  um seinen Quellcode daran anzupassen.

* Folgende Sonderzeichen sind keine Operatoren, sondern "Delimiter":

  +----+-----------------------------------------------------------------------+
  | ,  | Element-Trennzeichen Tuple/List/Dict, Funktion-Def/Aufruf, ...        |
  | ;  | Abschlusszeichen Anweisung (überflüssig)                              |
  | :  | Block-Beginn, Dict-Trennzeichen, Type Hint/Annotation: VAR : TYP      |
  | -> | Type Hint/Annotation: Funktions-Ergebnis                              |
  | .  | Objekt.Attribut, Modul.Submodul.Subsub...                             |
  +----+-----------------------------------------------------------------------+
  | \  | Zeilenfortsetzung (Line Continuation, Zeile in nächster Zeile weiter) |
  | #  | Kommentarbeginn (bis Zeilenende)                                      |
  +----+-----------------------------------------------------------------------+

* String-Begrenzer sind:

  +-----------+-----------------------------------------------+
  | "     '   | String-Begrenzer (nur einzeilig)              |
  | """   ''' | String--Begrenzer (mehrzeilig erlaubt)        |
  +-----------+-----------------------------------------------+
  | b"    b'  | Binär-String  b"deadbeefaffe..."              |
  | f"    f'  | Format-String  f"...{...}..."                 |
  | r"    r'  | Raw-String (Escape-Sequenzen \X "as is")      |
  | u"    u'  | Unicode-String (Std in PY3, notwendig in PY2) |
  +-----------+-----------------------------------------------+
  | br"   rb" | Binär + Raw                                   |
  | fr"   rf" | Format + Raw                                  |
  +-----------+-----------------------------------------------+