Schlüsselworte von Python                   (C) 2016-2024 T.Birnthaler OSTC GmbH
=========================

Folgende 35/38 Worte sind SCHLÜSSELWORTE (Keywords) in Python, ihre Bedeutung
ist FIX und kann nicht geändert werden (d.h. sie sind insbesondere nicht als
BEZEICHNER von eigenen Variablen verwendbar).

Doku --> docs.python.org/3/reference/lexical_analysis.html
         docs.python.org/3/reference/lexical_analysis.html#keywords
         docs.python.org/3/reference/lexical_analysis.html#identifiers-and-keywords
         docs.python.org/3/reference/grammar.html

Funktionen zur Information über Keywords:

  help("keywords")
  import keyword
  keyword.iskeyword("for")   # --> True
  keyword.kwlist()           # --> ['False', 'None', ..., 'with', 'yield']

Soll ein Schlüsselwort trotzdem als Name einer Variablen/Funktion/Klasse/...
genutzt werden, dann als Konvention einen Unterstrich "_" anhängen (z.B. "if_").

+----------+-------------------------------------------------------------------+
| True     | Konstante "logisch wahr"   (entspricht in Rechenausdruck Wert 1)  |
| False    | Konstante "logisch falsch" (entspricht in Rechenausdruck Wert 0)  |
| None     | Konstante "unmöglicher Wert" (führt im Rechenausdruck zu Fehler)  |
+----------+-------------------------------------------------------------------+
| and      | Operator "logisch UND"  (&& gibt es nicht, & ist bitweise UND)    |
| or       | Operator "logisch ODER" (|| gibt es nicht, | ist bitweise ODER)   |
| not      | Operator "logisch NICHT" (! gibt es nicht, ~ ist bitweise NICHT)  |
+----------+-------------------------------------------------------------------+
| class    | Klasse definieren                                                 |
| def      | Funktion definieren                                               |
| lambda   | Unbenannte Funktion definieren (ein Statement = Rechenausdruck)   |
+----------+-------------------------------------------------------------------+
| global   | Globale Variable in Funktion                                      |
| nonlocal | Nichtlokale Variable in eingeschachtelter Funktion                |
| return   | Rücksprung aus Funktion                                           |
| yield    | Generator-Rückgabe (erhält Zustand im Gegensatz zu "return")      |
+----------+-------------------------------------------------------------------+
| for      | Schleife Beginn                                                   |
| while    | Schleife Beginn                                                   |
| break    | Umgebende Schleife abbrechen                                      |
| continue | Umgebende Schleife nächsten Durchlauf starten (an Anfang spring.) |
+----------+-------------------------------------------------------------------+
| if       | Fallunterscheidung Beginn                                         |
| elif     | Fallunterscheidung Mehrfachverzweigung                            |
| else     | Fallunterscheidung (auch Schleife, Ausnahmebeh., Kontext Manager) |
+----------+-------------------------------------------------------------------+
| try      | Ausnahmebehandlung Beginn                                         |
| except   | Ausnahmebehandlung Fehlerbehandlung                               |
| finally  | Ausnahmebehandlung Abschluss (optional)                           |
| raise    | Ausnahme werfen                                                   |
+----------+-------------------------------------------------------------------+
| import   | Modul-Import                                                      |
| from     | Teil von import, raise, ...                                       |
| as       | Teil von import, except, with, ...                                |
+----------+-------------------------------------------------------------------+
| in       | Objekt-Suche (Elem in Seq., Key in Dict, String in String, ...)   |
| is       | Vergleich (Objektidentität, Klassenzugehörigkeit)                 |
+----------+-------------------------------------------------------------------+
| assert   | Zusicherung prüfen (und ggf. AssertionError auslösen)             |
| del      | Name + Referenz auf Objekt löschen (Objekt selbst nicht unbedingt)|
| pass     | Leere Anweisung (syntaktisch notwendig für "leeren Block")        |
| with     | Kontext Manager (Resourcenbelegung mit automatischer Freigabe)    |
+----------+-------------------------------------------------------------------+
| async    | Koroutinen (PEP 492)                                        PY3.5 |
| await    | Koroutinen (PEP 492)                                        PY3.5 |
+----------+-------------------------------------------------------------------+
| match    | Structural Pattern Matching (PEP 622,634,635,636,642,653)   PY3.10|
| case     | Structural Pattern Matching (PEP 622,634,635,636,642,653)   PY3.10|
| _        | Structural Pattern Matching (PEP 622,634,635,636,642,653)   PY3.10|
+----------+-------------------------------------------------------------------+

HINWEIS: In Python 3.10 wurden "match", "case" und "_" als "Soft Keywords"
hinzugefügt, d.h. sie zählen nur im Kontext "Structural Pattern Matching" als
Schlüsselworte, um bereits bestehenden Code, der diese Namen verwendet, nicht
ungültig zu machen. Mit dem seit Python 3.9 eingesetzten PEG-Parser ist das
kein Problem, das Modul "keyword" enthält seit Python 3.9 die Members
"issoftkeyword()" und "swkwlist" zusätzlich zu "iskeyword()" und "kwlist".

HINWEIS: Analog wurden in Python 3.5 und 3.6 die Namen "async" und "await"
zunächst als "Soft Keywords" hinzugefügt (damals durch einen Parser-Trick), um
bestehenden Code nicht ungültig zu machen. Erst seit Python 3.7 zählen sie als
echte Schlüsselworte.

HINWEIS: Neue Schlüsselworte werden extrem selten zu Python hinzugefügt,
(gestrichen werden Schlüsselworte 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 eingebaut wird. D.h. man hat mehrere Jahre Zeit, um seinen
Code daran anzupassen.