(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.2 2020/03/31 00:59:56 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  !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                   |
  | //=  | Division ohne Rest         |
  |  %=  | Divisions-Rest (Modulo)    |
  | **=  | Potenz-Operation           |
  |  |=  | Bitweise ODER (auch Set!)  |
  |  &=  | Bitweise AND (auch Set!)   |
  |  ^=  | Bitweise XOR (auch Set!)   |
  | <<=  | Bitweise Shift nach links  |
  | >>=  | Bitweise Shift nach rechts |
  |  @=  | Matrix-Multiplikation      |
  +------+----------------------------+

* 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                                  |
  +-----------+-----------------------------------------------+