7. Einfache Anweisungen
***********************

Eine einfache Anweisung besteht aus einer einzigen logischen Zeile. In
einer Zeile können mehrere einfache Anweisungen vorkommen, die durch
Semikolons voneinander getrennt sind. Die Syntax für einfache
Anweisungen lautet:

   simple_stmt ::= expression_stmt
                   | assert_stmt
                   | assignment_stmt
                   | augmented_assignment_stmt
                   | annotated_assignment_stmt
                   | pass_stmt
                   | del_stmt
                   | return_stmt
                   | yield_stmt
                   | raise_stmt
                   | break_stmt
                   | continue_stmt
                   | import_stmt
                   | future_stmt
                   | global_stmt
                   | nonlocal_stmt
                   | type_stmt


7.1. Ausdrucksanweisungen
=========================

Ausdrucksanweisungen werden (meist interaktiv) verwendet, um einen
Wert zu berechnen und auszugeben oder (in der Regel) um eine Prozedur
aufzurufen (eine Funktion, die kein aussagekräftiges Ergebnis
zurückgibt; in Python geben Prozeduren den Wert "None" zurück). Andere
Verwendungszwecke von Ausdrucksanweisungen sind zulässig und
gelegentlich nützlich. Die Syntax für eine Ausdrucksanweisung lautet:

   expression_stmt ::= starred_expression

Eine Ausdrucksanweisung wertet die Ausdrucksliste aus (die aus einem
einzigen Ausdruck bestehen kann).

Im interaktiven Modus wird der Wert, sofern er nicht "None" lautet,
mithilfe der integrierten Funktion "repr()" in eine Zeichenkette
umgewandelt, und die resultierende Zeichenkette wird in einer eigenen
Zeile in die Standardausgabe geschrieben (es sei denn, das Ergebnis
lautet "None", sodass Prozeduraufrufe keine Ausgabe verursachen).


7.2. Zuweisungsanweisungen
==========================

Zuweisungsanweisungen dienen dazu, Namen (erneut) mit Werten zu
verknüpfen und Attribute oder Elemente veränderbarer Objekte zu
ändern:

   assignment_stmt ::= (target_list "=")+ (starred_expression | yield_expression)
   target_list     ::= target ("," target)* [","]
   target          ::= identifier
                       | "(" [target_list] ")"
                       | "[" [target_list] "]"
                       | attributeref
                       | subscription
                       | slicing
                       | "*" target

(See section Primäre Funktionen for the syntax definitions for
*attributeref*, *subscription*, and *slicing*.)

Eine Zuweisungsanweisung wertet die Ausdrucksliste aus (beachte, dass
es sich dabei um einen einzelnen Ausdruck oder eine durch Kommas
getrennte Liste handeln kann, wobei Letztere ein Tupel ergibt) und
weist das einzelne resultierende Objekt nacheinander von links nach
rechts jeder der Ziellisten zu.

Assignment is defined recursively depending on the form of the target
(list). When a target is part of a mutable object (an attribute
reference, subscription or slicing), the mutable object must
ultimately perform the assignment and decide about its validity, and
may raise an exception if the assignment is unacceptable.  The rules
observed by various types and the exceptions raised are given with the
definition of the object types (see section Die Standardtyp-
Hierarchie).

Die Zuordnung eines Objekts zu einer Zielliste, die optional in runde
oder eckige Klammern gesetzt ist, wird rekursiv wie folgt definiert.

* Wenn die Zielliste aus einem einzelnen Ziel ohne abschließendes
  Komma besteht, das optional in Klammern steht, wird das Objekt
  diesem Ziel zugewiesen.

* Sonst:

  * Wenn die Zielliste ein Ziel enthält, dem ein Sternchen
    vorangestellt ist (ein sogenanntes "mit Sternchen markiertes";
    Ziel): Das Objekt muss eine iterierbare Struktur sein, die
    mindestens so viele Elemente enthält, wie es Ziele in der
    Zielliste gibt, minus eins.  Die ersten Elemente des iterierbaren
    Objekts werden von links nach rechts den Zielen vor dem mit einem
    Sternchen gekennzeichneten Ziel zugewiesen. Die letzten Elemente
    des iterierbaren Objekts werden den Zielen nach dem mit einem
    Sternchen gekennzeichneten Ziel zugewiesen. Anschließend wird dem
    mit einem Sternchen gekennzeichneten Ziel eine Liste der
    verbleibenden Elemente des iterierbaren Objekts zugewiesen (die
    Liste kann leer sein).

  * Andernfalls: Das Objekt muss eine iterierbare Struktur sein, deren
    Anzahl an Elementen der Anzahl der Ziele in der Zielliste
    entspricht, und die Elemente werden von links nach rechts den
    entsprechenden Zielen zugewiesen.

Die Zuordnung eines Objekts zu einem einzelnen Ziel wird rekursiv wie
folgt definiert.

* Wenn das Ziel ein Bezeichner (Name) ist:

  * Wenn der Name in keinem "global" - oder "nonlocal" -Befehl im
    aktuellen Codeblock vorkommt, wird der Name an das Objekt im
    aktuellen lokalen Namensraum gebunden.

  * Andernfalls: Der Name ist an das Objekt im globalen Namensraum
    bzw. in dem durch "nonlocal" festgelegten äußeren Namensraum
    gebunden.

  Der Name wird neu gebunden, falls er bereits gebunden war. Dies kann
  dazu führen, dass die Referenzanzahl für das zuvor an diesen Namen
  gebundene Objekt auf Null sinkt, wodurch das Objekt freigegeben und
  sein Destruktor (sofern vorhanden) aufgerufen wird.

* Wenn das Ziel eine Attributreferenz ist: Der primäre Ausdruck in der
  Referenz wird ausgewertet. Er sollte ein Objekt mit zuweisbaren
  Attributen ergeben; ist dies nicht der Fall, wird die Ausnahme
  "TypeError" ausgelöst. Dieses Objekt wird dann aufgefordert, das
  zugewiesene Objekt dem angegebenen Attribut zuzuweisen; kann es die
  Zuweisung nicht durchführen, löst es eine Ausnahme aus (in der
  Regel, aber nicht zwangsläufig "AttributeError" ).

  Hinweis: Handelt es sich bei dem Objekt um eine Klasseninstanz und
  erscheint die Attributreferenz auf beiden Seiten des
  Zuweisungsoperators, kann der Ausdruck auf der rechten Seite, "a.x",
  entweder auf ein Instanzattribut oder (falls kein Instanzattribut
  vorhanden ist) auf ein Klassenattribut zugreifen.  Das Ziel auf der
  linken Seite, "a.x", wird immer als Instanzattribut gesetzt und bei
  Bedarf angelegt. Daher beziehen sich die beiden Vorkommen von "a.x"
  nicht unbedingt auf dasselbe Attribut: Wenn sich der Ausdruck auf
  der rechten Seite auf ein Klassenattribut bezieht, legt die linke
  Seite ein neues Instanzattribut als Ziel der Zuweisung an:

     class Cls:
         x = 3             # class variable
     inst = Cls()
     inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

  Diese Beschreibung gilt nicht unbedingt für Deskriptorattribute, wie
  beispielsweise Eigenschaften, die mit "@property" erstellt wurden.

* If the target is a subscription: The primary expression in the
  reference is evaluated.  It should yield either a mutable sequence
  object (such as a list) or a mapping object (such as a dictionary).
  Next, the subscript expression is evaluated.

  Wenn das Primärobjekt ein veränderbliches Sequenzobjekt (wie
  beispielsweise eine Liste) ist, muss der Index eine ganze Zahl
  ergeben. Ist er negativ, wird die Länge der Sequenz dazu addiert.
  Der resultierende Wert muss eine nicht-negative Ganzzahl sein, die
  kleiner ist als die Länge der Sequenz, und die Sequenz wird
  aufgefordert, das zugewiesene Objekt ihrem Element mit diesem Index
  zuzuweisen.  Liegt der Index außerhalb des zulässigen Bereichs, wird
  eine Ausnahmel "IndexError" ausgelöst (die Zuweisung zu einer
  indizierten Sequenz darf keine neuen Elemente zu einer Liste
  hinzufügen).

  Wenn es sich bei dem Primärwert um ein Zuordnungsobjekt (z. B. ein
  Wörterbuch) handelt, muss der Index einen Typ haben, der mit dem
  Schlüsseltyp der Zuordnung kompatibel ist, und die Zuordnung wird
  dann aufgefordert, ein Schlüssel-Wert-Paar zu erstellen, das den
  Index dem zugewiesenen Objekt zuordnet.  Dies kann entweder ein
  vorhandenes Schlüssel-Wert-Paar mit demselben Schlüsselwert ersetzen
  oder ein neues Schlüssel-Wert-Paar einfügen (sofern kein Schlüssel
  mit demselben Wert existierte).

  For user-defined objects, the "__setitem__()" method is called with
  appropriate arguments.

* If the target is a slicing: The primary expression in the reference
  is evaluated.  It should yield a mutable sequence object (such as a
  list).  The assigned object should be a sequence object of the same
  type.  Next, the lower and upper bound expressions are evaluated,
  insofar they are present; defaults are zero and the sequence's
  length.  The bounds should evaluate to integers. If either bound is
  negative, the sequence's length is added to it.  The resulting
  bounds are clipped to lie between zero and the sequence's length,
  inclusive.  Finally, the sequence object is asked to replace the
  slice with the items of the assigned sequence.  The length of the
  slice may be different from the length of the assigned sequence,
  thus changing the length of the target sequence, if the target
  sequence allows it.

**CPython-Implementierungsdetail:** In the current implementation, the
syntax for targets is taken to be the same as for expressions, and
invalid syntax is rejected during the code generation phase, causing
less detailed error messages.

Obwohl die Definition der Zuweisung impliziert, dass Überschneidungen
zwischen der linken und der rechten Seite "gleichzeitig" stattfinden
(beispielsweise tauscht "a, b = b, a" zwei Variablen aus), erfolgen
Überschneidungen *innerhalb* der Menge der Variablen, denen Werte
zugewiesen werden, von links nach rechts, was manchmal zu Verwirrung
führt. So gibt beispielsweise das folgende Programm "[0, 2]" aus

   x = [0, 1]
   i = 0
   i, x[i] = 1, 2         # Zuerst wird i aktualisiert, dann x[i]
   print(x)

Siehe auch:

  **PEP 3132** - Erweitertes Entpacken von Iterables
     Die Spezifikation für die Funktion "*target" .


7.2.1. Erweiterte Zuweisungsanweisungen
---------------------------------------

Eine erweiterte Zuweisung ist die Kombination einer binären Operation
und einer Zuweisungsanweisung in einer einzigen Anweisung:

   augmented_assignment_stmt ::= augtarget augop (expression_list | yield_expression)
   augtarget                 ::= identifier | attributeref | subscription | slicing
   augop                     ::= "+=" | "-=" | "*=" | "@=" | "/=" | "//=" | "%=" | "**="
                                 | ">>=" | "<<=" | "&=" | "^=" | "|="

(Die Syntaxdefinitionen der letzten drei Symbole finden Sie im
Abschnitt Primäre Funktionen .)

Bei einer erweiterten Zuweisung werden das Ziel (das im Gegensatz zu
normalen Zuweisungsanweisungen kein Entpacken sein darf) und die
Ausdrucksliste ausgewertet, die für den Zuweisungstyp spezifische
binäre Operation auf die beiden Operanden angewendet und das Ergebnis
dem ursprünglichen Ziel zugewiesen. Das Ziel wird nur einmal
ausgewertet.

Eine erweiterte Zuweisungsanweisung wie "x += 1" lässt sich als "x = x
+ 1" umschreiben, um einen ähnlichen, wenn auch nicht exakt gleichen
Effekt zu erzielen. In der erweiterten Version wird "x" nur einmal
ausgewertet. Außerdem wird die eigentliche Operation, sofern möglich,
*in-place* ausgeführt, was bedeutet, dass nicht ein neues Objekt
erstellt und diesem dem Ziel zugewiesen wird, sondern stattdessen das
alte Objekt geändert wird.

Im Gegensatz zu normalen Zuweisungen wird bei erweiterten Zuweisungen
die linke Seite *vor* der rechten Seite ausgewertet. Beispielsweise
wird bei "a[i] += f(x)" zunächst "a[i]" nachgeschlagen, anschließend
wird  "f(x)" ausgewertet und die Addition durchgeführt, und
schließlich wird das Ergebnis wieder in "a[i]" geschrieben.

Mit Ausnahme der Zuweisung an Tupel und mehrere Ziele in einer
einzigen Anweisung wird die durch erweiterte Zuweisungsanweisungen
vorgenommene Zuweisung genauso behandelt wie normale Zuweisungen.
Ebenso entspricht die durch erweiterte Zuweisungsanweisungen
ausgeführte binäre Operation – mit Ausnahme des möglichen *In-
Place*-Verhaltens – den normalen binären Operationen.

Für Ziele, bei denen es sich um Attributverweise handelt, gilt
dieselbe Einschränkung bezüglich Klassen- und Instanzattributen wie
bei regulären Zuweisungen.


7.2.2. Kommentierte Zuweisungsanweisungen
-----------------------------------------

*Annotations*-Zuweisung ist die Kombination einer Variablen- oder
Attribut-Annotation mit einer optionalen Zuweisungsanweisung in einer
einzigen Anweisung:

   annotated_assignment_stmt ::= augtarget ":" expression
                                 ["=" (starred_expression | yield_expression)]

Der Unterschied zu Zuweisungsanweisungen besteht darin, dass nur ein
einziges Ziel zulässig ist.

The assignment target is considered "simple" if it consists of a
single name that is not enclosed in parentheses. For simple assignment
targets, if in class or module scope, the annotations are evaluated
and stored in a special class or module attribute "__annotations__"
that is a dictionary mapping from variable names (mangled if private)
to evaluated annotations. This attribute is writable and is
automatically created at the start of class or module body execution,
if annotations are found statically.

If the assignment target is not simple (an attribute, subscript node,
or parenthesized name), the annotation is evaluated if in class or
module scope, but not stored.

Wird ein Name in einem Funktionsbereich mit einer Annotation versehen,
so ist dieser Name für diesen Bereich lokal. Annotationen werden in
Funktionsbereichen niemals ausgewertet und gespeichert.

If the right hand side is present, an annotated assignment performs
the actual assignment before evaluating annotations (where
applicable). If the right hand side is not present for an expression
target, then the interpreter evaluates the target except for the last
"__setitem__()" or "__setattr__()" call.

Siehe auch:

  **PEP 526** - Syntax für Variablenanmerkungen
     Der Vorschlag, der eine Syntax zur Annotation der Typen von
     Variablen (einschließlich Klassen- und Instanzvariablen)
     einführte, anstatt diese über Kommentare auszudrücken.

  **PEP 484** - Typhinweise
     Der Vorschlag, mit dem das Modul "typing" hinzugefügt wurde, um
     eine Standardsyntax für Typannotationen bereitzustellen, die in
     statischen Analysewerkzeugen und IDEs verwendet werden kann.

Geändert in Version 3.8: Bei kommentierten Zuweisungen sind nun
dieselben Ausdrücke auf der rechten Seite zulässig wie bei regulären
Zuweisungen. Bisher führten einige Ausdrücke (wie beispielsweise
Tupelausdrücke ohne Klammern) zu einem Syntaxfehler.


7.3. Die "assert" Anweisung
===========================

"Prüf"-Anweisungen (Assert) sind eine praktische Möglichkeit,
Debugging-Prüfungen in ein Programm einzufügen:

   assert_stmt ::= "assert" expression ["," expression]

Die einfache Form "assert expression" entspricht folgendem Ausdruck:

   if __debug__:
       if not expression: raise AssertionError

Die erweiterte Form "assert expression1, expression2" entspricht

   if __debug__:
       if not expression1: raise AssertionError(expression2)

Diese Äquivalenzen setzen voraus, dass sich "__debug__" und
"AssertionError" auf die eingebauten Variablen mit diesen Namen
beziehen. In der aktuellen Implementierung ist die eingebaute Variable
"__debug__" unter normalen Umständen "True" und "False", wenn eine
Optimierung angefordert wird (Befehlszeilenoption "-O"). Der aktuelle
Codegenerator erzeugt keinen Code für eine "assert" -Anweisung, wenn
die Optimierung zur Kompilierungszeit angefordert wird.  Beachten Sie,
dass es nicht erforderlich ist, den Quellcode für den fehlgeschlagenen
Ausdruck in die Fehlermeldung aufzunehmen; dieser wird als Teil des
Stack-Traces angezeigt.

Zuweisungen an "__debug__" sind unzulässig. Der Wert der integrierten
Variablen wird beim Start des Interpreters festgelegt.


7.4. Die "pass" Anweisung
=========================

   pass_stmt ::= "pass"

"pass" ist eine Nulloperation – bei ihrer Ausführung passiert nichts.
Sie eignet sich als Platzhalter, wenn syntaktisch eine Anweisung
erforderlich ist, aber kein Code ausgeführt werden muss, zum Beispiel:

   def f(arg): pass    # eine Funktion, die (noch) nichts tut

   class C: pass       # eine Klasse (bisher) ohne Methoden


7.5. Die "del" Anweisung
========================

   del_stmt ::= "del" target_list

Die Löschung wird rekursiv definiert, ganz ähnlich wie die Zuweisung.
Anstatt hier auf alle Einzelheiten einzugehen, hier einige Hinweise.

Durch das Löschen einer Zielliste werden alle Ziele rekursiv von links
nach rechts gelöscht.

Durch das Löschen eines Namens wird die Bindung dieses Namens aus dem
lokalen oder globalen Namensraum entfernt, je nachdem, ob der Name in
einer ` "global" -Anweisung im selben Codeblock vorkommt. Der Versuch,
einen ungebundenen Namen zu löschen, löst eine "NameError" -Ausnahme
aus.

Deletion of attribute references, subscriptions and slicings is passed
to the primary object involved; deletion of a slicing is in general
equivalent to assignment of an empty slice of the right type (but even
this is determined by the sliced object).

Geändert in Version 3.2: Bisher war es nicht zulässig, einen Namen aus
dem lokalen Namensraum zu löschen, wenn er als freie Variable in einem
verschachtelten Block vorkommt.


7.6. Die "return" Anweisung
===========================

   return_stmt ::= "return" [expression_list]

"return" darf nur syntaktisch in einer Funktionsdefinition
verschachtelt vorkommen, nicht jedoch innerhalb einer verschachtelten
Klassendefinition.

Ist eine Ausdrucksliste vorhanden, wird diese ausgewertet; andernfalls
wird  "None" eingesetzt.

"return" beendet den aktuellen Funktionsaufruf mit der Ausdrucksliste
(oder ""None" ". als Rückgabewert.

Wenn "return" die Kontrolle aus einer "try" -Anweisung mit einer
"finally" -Klausel abgibt, wird diese  "finally" -Klausel ausgeführt,
bevor die Funktion tatsächlich verlassen wird.

In einer Generatorfunktion gibt die Anweisung "return" an, dass der
Generator fertig ist, und löst die Ausnahme "StopIteration" ; aus. Der
zurückgegebene Wert (falls vorhanden) wird als Argument für die
Erstellung von  "StopIteration" verwendet und wird zum Attribut
"StopIteration.value" .

In einer asynchronen Generatorfunktion zeigt eine leere "return"
-Anweisung an, dass der asynchrone Generator beendet ist, und führt
dazu, dass eine "StopAsyncIteration" -Ausnahme ausgelöst wird. Eine
nicht leere  "return" -Anweisung stellt in einer asynchronen
Generatorfunktion einen Syntaxfehler dar.


7.7. Die "yield" Anweisung
==========================

   yield_stmt ::= yield_expression

Eine Anweisung vom Typ  "yield" ist semantisch äquivalent zu einem
Yield-Ausdruck. Mit der Anweisung  "yield" lassen sich die Klammern
weglassen, die andernfalls in der entsprechenden Yield-Ausdruck-
Anweisung erforderlich wären. Beispielsweise die Yield-Anweisungen

   yield <expr>
   yield from <expr>

entsprechen den folgenden "yield"-Anweisungen

   (yield <expr>)
   (yield from <expr>)

Yield-Ausdrücke und -Anweisungen werden ausschließlich bei der
Definition einer *Generator*-Funktion verwendet und kommen nur im
Körper der Generatorfunktion zum Einsatz. Die Verwendung von "yield"
in einer Funktionsdefinition reicht aus, um zu bewirken, dass diese
Definition eine Generatorfunktion anstelle einer normalen Funktion
erzeugt.

Ausführliche Informationen zur Semantik von "yield" findest du im
Abschnitt Yield Ausdrücke .


7.8. Die "raise" Anweisung
==========================

   raise_stmt ::= "raise" [expression ["from" expression]]

Sind keine Ausdrücke vorhanden, löst "raise" die Ausnahme erneut aus,
die derzeit abgefangen wird – diese wird auch als *aktive Ausnahme*
bezeichnet. Ist derzeit keine aktive Ausnahme vorhanden, wird die
Ausnahme "RuntimeError" ausgelöst, um anzuzeigen, dass es sich um
einen Fehler handelt.

Andernfalls wertet "raise" den ersten Ausdruck als Ausnahmeobjekt aus.
Es muss sich dabei entweder um eine Unterklasse oder eine Instanz von
"BaseException". Handelt es sich um eine Klasse, wird die
Ausnahmeinstanz bei Bedarf durch Instanziierung der Klasse ohne
Argumente abgerufen.

Der *type* der Ausnahme ist die Klasse der Ausnahminstanz, der *value*
ist die Instanz selbst.

Ein Traceback-Objekt wird normalerweise automatisch erstellt, wenn
eine Ausnahme ausgelöst wird, und dieser als Attribut "__traceback__"
zugeordnet. Du kannst eine Ausnahme erstellen und in einem Schritt
dein eigenes Traceback festlegen, indem du die Ausnahmemethode
"with_traceback()" verwendest (die dieselbe Ausnahminstanz zurückgibt,
wobei deren Traceback auf das übergebene Argument gesetzt wird), und
zwar wie folgt:

   raise Exception("foo occurred").with_traceback(tracebackobj)

Die Klausel "from" wird für die Ausnahmekettenbildung verwendet: Falls
angegeben, muss der zweite *Ausdruck* eine weitere Ausnahmeklasse oder
-instanz sein. Handelt es sich bei dem zweiten Ausdruck um eine
Ausnahmeninstanz, wird diese der ausgelösten Ausnahme als Attribut
"__cause__" (das beschreibbar ist) hinzugefügt. Ist der Ausdruck eine
Ausnahmeklasse, wird die Klasse instanziiert und die resultierende
Ausnahmeinstanz der ausgelösten Ausnahme als Attribut  "__cause__"
hinzugefügt. Wird die ausgelöste Ausnahme nicht abgefangen, werden
beide Ausnahmen ausgegeben:

   >>> try:
   ...     print(1 / 0)
   ... except Exception as exc:
   ...     raise RuntimeError("Something bad happened") from exc
   ...
   Traceback (most recent call last):
     File "<stdin>", line 2, in <module>
       print(1 / 0)
             ~~^~~
   ZeroDivisionError: division by zero

   The above exception was the direct cause of the following exception:

   Traceback (most recent call last):
     File "<stdin>", line 4, in <module>
       raise RuntimeError("Something bad happened") from exc
   RuntimeError: Something bad happened

Ein ähnlicher Mechanismus greift implizit, wenn eine neue Ausnahme
ausgelöst wird, während bereits eine Ausnahme abgefangen wird. Eine
Ausnahme kann abgefangen werden, wenn eine "except" - oder "finally"
-Klausel oder eine "with" -Anweisung verwendet wird. Die vorherige
Ausnahme wird dann als Attribut "__context__" der neuen Ausnahme
angehängt:

   >>> try:
   ...     print(1 / 0)
   ... except:
   ...     raise RuntimeError("Something bad happened")
   ...
   Traceback (most recent call last):
     File "<stdin>", line 2, in <module>
       print(1 / 0)
             ~~^~~
   ZeroDivisionError: division by zero

   During handling of the above exception, another exception occurred:

   Traceback (most recent call last):
     File "<stdin>", line 4, in <module>
       raise RuntimeError("Something bad happened")
   RuntimeError: Something bad happened

Die Ausnahmekettenbildung kann explizit unterbunden werden, indem in
der "from" -Klausel "None" angegeben wird:

   >>> try:
   ...     print(1 / 0)
   ... except:
   ...     raise RuntimeError("Something bad happened") from None
   ...
   Traceback (most recent call last):
     File "<stdin>", line 4, in <module>
   RuntimeError: Something bad happened

Weitere Informationen zu Ausnahmen findest du im Abschnitt Ausnahmen,
Informationen zur Behandlung von Ausnahmen im Abschnitt Die  try
Anweisung.

Geändert in Version 3.3: "None" ist nun unter "Y" in "raise X from Y"
zulässig.Das Attribut "__suppress_context__" wurde hinzugefügt, um die
automatische Anzeige des Ausnahmekontexts zu unterdrücken.

Geändert in Version 3.11: Wird der Traceback der aktiven Ausnahme in
einer "except" -Klausel geändert, löst eine nachfolgende "raise"
-Anweisung die Ausnahme mit dem geänderten Traceback erneut aus.
Bisher wurde die Ausnahme mit dem Traceback ausgelöst, den sie zum
Zeitpunkt ihrer Abfangung hatte.


7.9. Die Erklärung der "break" Anweisung.
=========================================

   break_stmt ::= "break"

"break" dürfen syntaktisch nur in einer  "for" - oder  "while"
-Schleife verschachtelt vorkommen, jedoch nicht in einer Funktions-
oder Klassendefinition innerhalb dieser Schleife.

Sie beendet die nächstgelegene umschließende Schleife und überspringt
dabei die optionale Klausel  "else", falls die Schleife eine solche
enthält.

Wird eine  "for" -Schleife durch "break" beendet, behält das
Schleifensteuerungsziel seinen aktuellen Wert bei.

Wenn  "break" die Kontrolle aus einer  "try" -Anweisung mit einer
"finally" -Klausel abgibt, wird diese "finally" -Klausel ausgeführt,
bevor die Schleife tatsächlich verlassen wird.


7.10. Die  "continue" Anweisung
===============================

   continue_stmt ::= "continue"

"continue" darf syntaktisch nur in einer  "for" - oder  "while"
-Schleife verschachtelt vorkommen, jedoch nicht in einer Funktions-
oder Klassendefinition innerhalb dieser Schleife. Es wird mit dem
nächsten Zyklus der nächstübergeordneten Schleife fortgesetzt.

Wenn  "continue" die Steuerung aus einer  "try" -Anweisung mit einer
"finally" -Klausel abgibt, wird diese "finally" -Klausel ausgeführt,
bevor der nächste Schleifenzyklus tatsächlich beginnt.


7.11. Die  "import" Anweisung
=============================

   import_stmt     ::= "import" module ["as" identifier] ("," module ["as" identifier])*
                       | "from" relative_module "import" identifier ["as" identifier]
                       ("," identifier ["as" identifier])*
                       | "from" relative_module "import" "(" identifier ["as" identifier]
                       ("," identifier ["as" identifier])* [","] ")"
                       | "from" relative_module "import" "*"
   module          ::= (identifier ".")* identifier
   relative_module ::= "."* module | "."+

Die einfache IMPORT-Anweisung (ohne  "from" -Klausel) wird in zwei
Schritten ausgeführt:

1. ein Modul suchen und es gegebenenfalls laden und initialisieren

2. Definiert einen oder mehrere Namen im aktuellen Namensraum für den
   Gültigkeitsbereich, in dem die Anweisung  "import" auftritt, genau
   wie es eine Zuweisungsanweisung tun würde (einschließlich der
   Semantik von "global" und  "nonlocal") .

Wenn die Anweisung mehrere Klauseln enthält (die durch Kommas getrennt
sind), werden die beiden Schritte für jede Klausel separat ausgeführt,
so als wären die Klauseln in einzelne *import*-Anweisungen aufgeteilt
worden.

Die Einzelheiten des ersten Schritts – das Auffinden und Laden von
Modulen  werden im Abschnitt über das Import-System ausführlicher
beschrieben. Dort werden auch die verschiedenen Arten von Paketen und
Modulen erläutert, die importiert werden können, sowie alle Hooks, mit
denen sich das Import-System anpassen lässt. Beachte, dass Fehler in
diesem Schritt entweder darauf hindeuten können, dass das Modul nicht
gefunden werden konnte, *oder* dass bei der Initialisierung des Moduls
ein Fehler aufgetreten ist, wozu auch die Ausführung des Modulcodes
gehört.

Wird das angeforderte Modul erfolgreich abgerufen, wird es auf eine
von drei Arten im lokalen Namensraum bereitgestellt:

* Folgt auf den Modulnamen  "as", wird der Name nach  "as" direkt an
  das importierte Modul gebunden.

* Wenn kein anderer Name angegeben wird und es sich bei dem
  importierten Modul um ein Modul der obersten Ebene handelt, wird der
  Name des Moduls im lokalen Namensraum als Verweis auf das
  importierte Modul gebunden.

* Wenn es sich bei dem importierten Modul *nicht* um ein Modul der
  obersten Ebene handelt, wird der Name des Pakets der obersten Ebene,
  das das Modul enthält, im lokalen Namensraum als Verweis auf dieses
  Paket der obersten Ebene gebunden. Der Zugriff auf das importierte
  Modul muss über dessen vollqualifizierten Namen erfolgen und nicht
  direkt.

Das Formular  "from" sieht einen etwas komplexeren Ablauf vor:

1. das in der Klausel  "from" angegebene Modul suchen und es
   gegebenenfalls laden und initialisieren;

2. für jeden der in den  "import" -Klauseln angegebenen Bezeichner:

   1. Prüfe, ob das importierte Modul ein Attribut mit diesem Namen
      hat

   2. Falls nicht, versuche ein Submodul mit diesem Namen zu
      importieren, und überprüfe anschließend das importierte Modul
      erneut auf dieses Attribut.

   3. Wird das Attribut nicht gefunden, wird eine "ImportError"
      ausgelöst.

   4. Andernfalls wird ein Verweis auf diesen Wert im aktuellen
      Namensraum gespeichert, wobei der Name in der Klausel "as"
      verwendet wird, sofern vorhanden; andernfalls wird der
      Attributname verwendet.

Beispiele:

   import foo                 # foo imported and bound locally
   import foo.bar.baz         # foo, foo.bar, and foo.bar.baz imported, foo bound locally
   import foo.bar.baz as fbb  # foo, foo.bar, and foo.bar.baz imported, foo.bar.baz bound as fbb
   from foo.bar import baz    # foo, foo.bar, and foo.bar.baz imported, foo.bar.baz bound as baz
   from foo import attr       # foo imported and foo.attr bound as attr

Wird die Liste der Bezeichner durch ein Sternchen ("'*'") ersetzt,
werden alle im Modul definierten öffentlichen Namen im lokalen
Namensraum für den Geltungsbereich gebunden, in dem die Anweisung
"import" auftritt.

The *public names* defined by a module are determined by checking the
module's namespace for a variable named "__all__"; if defined, it must
be a sequence of strings which are names defined or imported by that
module. Names containing non-ASCII characters must be in the
normalization form NFKC.  The names given in "__all__" are all
considered public and are required to exist.  If "__all__" is not
defined, the set of public names includes all names found in the
module's namespace which do not begin with an underscore character
("'_'").  "__all__" should contain the entire public API. It is
intended to avoid accidentally exporting items that are not part of
the API (such as library modules which were imported and used within
the module).

Die Wildcard-Form des Imports --- "from module import *" --- ist nur
auf Modulebene zulässig. Der Versuch, sie in Klassen- oder
Funktionsdefinitionen zu verwenden, löst einen "SyntaxError" aus.

Bei der Angabe des zu importierenden Moduls musst du nicht den
absoluten Namen des Moduls angeben. Befindet sich ein Modul oder Paket
in einem anderen Paket, ist es möglich, innerhalb desselben obersten
Pakets einen relativen Import durchzuführen, ohne den Paketnamen
anzugeben. Durch die Verwendung von führenden Punkten im angegebenen
Modul oder Paket nach  "from" kannst du festlegen, wie weit du in der
aktuellen Pakethierarchie nach oben navigieren möchtest, ohne genaue
Namen angeben zu müssen. Ein führender Punkt bedeutet das aktuelle
Paket, in dem sich das Modul befindet, das den Import durchführt. Zwei
Punkte bedeuten eine Paketebene höher. Drei Punkte bedeuten zwei
Ebenen nach oben usw. Wenn du also "from . import mod" aus einem Modul
im Paket "pkg" ausführst, importiere letztendlich "pkg.mod". Wenn du
"from ..subpkg2 import mod" aus dem Paket "pkg.subpkg1" ausführst,
importiere "pkg.subpkg2.mod". Die Spezifikation für relative Importe
ist im Abschnitt  Paketbezogene Importe enthalten.

"importlib.import_module()" wird bereitgestellt, um Anwendungen zu
unterstützen, die die zu ladenden Module dynamisch ermitteln.

Löst ein Audit-Ereignis "import" mit den Argumenten "module",
"filename", "sys.path", "sys.meta_path", "sys.path_hooks" aus.


7.11.1. Future-Anweisung
------------------------

Eine *Future-Anweisung* ist eine Anweisung an den Compiler, dass ein
bestimmtes Modul unter Verwendung einer Syntax oder Semantik
kompiliert werden soll, die in einer bestimmten zukünftigen Python-
Version verfügbar sein wird, in der diese Funktion zum Standard wird.

Die Zukunftserklärung soll die Migration auf zukünftige Python-
Versionen erleichtern, die inkompatible Änderungen an der Sprache mit
sich bringen. Sie ermöglicht die Nutzung der neuen Funktionen auf
Modulbasis bereits vor der Veröffentlichung, in der die Funktion zum
Standard wird.

   future_stmt ::= "from" "__future__" "import" feature ["as" identifier]
                   ("," feature ["as" identifier])*
                   | "from" "__future__" "import" "(" feature ["as" identifier]
                   ("," feature ["as" identifier])* [","] ")"
   feature     ::= identifier

Eine "future"-Anweisung muss im oberen Bereich des Moduls stehen. Die
einzigen Zeilen, die vor einer "future"-Anweisung stehen dürfen, sind:

* die Docstring des Moduls (falls vorhanden),

* Kommentare,

* Leerzeilen und

* sonstige Future-Anweisung

Die einzige Funktion, für die die Verwendung der "future"-Anweisung
erforderlich ist, ist  "annotations" (siehe **PEP 563**).

Alle historischen Funktionen, die durch die "future"-Anweisung
aktiviert werden, werden von Python 3 weiterhin erkannt. Dazu gehören
"absolute_import",  "division",  "generators",  "generator_stop",
"unicode_literals",  "print_function",  "nested_scopes" und
"with_statement" . Sie sind alle überflüssig, da sie immer aktiviert
sind, und werden nur aus Gründen der Abwärtskompatibilität
beibehalten.

Eine Zukunftsanweisung wird bereits zur Kompilierungszeit erkannt und
besonders behandelt: Änderungen an der Semantik von Kernkonstrukten
werden oft durch die Generierung von anderem Code umgesetzt. Es kann
sogar vorkommen, dass eine neue Funktion eine neue, inkompatible
Syntax einführt (wie beispielsweise ein neues Schlüsselwort); in
diesem Fall muss der Compiler das Modul möglicherweise anders
analysieren.  Solche Entscheidungen können nicht bis zur Laufzeit
aufgeschoben werden.

Für jede beliebige Version weiß der Compiler, welche Funktionsnamen
definiert wurden, und löst einen Fehler zur Kompilierungszeit aus,
wenn eine "future"-Anweisung eine ihm unbekannte Funktion enthält.

Die direkte Laufzeitsemantik entspricht der jeder anderen
Importanweisung: Es gibt ein Standardmodul  "__future__", das später
beschrieben wird und zum Zeitpunkt der Ausführung der
"future"-Anweisung auf die übliche Weise importiert wird.

Die interessante Laufzeitsemantik hängt von der jeweiligen Funktion
ab, die durch die "future"-Anweisung aktiviert wird.

Beachte, dass an dieser Aussage nichts Besonderes ist:

   import __future__ [as name]

Das ist keine Zukunftsanweisung, sondern eine gewöhnliche
Importanweisung ohne besondere Semantik oder syntaktische
Einschränkungen.

Code, der durch Aufrufe der integrierten Funktionen  "exec()" und
"compile()" kompiliert wird, die in einem Modul  "M" vorkommen, das
eine "future"-Anweisung enthält, verwendet standardmäßig die neue
Syntax bzw. Semantik, die mit der "future"-Anweisung verbunden ist.
Dies kann durch optionale Argumente an "compile()" gesteuert werden –
Einzelheiten findest du in der Dokumentation dieser Funktion.

Eine "future"-Anweisung, die an der Eingabeaufforderung eines
interaktiven Interpreters eingegeben wird, gilt für den Rest der
Interpreter-Sitzung. Wird ein Interpreter mit der Option  "-i"
gestartet, ihm ein auszuführender Skriptname übergeben und enthält das
Skript eine "future"-Anweisung, so gilt diese in der interaktiven
Sitzung, die nach der Ausführung des Skripts gestartet wird.

Siehe auch:

  **PEP 236** - Zurück in die __Zukunft__
     Der ursprüngliche Vorschlag für den __future__-Mechanismus.


7.12. Die Erklärung der "global" .
==================================

   global_stmt ::= "global" identifier ("," identifier)*

Die Anweisung  "global" bewirkt, dass die aufgeführten Bezeichner als
globale Variablen interpretiert werden. Ohne  "global" wäre es
unmöglich, einer globalen Variablen einen Wert zuzuweisen, obwohl
freie Variablen auf globale Variablen verweisen können, ohne selbst
als global deklariert zu sein.

Die Anweisung  "global" gilt für den gesamten aktuellen
Geltungsbereich (Modul, Funktionskörper oder Klassendefinition). Es
wird eine "SyntaxError" ausgelöst, wenn eine Variable vor ihrer
globalen Deklaration in diesem Geltungsbereich verwendet oder ihr ein
Wert zugewiesen wird.

Auf Modulebene sind alle Variablen global, sodass eine "global"
-Anweisung keine Wirkung hat. Variablen dürfen jedoch dennoch nicht
verwendet oder zugewiesen werden, bevor sie mit "global" deklariert
wurden. Diese Vorschrift wird in der interaktiven Eingabeaufforderung
(*REPL*) gelockert.

**Anmerkung des Programmierers:**  "global" ist eine Anweisung an den
Parser. Sie gilt nur für Code, der gleichzeitig mit der Anweisung
"global" geparst wird. Insbesondere hat eine  "global" -Anweisung, die
in einer Zeichenkette oder einem Codeobjekt enthalten ist, das der
integrierten Funktion  "exec()" übergeben wird, keine Auswirkungen auf
den Codeblock, der den Funktionsaufruf *enthält*, und der in einer
solchen Zeichenkette enthaltene Code bleibt von  "global" -Anweisungen
in dem Code, der den Funktionsaufruf enthält, unberührt. Dasselbe gilt
für die Funktionen  "eval()" und  "compile()" .


7.13. Die "nonlocal" Anweisung
==============================

   nonlocal_stmt ::= "nonlocal" identifier ("," identifier)*

Wenn die Definition einer Funktion oder Klasse in die Definitionen
anderer Funktionen eingebettet (umschlossen) ist, entsprechen ihre
nichtlokalen Gültigkeitsbereiche den lokalen Gültigkeitsbereichen der
umschließenden Funktionen. Die Anweisung  "nonlocal" bewirkt, dass die
aufgeführten Bezeichner auf Namen verweisen, die zuvor in nichtlokalen
Gültigkeitsbereichen gebunden wurden. Sie ermöglicht es, solche
nichtlokalen Bezeichner in gekapseltem Code neu zu binden.  Ist ein
Name in mehr als einem nichtlokalen Gültigkeitsbereich gebunden, wird
die nächstgelegene Bindung verwendet. Ist ein Name in keinem
nichtlokalen Gültigkeitsbereich gebunden oder gibt es keinen
nichtlokalen Gültigkeitsbereich, wird eine  "SyntaxError" ausgelöst.

Die Anweisung  "nonlocal" gilt für den gesamten Geltungsbereich einer
Funktion oder eines Klassenkörpers. Es wird eine Ausnahme vom Typ
"SyntaxError" ausgelöst, wenn eine Variable verwendet oder zugewiesen
wird, bevor sie im Geltungsbereich nichtlokal deklariert wurde.

Siehe auch:

  **PEP 3104** - Zugriff auf Namen in äußeren Gültigkeitsbereichen
     Die Spezifikation für die Anweisung "nonlocal" .

**Anmerkung des Programmierers:** "nonlocal" ist eine Anweisung an den
Parser und gilt nur für Code, der zusammen mit dieser Anweisung
geparst wird. Siehe dazu die Anmerkung zur Anweisung  "global" .


7.14. Die  "type" Anweisung
===========================

   type_stmt ::= 'type' identifier [type_params] "=" expression

Die Anweisung  "type" deklariert einen Typalias, bei dem es sich um
eine Instanz von  "typing.TypeAliasType" handelt.

Die folgende Anweisung erstellt beispielsweise einen Typalias:

   type Point = tuple[float, float]

Dieser Code entspricht in etwa folgendem:

   annotation-def VALUE_OF_Point():
       return tuple[float, float]
   Point = typing.TypeAliasType("Point", VALUE_OF_Point())

"annotation-def" bezeichnet einen Annotationsbereich, der sich
größtenteils wie eine Funktion verhält, jedoch einige kleine
Unterschiede aufweist.

Der Wert des Typalias wird im Geltungsbereich der Annotation
ausgewertet. Er wird nicht bei der Erstellung des Typalias
ausgewertet, sondern erst dann, wenn über das Attribut  "__value__"
des Typalias auf den Wert zugegriffen wird (siehe Verzögerte
Auswertung). Dadurch kann der Typalias auf Namen verweisen, die noch
nicht definiert sind.

Typaliase können generisch gemacht werden, indem man hinter dem Namen
eine Typ-Parameterliste hinzufügt. Weitere Informationen finden Sie
unter Generische Typaliase.

"type" ist ein Soft-Schlüsselwort.

Added in version 3.12.

Siehe auch:

  **PEP 695** - Type Parameter Syntax
     Es wurden die Anweisung "type" sowie die Syntax für generische
     Klassen und Funktionen eingeführt.
