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.