Namen in Python 

Die Eingabe eines Wortes führt normalerweise nur zu einer Fehlermeldung.

Eingabe eines Quelltextes und Ausgabe einer Fehlermeldung (vereinfacht und übersetzt)

Alpha

Namensfehler: Das Wort 'Alpha' ist nicht bekannt.

Aussprachehinweis

alpha ˈæl fə (Englische Aussprache)

Einige spezielle Wörter sind jedoch als Literale erlaubt.

Ein Wort, wie »credits«, kann an ein Objekt gebunden  sein. Dann ist sein Wert dieses Objekt, wenn es als Ausdruck ausgewertet wird.

Wir nennen solch ein Wort, das an ein Objekt gebunden ist, auch einen Namen.

Ein Name kann als Ausdruck verwendet werden. Seine Auswertung ergibt dann das Objekt, an das er gebunden ist.

Beispielsweise ist »credits« ein Name, der an ein Objekt gebunden ist, dessen Ausgabedarstellung ein englischsprachiger Text mit einer Danksagung ist.

Protokoll

credits

    Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands
    for supporting Python development.  See www.python.org for more information.

Eine Verwendung eines Namens als Ausdruck nennt man auch kurz eine Verwendung  jenes Namens.

Etwas vereinfacht gesagt, ist ein Name ein einfacher Ausdruck, der mit einem Buchstaben oder einem Grundstrich »_« beginnt.

Namen als lexikalische Einheiten

So wie ein Literale und fast jeder Operator, ist auch ein Name eine lexikalische Einheit. (Nur der Klammeroperator »(« und »)« besteht aus zwei  lexikalischen Einheiten.)

Groß- und Kleinschreibung

Groß- und Kleinschreibung ist signifikant. Das heißt, daß ein großes »C« ein anderes Zeichen ist als ein kleines »c« und daher »Credits« ein anderer Name als »credits« ist. Entsprechend führen Versuche der Auswertung von »Credits« normalerweise zu einer Fehlermeldung.

Protokoll

Credits

NameError: name 'Credits' is not defined

Namen für Typen

Die Namen der bisher behandelten Typen sind jeweils an ein bestimmtes Objekt gebunden, welches den benannten Typ repräsentiert.

Protokoll

str

<class 'str'>

Protokoll

int

<class 'int'>

Protokoll

float

<class 'float'>

Module

Quelltext wird zur besseren Übersicht in verschiedene Module  aufgeteilt. Meist enthält ein Modul Programmteile, die inhaltlich zusammengehören.

Ein Modul wird zur Laufzeit durch ein Objekt dargestellt, das meist einen Namen hat.

Wenn eine Python -Implementation einen Ausdruck auswertet, sieht sie diesen immer als Teil eines Moduls an.

Das Modul all der Ausdrücke, die wir bisher eingegeben haben, hat den Namen »__main__«, was soviel wie „Hauptprogramm“ bedeutet.

Der Name »__name__« ist an den Namen des Moduls gebunden, in dem er sich befindet.

Protokoll

__name__

'__main__'

Die Bindungstabelle

Jedes Modul verfügt über eine Bindungstabelle, welche zu jedem Namen das Objekt enthält, an welches er gebunden ist.

Wenn ein Name in einem Modul ausgewertet wird, wird in der Bindungstabelle des Moduls nach dem Objekt gesucht, für das der Name steht.

Ausdrücke, die in der Konsole ausgewertet werden, gehören zum Modul »__main__« und verwenden daher die Bindungstabelle des Moduls »__main__«.

Bindungstabelle (in symbolischer Darstellung)

-|--------------|-----------------|-
 | erster Name  | erstes Objekt   |
-|--------------|-----------------|-
 | zweiter Name | zweites Objekt  |
-|--------------|-----------------|-
 | dritter Name | drittes Objekt  |
-|--------------|-----------------|-
 | u.s.w.       | u.s.w.          |

Ein Objekt kann auch mehrfach in der rechten Spalte vorkommen (wenn es mehrere verschiedene Namen hat).

(Auch wenn »__main__« der korrekte Name unseres Moduls ist, kann der Name »__main__« selber derzeit in der Konsole noch nicht ausgewertet werden. Wir werden später sehen, wie der Name »__main__« ausgewertet werden kann.)

Auswertungen von Namen

Ein in der Konsole eingegebener Name gehört normalerweise zum Modul »__main__«.

Zuerst wird in der Bindungstabelle des Moduls eines Namens nach dem Namen gesucht.

Nach einem in der Konsole eingegebenen Namen wird also zuerst in der Bindungstabelle des Moduls »__main__« gesucht.

Falls der Name darin nicht gefunden wurde, wird auch noch im Modul »builtins« gesucht.

Falls der Name auch darin nicht gefunden wurde, dann kommt es zu einer Fehlermeldung.

Schritte bei der Auswertung von Namen

Suche in "__main__"
        |
        |
        | Falls nicht gefunden
        v
Suche in "builtins"
        |
        |
        | Falls nicht gefunden
        v
    NameError
 (Fehlermeldung)

Die bisher vorgestellten Namen finden sich alle im Modul »builtins«.

Syntaxdiagramm zu Atomen

Ein Name ist ein Atom.

Syntax

Atom
                 .--------------------------.
---.------------>| Literal                  |------------.--->
   |             '--------------------------'            |
   |             .--------------------------.            |
   '------------>| Name                     |------------'
   |             '--------------------------'            |
   |     .-.     .--------------------------.     .-.    |
   '--->( ( )--->| Ausdruck                 |--->( ) )---'
         '-'     '--------------------------'     '-'

Zusammenfassend sei festgehalten, daß nach dem bisher Gesagtem ein Ausdruck entweder

• ein Literal – wie »2« – oder
• ein Name – wie »__name__« – oder
• ein Operatorausdruck – wie »'[' + __name__ + ']'« – ist.

Standardnamen

Bestimmte Namen, wie »str« oder »__name__«, sind in Python schon von Anfang an definiert. Solche Namen nennen wir Standardnamen.

Dies sind Namen, die von der Standardbibliothek definiert werden.

Übungsaufgaben

/   Übungsaufgabe

Lassen Sie sich den Wert des Namens »copyright« ausgeben.

Wenn man einen Ausdruck eingibt, so wird dieser ausgewertet und anschließend wird der erhaltene Wert des Ausdrucks ausgegeben (in einer Textdarstellung). Ein Name ist ein Ausdruck.

/   Reserveaufgabe

Lassen Sie sich den Wert des Namens »__debug__« ausgeben.

Zitat aus der Sprachnorm *

The Python Language Reference, Release 3.6.0, Abschnitt 4.2.1

Names refer to objects. Names are introduced by name binding operations.

The Python Language Reference, Release 3.6.0, Abschnitt 6.2.1

When the name is bound to an object, evaluation of the atom yields that object. When a name is not bound, an attempt to evaluate it raises a NameError exception.

Von zwei Grundstrichen umrahmte Namen

Namen wie »__name__«, die mit einer Folge »__« zweier Grundstriche »_« beginnen und enden, sind Namen, die von der Python -Implementation definiert wurden oder deren Bedeutung durch Python  oder die Standardbiblothek definiert wurde. Wenn solche Namen in der Referenz von Python  nicht dokumentiert sind, dann kann man sich nicht darauf verlassen, daß sie unter anderen Python -Implementationen verfügbar sind oder sein werden. Solche Namen sind also „interne Namen“, die nicht immer ungeprüft in Programmen verwendet werden sollten. Lösungen ohne die Verwendung solcher Namen sind zu bevorzugen.

Das folgende Beispiel zeigt die Auswertung des Namens »__name__«.

Eingabe eines Ausdrucks und Ausgabe einer Textdarstellung seines Wertes

__name__

'__main__'

Aussprachehinweise

name ˈnᴇˑɪm (r)

main ˈmᴇˑɩn (r)

Man beachte, daß der Name »__name__« genauso wie sein Wert mit zwei  Grundstrichen »_« beginnt und endet und insgesamt aus acht Zeichen besteht. Im weiteren Verlaufe dieses Kurses wird nicht mehr besonders auf zwei direkt aufeinanderfolgende Grundstriche »_« hingewiesen und davon ausgegangen, daß der Leser diese an ihrer doppelten Breite erkennen kann.

Namen, die mit zwei Grundstrichen beginnen und enden, werden auch als Dunder-Namen  bezeichnet (von “double underscore ”).

Dunder-Namen haben oft besondere Bedeutungen für Python.

Da “dunder ” das Zeichenpaar »__« bedeutet, wäre »__name__« “dunder name dunder ” wird aber oft auch nur “dunder name ” gesprochen.

Sprechweisen der Bindung ⃗

Wenn ein Name an eine Objekt gebunden ist, so sagt man auch umgekehrt, daß das Objekt an den Namen gebunden sei. Jedoch kann ein Name zu einem Zeitpunkt immer nur an ein Objekt gebunden sein, während ein Objekt an mehrere Namen gebunden sein kann. Außerdem kann man nur vom Namen zum Objekt gelangen, aber nicht umgekehrt zu einem Objekt alle Namen des Objekts finden.

Das Modul »__builtins__« unter CPython  ⃗

Der Modulname »__builtins__« existiert nur in einigen Python -Implementation, wie beispielsweise CPython.

Das Modul »__builtins__« enthält Namen, die allgemein in Python -Ausdrücken verwendet werden können. Dieses Modul gehört zur Standardbibliothek von Python.

Der Name dieses Moduls ist der Python -Implementation CPython  bekannt und kann ausgewertet werden.

Eingabe eines Namens und Ausgabe einer Textdarstellung seines Wertes

__builtins__

<module 'builtins' (built-in)>

Module sind Objekte.

Das Modul »__main__« ⃗

Das Modul »__main__« enthält Namen, die mit der aktuellen Konsolensitzung verbunden sind.

»__main__« ist als ein Name zu verstehen, den wir diesem Modul geben, um von ihm sprechen zu können, der aber nicht  als Python -Ausdruck verwendet werden kann. (Erst später in diesem Kurs wird gezeigt werden können, wie »__main__« in Python  verwendet werden kann.)

Der Name dieses Moduls ist der Python -Implementation nicht direkt bekannt, daher kann er nicht direkt ausgewertet werden.

Protokoll

__main__

NamensFehler: Name '__main__' ist nicht definiert

Das Modul »__main__« ist das „Hauptprogramm“, welches auch als „Skript“ bezeichnet wird. Zu diesem Modul gehören die Zeilen, welche wir in der Konsole eingeben. Insofern ist »__main__« „unser“ Modul (das Modul unserer Eingabe / unseres Skripts).

Der Name »__name__« ⃗

Der Name »__name__« enthält den Namen des derzeit zur zur Auswertung von Namen verwendeten Moduls (also »__main__«).

Namen als Operanden ⃗

Ein Name kann auch als Operand verwendet werden, wie das folgende Beispiel mit dem Namen »__name__« zeigt.

Eingabe eines Ausdrucks und Ausgabe einer Textdarstellung seines Wertes

10 * __name__

'__main____main____main____main____main____main____main____main____main____main__'

Es können allerdings nicht alle Werte für alle Operandenstellen verwendet werden. Da der Wert des Namens »credits« nicht zum Operanden »+« paßt, kann der Name »credits« beispielsweise nicht wie »__name__« als Operand des Operators »+« verwendet werden.

Zitate zu Themen dieser Lektion ⃗

The Python Language Reference, Release 3.8.0a0

2.3.2 Reserved classes of identifiers
Certain classes of identifiers (besides keywords) have special meanings. These classes are identified by the
patterns of leading and trailing underscore characters:
_* Not imported by from module import *. The special identifier _ is used in the interactive interpreter
to store the result of the last evaluation; it is stored in the builtins module. When not in interactive
mode, _ has no special meaning and is not defined. See section The import statement.
Note: The name _ is often used in conjunction with internationalization; refer to the documentation
for the gettext module for more information on this convention.
__*__ System-defined names. These names are defined by the interpreter and its implementation (including
the standard library). Current system names are discussed in the Special method names section and
elsewhere. More will likely be defined in future versions of Python. Any use of __*__ names, in any
context, that does not follow explicitly documented use, is subject to breakage without warning.