Bezeichner-Konventionen (Identifier) (C) 2017-2024 T.Birnthaler OSTC GmbH
====================================
Doku --> docs.python.org/dev/peps/pep-0008
www.pep8.org
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
BEZEICHNER (IDENTIFIER) in Python gehorchen den üblichen Regeln in jeder
Programmiersprache:
* Ab 1. Zeichenposition BUCHSTABEN "A-Z" "a-z" und "_" erlaubt
* Ab 2. Zeichenposition ZIFFERN "0-9" zusätzlich erlaubt
* Außer UNTERSTRICH "_" keine Sonderzeichen (z.B. Operatoren + - * /) erlaubt
* LEERZEICHEN nicht erlaubt (Unterstrich "_" dient als Ersatz)
Besonderheiten von Python:
* Groß/Kleinschreibung wird unterschieden
(da unter UNIX/Linux üblich und Python unter UNIX/Linux entstanden ist)
* Punkt "." dient zum Strukturieren von "Qualifizierten" Namen
(d.h. dem Zugriff auf Namen in anderen Namensräumen)
* Beim "import" von Modul-Dateien wird der Punkt "." in einen
Verzeichnis-Trenner (je nach Betriebssystem "\", "/", ":") umgesetzt
* MODULNAMEN sind gleichzeitig auch Bezeichner von NAMENSRÄUMEN!
--> DÜRFEN keine Sonderzeichen/Leerzeichen/... enthalten
(am Besten nur "a-z" und "_" sowie "0-9" ab dem 2. Zeichen!)
--> Aus Portabilitätsgründen auch auf Groß/Kleinschreibung verzichten
(nur klein schreiben)
Empfehlung:
* Alle UNICODE-Buchstaben sind zwar erlaubt (z.B. Umlaute "äöüÄÖÜ" und "ß"
und griechische/kyrillische Buchstaben, chinesische Schriftzeichen, ...)
--> Wegen Portabilität/internationaler Verständlichkeit darauf verzichten!
Folgende Konventionen für Bezeichner (Identifier) gelten in Python:
+-----------+------------------------------------------------------------------+
| NAME | BEDEUTUNG |
+-----------+------------------------------------------------------------------+
| __xxx__ | INTERNER Name ("dunder name", reserviert für Python selbst) |
+-----------+------------------------------------------------------------------+
| __xxx | PRIVATER Name in Klasse/Objekt (mangled --> _CLASS__xxx) |
| _xxx | PROTECTED Name in Klasse/Objekt (im Zshg. mit Vererbung nutzbar) |
| xxx | PUBLIC Name in Klasse/Objekt (für alle von außen nutzbar) |
+-----------+------------------------------------------------------------------+
| self | Objekt in normaler Methode (1. Standard-Parameter) |
| other | Zweites Objekt in 2-wertiger normaler Methode (z.B. "__eq__") |
| cls | Klasse in Klassen-Methode (1. Standard-Parameter) |
+-----------+------------------------------------------------------------------+
| _xxx | INTERNER Name in MODUL (nur für modulinterne Zwecke gedacht |
| __xxx | --> Von "from MODULE import *" nicht importiert |
| | --> Hilfsklasse, Hilfsfunktion, Hilfsvariable, ... |
| xxx_ | Schlüsselwort als Bezeichner nutzen (z.B. "if_", "for_", ...) |
+-----------+------------------------------------------------------------------+
| *_ | "Wegwerfvariable" (sammelt beim *-Packing überflüssige Werte) |
| _ | "Wegwerfvariable" (syntaktisch notwendig, inhaltlich irrelevant) |
| _ | Internationalisierung (i18n, l10n, gettext) |
| _ | Ergebnis letzte Auswertung im interaktiven Interpreter ">>>" |
+-----------+------------------------------------------------------------------+
| *args | Sammelt restliche POSITIONS-PARAMETER in Funktion (--> Tupel) |
| **kwargs | Sammelt restliche KEYWPRD-PARAMETER in Funktion (--> Dictionary) |
+-----------+-------------------+------------------------------+---------------+
| XXX | Konstante | TrumpCase Unterstrich Ziffer | Subst Adj -- |
| Xxx | Klasse/Datentyp | CamelCase -- Ziffer | Subst Adj -- |
| XxxError | Exception | CamelCase -- Ziffer | Subst -- -- |
| xxx | Modul | SmallCase -- Ziffer | Subst -- -- |
| xxx_... | Variable/Attribut | SnakeCase Unterstrich Ziffer | Subst -- -- |
| xxx_... | Funktion/Methode | SnakeCase Unterstrich Ziffer | -- -- Verb|
| xxx_... | Objekt/Instanz | SnakeCase Unterstrich Ziffer | Subst -- -- |
+-----------+-------------------+------------------------------+---------------+
| NAME | BEDEUTUNG | REGEL + ERLAUBTE ZEICHEN | WORTART |
+-----------+-------------------+------------------------------+---------------+
camelCase = EINZELNE Großbst. (zur Strukturierung) + KEIN Unterstrich +
klein-Bbst. + Ziffern (1. Zeichen klein)
CamelCase = Analog camelCase (1. Zeichen GROSS statt klein)
PascalCase = Analog camelCase (1. Zeichen GROSS statt klein)
kebap-case = Minus "-" statt Unterstrich "_" + NUR klein-Bbst.
(in Python nicht möglich)
TRUMPCASE = NUR GROSS-Bst + Ziffern + KEIN Unterstrich
SCREAMING_SNAKE_CASE = Analog TRUMPCASE + Unterstrich (zur Strukturierung)
smallcase = NUR klein-Bst + Ziffern + KEIN Unterstrich
snake_case = NUR klein-Bst + Ziffern + Unterstrich (zur Strukturierung)
Title Case = 1. Bbst. jedes Wortes GROSS + Rest klein + Leerzeichen als Trennzeichen
(in Python nicht möglich)
Train-Case = 1. Bbst. jedes Wortes GROSS + Rest klein + Bindestrich "-" statt Unterstrich "_"
(in Python nicht möglich)
Sentence case = Analog Title Case (nur 1. Bst. weniger Worte GROSS)
(in Python nicht möglich)
HINWEIS: Aus historischen Gründen gibt es Ausnahmen bei Konstanten-Benennung:
(z.B. True, False, None, math.pi, math.e, math.inf, math.nan, ...)
Ebenso bei der Datentyp/Klassen-Benennung:
(z.B. bool, int, float, complex, str, tuple, list, set, dict, ...)
QUALIFIZIERTE Namen werden durch "." getrennt (der "." wird beim Zugriff auf
das Dateisystem in den jeweiligen Verz.-Trenner "\" oder "/" umgesetzt).
MODUL.VARIABLE # Zugriff auf Variable in Modul
MODUL.FUNKTION() # Aufruf von Funktion in Modul
PAKET.SUBMODUL.VARIABLE # Zugriff auf Variable in Paket-Untermodul
PAKET.SUBMODUL.FUNKTION() # Aufruf von Funktion in Paket-Untermodul
PFAD.ZU.MODUL.VARIABLE # Zugriff auf Variable in Modul in Unterverzeichnis
PFAD.ZU.MODUL.FUNKTION() # Aufruf von Funktion in Modul in Unterverzeichnis
Komponenten von Klassen und Objekten (Attribute, Methoden) werden ebenfalls
durch "." im Namen angesprochen:
OBJEKT.ATTRIBUT # Zugriff auf Attribut von Objekt
OBJEKT.METHODE() # Aufruf von Methode für Objekt
KLASSE.ATTRIBUT # Zugriff auf Klassen-Attribut
KLASSE.METHODE() # Aufruf von Klassen-Methode oder statischer Methode
FUNKTION.ATTRIBUT # Zugriff auf Funktions-Attribut
Spezielle Attribute
-------------------
Spezielle Attribute, werden teilweise von der built-in Funktion "dict()" nicht
aufgelistet, wohl aber von der Funktion "dir()".
+------------------+-----------------------------------------------------------+
| Attribut | Beschreibung |
+------------------+-----------------------------------------------------------+
| __doc__ | Dokumentationsstring ("Docstring") |
| __name__ | Name Klasse/Funktion/Methode/Descriptor/Generator-Instanz |
| __qualname__ | Qualifizierter Name Klasse/.../Generator-Instanz |
| __module__ | Modul in dem Objekt definiert ist |
| __all__ | In __init__.py automatisch zu importierende Submodule bei |
| | from MODUL import * |
+------------------+-----------------------------------------------------------+
| __call__ | Code-Objekt einer Funktion |
| __defaults__ | Tuple mit Defaultwerten für Position-Parameter von Funk. |
| __kwdefaults__ | Dictionary mit Defaultwerten für Keyword-Parameter von F. |
| __annotations__ | Dictionary mit Annotations für Param. + Rückgabewert von F|
| __closure__ | Bindungen freier Variablen an Werte zu einer Funktion |
+------------------+-----------------------------------------------------------+
| __mro__ | Tupel der Basisklassen für Methodenauflösung (linear) |
| mro() | Liefert Ergebnis für __mro__ bei Klassen-Instanziierung |
| __subclasses__() | Liste schwacher Referenzen zu direkten Unterklassen |
+------------------+-----------------------------------------------------------+
| __class__ | Klasse zu der eine Instanz gehört |
| __bases__ | Tupel der Basisklassen eines Klassenobjekts |
| __dict__ | Speicher für dynamische Objektattribute (Name + Wert) |
| __slots__ | Namen der statische Objektattribute (__dict__ entfällt) |
| __weakref__ | "Schwache" Referenzen |
+------------------+-----------------------------------------------------------+
| __globals__ | Referenz zu Dictionary mit globalen Variablen |
+------------------+-----------------------------------------------------------+
| __self__ | Objekt auf dem eine Methode arbeitet |
| __func__ | Funktion die hinter einer Methode steckt (implementiert) |
+------------------+-----------------------------------------------------------+
Spezielle Methoden