4. Ausführungsmodell
********************


4.1. Aufbau eines Programms
===========================

Ein Python-Programm setzt sich aus Codeblöcken zusammen. Ein *Block*
ist ein Teil des Python-Programmtextes, der als Einheit ausgeführt
wird. Zu den Blöcken gehören: ein Modul, ein Funktionskörper und eine
Klassendefinition. Jeder interaktiv eingegebene Befehl ist ein Block.
Eine Skriptdatei (eine Datei, die dem Interpreter als Standardeingabe
übergeben oder als Befehlszeilenargument für den Interpreter angegeben
wird) ist ein Codeblock. Ein Skriptbefehl (ein Befehl, der in der
Befehlszeile des Interpreters mit der Option "-c" angegeben wird) ist
ein Codeblock. Ein Modul, das als Skript der obersten Ebene (als Modul
"__main__" ) über die Befehlszeile mit dem Argument "-m" ausgeführt
wird, ist ebenfalls ein Codeblock. Das an die integrierten Funktionen
"eval()" und "exec()" übergebene Zeichenfolgenargument ist ein
Codeblock.

Ein Codeblock wird in einem *Ausführungsrahmen* ausgeführt. Ein Rahmen
enthält einige Verwaltungsinformationen (die zur Fehlersuche dienen)
und legt fest, wo und wie die Ausführung fortgesetzt wird, nachdem die
Ausführung des Codeblocks abgeschlossen ist.


4.2. Benennung und Zuordnung
============================


4.2.1. Namensbindung
--------------------

*Namen* beziehen sich auf Objekte. Namen werden durch
Namensbindungsoperationen eingeführt.

Die folgenden Konstrukte binden Namen:

* Formale Parameter von Funktionen,

* Klassendefinitionen,

* Funktionsdefinitionen,

* Zuweisungsausdrücke,

* Ziele, die als Bezeichner gelten, wenn sie in einer Zuweisung
  vorkommen:

  * "for" Schleifenkopf,

  * nach "as" in einer "with" -Anweisung, einer "except" -Klausel,
    einer "except*" -Klausel oder im "as"-Muster beim strukturellen
    Musterabgleich,

  * in einem Erfassungsmuster beim strukturellen Musterabgleich

* "import" Aussagen.

Die Anweisung "import" in der Form "from ... import *" bindet alle im
importierten Modul definierten Namen, mit Ausnahme derjenigen, die mit
einem Unterstrich beginnen. Diese Form darf nur auf Modulebene
verwendet werden.

Ein Ziel, das in einer Anweisung vom Typ "del" vorkommt, gilt für
diesen Zweck ebenfalls als gebunden (auch wenn die eigentliche
Semantik darin besteht, die Bindung des Namens aufzuheben).

Jede Zuweisungs- oder Importanweisung erfolgt innerhalb eines Blocks,
der durch eine Klassen- oder Funktionsdefinition definiert ist, oder
auf Modulebene (dem Code-Block der obersten Ebene).

If a name is bound in a block, it is a local variable of that block,
unless declared as "nonlocal" or "global".  If a name is bound at the
module level, it is a global variable.  (The variables of the module
code block are local and global.)  If a variable is used in a code
block but not defined there, it is a *free variable*.

Jedes Vorkommen eines Namens im Programmtext bezieht sich auf die
*Bindung* dieses Namens, die durch die folgenden
Namensauflösungsregeln festgelegt wird.


4.2.2. Namensauflösung
----------------------

Ein *Gültigkeitsbereich* legt fest, in welchem Umfang ein Name
innerhalb eines Blocks sichtbar ist. Wird eine lokale Variable in
einem Block definiert, erstreckt sich ihr Gültigkeitsbereich auf
diesen Block. Erfolgt die Definition in einem Funktionsblock,
erstreckt sich der Gültigkeitsbereich auf alle Blöcke, die in dem
definierenden Block enthalten sind, es sei denn, ein darin enthaltener
Block führt eine andere Bindung für den Namen ein.

Wenn ein Name in einem Codeblock verwendet wird, wird er anhand des
nächstgelegenen übergeordneten Gültigkeitsbereichs aufgelöst. Die
Menge aller solcher Gültigkeitsbereiche, die für einen Codeblock
sichtbar sind, wird als *Umgebung* des Blocks bezeichnet.

Wenn ein Name überhaupt nicht gefunden wird, wird eine Ausnahme vom
Typ "NameError" ausgelöst. Handelt es sich beim aktuellen
Gültigkeitsbereich um einen Funktionsbereich und bezieht sich der Name
auf eine lokale Variable, die an der Stelle, an der der Name verwendet
wird, noch nicht mit einem Wert belegt wurde, wird eine Ausnahme vom
Typ "UnboundLocalError" ausgelöst. "UnboundLocalError" ist eine
Unterklasse von "NameError" .

Wenn irgendwo innerhalb eines Codeblocks eine Namensbindung
stattfindet, werden alle Verwendungen des Namens innerhalb des Blocks
als Verweise auf den aktuellen Block behandelt. Dies kann zu Fehlern
führen, wenn ein Name innerhalb eines Blocks verwendet wird, bevor er
gebunden wurde. Diese Regel ist nicht ganz einfach zu verstehen.
Python kennt keine Deklarationen und erlaubt es, dass
Namensbindungsoperationen an beliebiger Stelle innerhalb eines
Codeblocks stattfinden.  Die lokalen Variablen eines Codeblocks lassen
sich ermitteln, indem der gesamte Text des Blocks auf
Namensbindungsoperationen durchsucht wird. Beispiele finden Sie im
FAQ-Eintrag zu UnboundLocalError.

If the "global" statement occurs within a block, all uses of the names
specified in the statement refer to the bindings of those names in the
top-level namespace.  Names are resolved in the top-level namespace by
searching the global namespace, i.e. the namespace of the module
containing the code block, and the builtins namespace, the namespace
of the module "builtins".  The global namespace is searched first.  If
the names are not found there, the builtins namespace is searched.
The "global" statement must precede all uses of the listed names.

Die Anweisung "global" hat denselben Geltungsbereich wie eine
Namensbindung im selben Block. Wenn der nächstübergeordnete
Geltungsbereich einer freien Variablen eine globale Anweisung enthält,
wird die freie Variable als globale Variable behandelt.

The "nonlocal" statement causes corresponding names to refer to
previously bound variables in the nearest enclosing function scope.
"SyntaxError" is raised at compile time if the given name does not
exist in any enclosing function scope.

Der Namensraum für ein Modul wird automatisch angelegt, sobald das
Modul zum ersten Mal importiert wird. Das Hauptmodul eines Skripts
heißt immer "__main__" .

Class definition blocks and arguments to "exec()" and "eval()" are
special in the context of name resolution. A class definition is an
executable statement that may use and define names. These references
follow the normal rules for name resolution with an exception that
unbound local variables are looked up in the global namespace. The
namespace of the class definition becomes the attribute dictionary of
the class. The scope of names defined in a class block is limited to
the class block; it does not extend to the code blocks of methods --
this includes comprehensions and generator expressions since they are
implemented using a function scope.  This means that the following
will fail:

   class A:
       a = 42
       b = list(a + i for i in range(10))


4.2.3. Eingebaute Funktionen und eingeschränkte Ausführung
----------------------------------------------------------

**CPython-Implementierungsdetail:** Benutzer sollten "__builtins__"
nicht ändern; es handelt sich dabei ausschließlich um ein
Implementierungsdetail. Benutzer, die Werte im Namespace "builtins"
überschreiben möchten, sollten das Modul "builtins" über "import"
laden und dessen Attribute entsprechend anpassen.

Der mit der Ausführung eines Codeblocks verbundene
"builtins"-Namensraum wird tatsächlich durch Abfrage des Namens
"__builtins__" in dessen globalem Namensraum ermittelt; dabei sollte
es sich um ein Wörterbuch oder ein Modul handeln (im letzteren Fall
wird das Wörterbuch des Moduls verwendet).  Standardmäßig ist
"__builtins__" im Modul "__main__" das eingebaute Modul "builtins" ;
in jedem anderen Modul ist "__builtins__" ein Alias für das Wörterbuch
des Moduls "builtins" selbst.


4.2.4. Interaktion mit dynamischen Funktionen
---------------------------------------------

Die Auflösung freier Variablen erfolgt zur Laufzeit und nicht zur
Kompilierungszeit. Das bedeutet, dass der folgende Code 42 ausgibt:

   i = 10
   def f():
       print(i)
   i = 42
   f()

Die Funktionen "eval()" und "exec()" haben keinen Zugriff auf die
vollständige Umgebung zur Namensauflösung.  Namen können im lokalen
und globalen Namensraum des Aufrufers aufgelöst werden. Freie
Variablen werden nicht im nächstübergeordneten Namensraum, sondern im
globalen Namensraum aufgelöst. [1] Die Funktionen "exec()" und
"eval()" verfügen über optionale Argumente, um den globalen und
lokalen Namensraum zu überschreiben. Wird nur ein Namensraum
angegeben, wird dieser für beide verwendet.


4.3. Ausnahmen
==============

Ausnahmen dienen dazu, den normalen Kontrollfluss eines Codeblocks zu
unterbrechen, um Fehler oder andere Ausnahmebedingungen zu behandeln.
Eine Ausnahme wird an der Stelle *ausgelöst*, an der der Fehler
erkannt wird; sie kann vom umgebenden Codeblock oder von jedem
Codeblock *behandelt* werden, der den Codeblock, in dem der Fehler
aufgetreten ist, direkt oder indirekt aufgerufen hat.

Der Python-Interpreter löst eine Ausnahme aus, wenn er einen
Laufzeitfehler (wie beispielsweise eine Division durch Null)
feststellt. Ein Python-Programm kann zudem mit der Anweisung "raise"
explizit eine Ausnahme auslösen. Ausnahmebehandler werden mit der
Anweisung "try"... "except" festgelegt.  Die Klausel "finally" einer
solchen Anweisung kann verwendet werden, um Aufräumcode anzugeben, der
die Ausnahme nicht behandelt, sondern unabhängig davon ausgeführt
wird, ob im vorangehenden Code eine Ausnahme aufgetreten ist oder
nicht.

Python verwendet das "Termination"-Modell der Fehlerbehandlung: Ein
Ausnahmebehandler kann zwar feststellen, was passiert ist, und die
Ausführung auf einer übergeordneten Ebene fortsetzen, aber er kann die
Fehlerursache nicht beheben und den fehlgeschlagenen Vorgang nicht
wiederholen (außer durch erneutes Ausführen des fehlerhaften
Codeabschnitts von Anfang an).

Wird eine Ausnahme überhaupt nicht abgefangen, bricht der Interpreter
die Ausführung des Programms ab oder kehrt zu seiner interaktiven
Hauptschleife zurück. In beiden Fällen gibt er einen Stack-Traceback
aus, es sei denn, es handelt sich um die Ausnahme "SystemExit" .

Ausnahmen werden anhand von Klasseninstanzen identifiziert. Die
Klausel "except" wird je nach Klasse der Instanz ausgewählt: Sie muss
auf die Klasse der Instanz oder auf eine *nicht-virtuelle Basisklasse*
derselben verweisen. Die Instanz kann vom Handler empfangen werden und
zusätzliche Informationen über die Ausnahmebedingung enthalten.

Bemerkung:

  Ausnahmemeldungen sind nicht Teil der Python-API. Ihr Inhalt kann
  sich von einer Python-Version zur nächsten ohne Vorwarnung ändern,
  weshalb sich Code, der unter mehreren Versionen des Interpreters
  ausgeführt wird, nicht darauf verlassen sollte.

Siehe auch die Beschreibung der Anweisung "try" im Abschnitt Die  try
Anweisung und der Anweisung "raise" im Abschnitt Die raise Anweisung.

-[ Fußnoten ]-

[1] Diese Einschränkung ergibt sich daraus, dass der Code, der durch
    diese Operationen ausgeführt wird, zum Zeitpunkt der Kompilierung
    des Moduls noch nicht verfügbar ist.
