Python 2.7-Grundlagen-Tutorial: Fehler und Ausnahmen

.. _tut-errors:

=================================

Fehler und Ausnahmen Fehler und Ausnahmen

================================ === =

Bisher gab es nicht mehr als die genannten Fehlermeldungen, aber wenn Sie die Beispiele ausprobiert haben

Sie haben wahrscheinlich einige gesehen. Es gibt (mindestens) zwei

Unterscheidbare Arten von Fehlern: *Syntaxfehler* und *Ausnahmen*.

Keine weitere Diskussion von Fehlermeldungen bisher, aber in den Beispielen, mit denen Sie experimentiert haben,

Sie Vielleicht bin ich auf einige gestoßen. Es gibt (mindestens) zwei Arten von Fehlern in Python: *Syntaxfehler* und *Ausnahmen* .

.. _tut-syntaxerrors:

Syntaxfehler Syntaxfehler

======================

Syntaxfehler, auch Parsing-Fehler genannt, sind möglicherweise die häufigste Art von

Beschwerden, die Sie erhalten, während Sie noch Python lernen:

Syntaxfehler, auch bekannt als Interpretationsfehler sind möglicherweise die häufigsten Fehler beim Erlernen von Python::

>>> while True print 'Hello world'

Datei „“, Zeile 1, in ?

while True print 'Hallo Welt'

                                                                                                                                       Punkt in der Zeile, an der der Fehler erkannt wurde. Der Fehler ist

verursacht (oder zumindest erkannt an) dem Token *vor* dem Pfeil: Im

Beispiel wird der Fehler beim Schlüsselwort :keyword:`print` erkannt, da ein Doppelpunkt

(``':'``) fehlt davor. Dateiname und Zeilennummer werden gedruckt, damit Sie

wissen, wo Sie suchen müssen, falls die Eingabe von einem Skript stammt.

Der Parser wiederholt die Zeile mit dem Fehler und zeigt einen kleinen „Pfeil“ an. Der Fehler

(zumindest der erkannte) tritt dort auf, wo der Pfeil *zeigt*. Der Fehler im Beispiel tritt beim Schlüsselwort

:keyword:`print` auf, da davor ein Doppelpunkt ( ``':'`` ) fehlt. Außerdem werden der Dateiname und die Zeilennummer angezeigt,

damit Sie wissen, von welchem ​​Skript der Fehler stammt und wo.

.. _tut-Exceptions:

Ausnahmen

==========

Auch wenn eine Anweisung oder ein Ausdruck syntaktisch korrekt ist , kann es zu einem

Fehler kommen, wenn versucht wird, es auszuführen

werden *Ausnahmen* genannt und sind nicht unbedingt schwerwiegend: Sie werden es bald erfahren

wie man damit in Python-Programmen umgeht. Die meisten Ausnahmen werden von

Programmen jedoch nicht behandelt und führen zu Fehlermeldungen wie hier gezeigt:

Sogar Anweisungen, die völlig grammatikalisch korrekt sind, an Beim Versuch, es auszuführen, kann auch ein Fehler auftreten. Fehler, die beim Ausführen eines Programms

erkannt werden, werden als Ausnahmen bezeichnet. Sie verursachen normalerweise keine schwerwiegenden Probleme, und Sie werden bald

lernen, wie Sie sie in Python-Programmen kontrollieren können. Die meisten Ausnahmen werden vom Programm nicht behandelt, es wird jedoch eine Fehlermeldung angezeigt::

>>> :

Datei „“, Zeile 1, in ?

ZeroDivisionError: Ganzzahldivision oder Modulo durch Null

>> 3

Traceback (letzter Anruf zuletzt):

Datei „“, Zeile 1, in ?

NameError: Name „Spam“ ist nicht definiert

>>> '2' + 2

Traceback (letzter Aufruf zuletzt):

Datei „“, Zeile 1, in ?

TypeError: 'str'- und 'int'-Objekte können nicht verkettet werden

Die letzte Zeile der Fehlermeldung gibt an, was passiert ist

verschiedene Typen, und der Typ ist Wird als Teil der Nachricht gedruckt: Die Typen im

Beispiel sind :exc:`ZeroDivisionError`, :exc:`NameError` und :exc:`TypeError`.

Die Zeichenfolge wird gedruckt als Der Ausnahmetyp ist der Name der integrierten Ausnahme

Dies gilt für alle integrierten Ausnahmen, muss aber nicht wahr sein

für benutzerdefinierte Ausnahmen (obwohl es ist eine nützliche Konvention.) Standard

Ausnahmenamen sind integrierte Bezeichner (keine reservierten Schlüsselwörter).

Die letzte Zeile der Fehlermeldung gibt an, welcher Fehler aufgetreten ist. Ausnahmen haben auch unterschiedliche Typen. Der Ausnahmetyp wird als Teil der

-Fehlermeldung angezeigt: Die Ausnahmen im Beispiel sind Nulldivisionsfehler

( :exc:`ZeroDivisionError` ) und Namensfehler ( :exc:`NameError`) und Typ

Fehler (:exc:`TypeError`). Beim Drucken von Fehlerinformationen wird der Ausnahmetyp als integrierter Name der Ausnahme

verwendet

Anzeige. Dies gilt für alle integrierten Ausnahmen, jedoch nicht unbedingt für benutzerdefinierte Ausnahmen (obwohl dies

eine nützliche Konvention ist). Standardausnahmenamen sind integrierte Bezeichner (keine reservierten Schlüsselwörter).

Der Rest der Zeile liefert Details basierend auf der Art der Ausnahme und was sie verursacht hat.

Das heißt, ihr Inhalt hängt von der Art der Ausnahme ab.

Der vorangehende Teil der Fehlermeldung zeigt den Kontext, in dem die Ausnahme aufgetreten ist, in Form eines Stack-Tracebacks. Im Allgemeinen enthält er eine Stack-Traceback-Listenquelle Es werden jedoch keine Zeilen angezeigt, die aus der

Standardeingabe gelesen wurden.

In der ersten Hälfte der Fehlermeldung wird der Ort, an dem die Ausnahme aufgetreten ist, in Form eines Stapels aufgeführt. Normalerweise werden die Quellcodezeilen im Stapel aufgelistet, Quellcode aus der Standardeingabe wird jedoch nicht angezeigt.

:ref:`bltin-Exceptions` listet die integrierten Ausnahmen und ihre Bedeutung auf.

.. _tut-handling:

Behandeln von Ausnahmen Kontrollausnahmen

====================== ======

Es ist möglich, Programme zu schreiben, die ausgewählte Ausnahmen behandeln

Sehen Sie sich das folgende Beispiel an, das den Benutzer zur Eingabe auffordert, bis eine gültige Ganzzahl vorliegt

Eingegeben, aber der Benutzer kann das Programm unterbrechen (mit :kbd:`Strg-C` oder

was auch immer das Betriebssystem unterstützt); beachten Sie, dass es sich um eine vom Benutzer verursachte Unterbrechung handelt

wird durch Auslösen der :exc:`KeyboardInterrupt`-Ausnahme signalisiert:

Programme können geschrieben werden, um bekannte Ausnahmen zu kontrollieren. Sehen Sie sich das folgende Beispiel an, bei dem der Benutzer Informationen eingeben muss, bis

eine gültige Ganzzahl erhält, und es dem Benutzer ermöglicht, das Programm zu unterbrechen (mit :kbd:`Control-C` oder

etwas anderes). else Vom Betriebssystem unterstützte Operationen); es ist zu beachten, dass benutzergenerierte Interrupts die Ausnahme

:exc:`KeyboardInterrupt` auslösen. ::

>>> while True:

... try:

... x = int(raw_input("Bitte geben Sie eine Zahl ein: " ))

... break

... außer ValueError:

... print "Ups! Das war keine gültige Nummer. Versuchen Sie es erneut..."

...

Die :keyword:`try`-Anweisung funktioniert wie folgt.

:keyword:`try`-Anweisung funktioniert wie folgt.

* Zuerst wird die *try-Klausel* (die Anweisung(en) zwischen den Schlüsselwörtern :keyword:`try` und

:keyword:`exclusive` ausgeführt.

Führen Sie zunächst die *try-Klausel* aus (den Teil zwischen den Schlüsselwörtern :keyword:`try` und :keyword:`exclusive).

* Wenn keine Ausnahme auftritt, wird die *Exception-Klausel* übersprungen und die Ausführung der

:keyword:`try`-Anweisung wird beendet.

Wenn keine Ausnahme auftritt, Die *Exception-Klausel* wird ignoriert, nachdem die Ausführung der :keyword:`try`-Anweisung abgeschlossen ist.

* Wenn während der Ausführung der try-Klausel eine Ausnahme auftritt, wird der Rest der

-Klausel übersprungen, wenn ihr Typ mit der Ausnahme übereinstimmt, die nach dem Schlüsselwort

benannt ist :`exclusive` Schlüsselwort, die Ausnahmeklausel wird ausgeführt und dann wird die Ausführung

nach der :keyword:`try`-Anweisung fortgesetzt.

Wenn während der Ausführung der try-Klausel eine Ausnahme auftritt, Dann wird der Rest der Klausel ignoriert.

Wenn die Ausnahme mit dem Ausnahmetyp übereinstimmt, der nach dem Schlüsselwort :keyword:`exclusive` angegeben ist, wird die entsprechende Ausnahmeklausel

ausgeführt. Fahren Sie dann mit der Ausführung des Codes nach der :keyword:`try`-Anweisung fort.

* Wenn eine Ausnahme auftritt, die nicht mit der in der Ausnahmeklausel genannten Ausnahme

übereinstimmt, wird sie an äußere :keyword:`try`-Anweisungen weitergeleitet; wenn kein Handler vorhanden ist

gefunden, handelt es sich um eine *unbehandelte Ausnahme* und die Ausführung stoppt mit einer Meldung wie

oben gezeigt.

Wenn eine Ausnahme auftritt, gibt es keine entsprechende Ausnahme im Ausnahmeklauselzweig. Es wird an die Anweisung

der oberen Ebene:keyword:`try` übergeben. Wenn die entsprechende Verarbeitungsanweisung am Ende immer noch nicht gefunden wird, wird sie als *unbehandelte Ausnahme* zu

, beendet das Programm und zeigt eine Eingabeaufforderung an.

Eine :keyword:`try`-Anweisung kann mehr als eine Ausnahmeklausel haben, um

Handler für verschiedene Ausnahmen anzugeben. Es wird höchstens ein Handler ausgeführt.

Handler Behandeln Sie nur Ausnahmen, die in der entsprechenden Try-Klausel auftreten, nicht

in anderen Handlern derselben :keyword:`try`-Anweisung. Eine Ausnahmeklausel kann

mehrere Ausnahmen als in Klammern gesetztes Tupel benennen. zum Beispiel:

Eine :keyword:`try`-Anweisung kann mehrere Except-Klauseln enthalten, die jeweils die Behandlung unterschiedlicher Ausnahmen angeben

. Es wird maximal nur eine Verzweigung ausgeführt. Der Ausnahmehandler verarbeitet nur die entsprechende Try-Klausel

Ausnahmen, die in derselben :keyword:`try`-Anweisung auftreten, Ausnahmen, die in anderen Klauseln auftreten, werden nicht behandelt

. Eine Ausnahmeklausel kann mehrere Ausnahmenamen in Klammern auflisten, zum Beispiel::

... außer (RuntimeError, TypeError, NameError):

... pass

The Die letzte Ausnahmeklausel kann den/die Ausnahmenamen weglassen, um als Platzhalter zu dienen.

Verwenden Sie dies mit äußerster Vorsicht, da es auf diese Weise leicht ist, einen echten Programmierfehler zu maskieren

! Es kann auch verwendet werden, um eine Fehlermeldung auszudrucken und dann

die Ausnahme erneut auszulösen (wodurch auch ein Aufrufer die Ausnahme behandeln kann):

letzte Ausnahmeklausel Sie können den Ausnahmenamen weglassen und verwenden Sie es als Platzhalter. Verwenden Sie

diese Methode unbedingt mit Vorsicht, da sie wahrscheinlich echte Programmfehler maskiert und verhindert, dass andere sie entdecken! Es kann auch verwendet werden, um eine Zeile mit Fehlerinformationen zu drucken und dann die Ausnahme erneut auszulösen (wodurch der Aufrufer die Ausnahme besser behandeln kann)::

import sys

try:

f = open('myfile.txt')

s = f.readline()

i = int(s.strip())

außer IOError as (errno, strerror):

print „E/A-Fehler({0}): {1}“.format(errno, strerror)

außer ValueError:

print „Daten konnten nicht in eine Ganzzahl konvertiert werden.“

außer:

print „Unerwarteter Fehler:“, sys.exc_info()[0]

raise

Die :keyword:`try` ... :keyword:`exclusive`-Anweisung hat eine optionale *else

Klausel*, die, sofern vorhanden, allen Ausnahmeklauseln folgen muss. Sie ist nützlich für

Code, der ausgeführt werden muss, wenn die Try-Klausel keine Ausnahme auslöst. Für

Beispiel:

:keyword:`try` ... :keyword :`exclusive` Die Anweisung kann eine *else-Klausel* haben,

Diese Klausel kann nur nach allen Ausnahmeklauseln erscheinen. Wenn die try-Anweisung keine Ausnahme auslöst und Code ausgeführt werden muss, können Sie die

-Klausel verwenden. Zum Beispiel::

für arg in sys.argv[1:]:

versuchen Sie:

f = open(arg, 'r')

außer IOError:

                                                                                                                                                                                                                                                                  f.close()

Die Verwendung von :keyword:`else` ist besser als das Hinzufügen von zusätzlichem Code zur

der :keyword:`try`-Klausel, da sie verhindert, dass versehentlich eine Ausnahme abgefangen wird

die nicht durch den durch das :keyword: geschützten Code ausgelöst wurde: `try` ...

:keyword:`exclusive`-Anweisung.

Die Verwendung einer :keyword:`else`-Klausel ist besser als das Anhängen von Code in einer :keyword:`try`-Klausel, weil

Dies vermeidet :keyword:`try` ... :keyword:`außer ` Es wird nicht erwartet, dass unerwartete Abhörvorgänge

Ausnahmen sind, die durch den Code ausgelöst werden, den sie schützen.

Wenn eine Ausnahme auftritt, kann ihr ein Wert zugeordnet sein, der auch als *Argument* der

Ausnahme bezeichnet wird. Das Vorhandensein und der Typ des Arguments hängen von der

Ausnahme ab Typ.

Wenn eine Ausnahme auftritt, kann ein angehängter Wert vorhanden sein, der als *Parameter* der Ausnahme vorhanden ist. Ob dieser Parameter vorhanden ist und welcher Typ

ist, hängt von der Art der Ausnahme ab.

Die Ausnahmeklausel kann eine Variable nach dem Ausnahmenamen (oder Tupel) angeben.

Die Variable ist an eine Ausnahmeinstanz gebunden, wobei die Argumente in der

``Instanz gespeichert sind .args``. Der Einfachheit halber definiert die Ausnahmeinstanz

:meth:`__str__`, sodass die Argumente direkt gedruckt werden können, ohne

auf „.args“ verweisen zu müssen.

Nach dem Ausnahmenamen (Liste) können Sie auch eine Variable für die Ausnahmeklausel angeben. Diese Variable ist an

eine Ausnahmeinstanz gebunden, die in den Argumenten von „instance.args“ gespeichert ist. Der Einfachheit halber definiert die Ausnahmeinstanz

:meth:`__str__`, sodass auf die Druckparameter direkt zugegriffen werden kann, ohne auf

``.args`` zu verweisen.

Man kann auch zuerst eine Ausnahme instanziieren, bevor man sie auslöst, und ihr nach Wunsch

Attribute hinzufügen:

Diese Vorgehensweise wird nicht empfohlen. Stattdessen besteht ein besserer Ansatz darin, einen Parameter an die Ausnahme zu übergeben (oder ein Tupel, wenn Sie mehrere

-Parameter übergeben möchten) und ihn an die Nachrichteneigenschaft zu binden. Sobald eine Ausnahme auftritt,

bindet sie alle angegebenen Eigenschaften, bevor sie ausgelöst wird. ::

>>> try:

... raise Exception('spam', 'eggs')

... außer Exception as inst:

... print type(inst) # die Ausnahmeinstanz

... print inst.args # in .args gespeicherte Argumente

... print inst ... # __str__ ermöglicht das direkte Drucken von Argumenten

... x, y = inst # __getitem__ ermöglicht das direkte Entpacken von Argumenten

... drucken 'x = ', x

... print 'y =', y

...

('Spam', 'Eier')

('Spam', 'Eier')

x = Spam

y = Eier

Wenn eine Ausnahme ein Argument hat, wird es als letzter Teil ('Detail') der Meldung für nicht behandelte Ausnahmen gedruckt. Es wird als letzter Teil der Fehlermeldung ausgedruckt

(„Details“).

Ausnahmebehandler behandeln Ausnahmen nicht nur, wenn sie sofort in der

try-Klausel auftreten, sondern auch, wenn sie innerhalb von Funktionen auftreten, die (sogar

indirekt) aufgerufen werden die try-Klausel. Zum Beispiel:

Der Ausnahmebehandlungshandler kann nicht nur Ausnahmen behandeln, die direkt in der try-Klausel auftreten, auch wenn eine Ausnahme in der darin aufgerufenen Funktion auftritt (sogar

ist indirekt). , kann auf die gleiche Weise verarbeitet werden. Zum Beispiel::

>>> def this_fails():

... x = 1/0

...

> ;>> try:

... this_fails()

... außer ZeroDivisionError als Detail:

... print 'Laufzeitfehler behandeln : ', detail

...

Behandlung von Laufzeitfehlern: Ganzzahldivision oder Modulo durch Null

.. _tut-raising:

Raising Ausnahmen werfen eine Ausnahme aus

===========================

Das :keyword:`raise` Mit der Anweisung kann der Programmierer das Auftreten einer bestimmten

Ausnahme erzwingen. Beispiel:

Der Programmierer kann die :keyword:`raise`-Anweisung verwenden, um das Auftreten der angegebenen Ausnahme zu erzwingen. Zum Beispiel::

>>> raise NameError('HiThere')

Traceback (letzter Aufruf zuletzt):

Datei „“ , Zeile 1, in ?

NameError: HiThere

Das einzige Argument für :keyword:`raise` gibt die Ausnahme an, die ausgelöst werden soll.

Dies muss entweder eine Ausnahme sein Instanz oder eine Ausnahmeklasse (eine Klasse, die

von :class:`Exception` abgeleitet ist).

Die auszulösende Ausnahme wird durch den eindeutigen Parameter :keyword:`raise` identifiziert. Es muss eine Ausnahmeinstanz oder

Ausnahmeklasse sein (eine von :class:`Exception` geerbte Klasse).

Wenn Sie feststellen müssen, ob eine Ausnahme ausgelöst wurde, aber nicht beabsichtigen,

diese zu behandeln, können Sie dies mit einer einfacheren Form der :keyword:`raise`-Anweisung tun

Ausnahme erneut auslösen:

Wenn Sie wissen müssen, ob eine Ausnahme ausgelöst wird, sie aber nicht behandeln möchten, können Sie dies mit der Anweisung :keyword:`raise`

tun um es einfach erneut zu erhöhen. Diese Ausnahme tritt auf.

>>> try:

... raise NameError('HiThere')

... außer NameError:

.. . print 'Eine Ausnahme ist vorbeigegangen!'

... raise

...

Eine Ausnahme ist vorbeigegangen!

Traceback (letzter Anruf last):

Datei „“, Zeile 2, in ?

NameError: HiThere

.. _tut-userExceptions:

Benutzer -definierte Ausnahmen Benutzerdefinierte Ausnahmen

==================================== === =

Programme können ihre eigenen Ausnahmen benennen, indem sie eine neue Ausnahmeklasse erstellen (siehe

:ref:`tut-classes` für mehr über Python-Klassen). >

entweder direkt oder indirekt von der Klasse :exc:`Exception` abgeleitet werden. Zum Beispiel:

Sie können Ihre eigenen Ausnahmen benennen, indem Sie im Programm neue Ausnahmetypen erstellen (Python Den Inhalt der Klasse finden Sie unter

see:ref:`tut-classes`). Ausnahmeklassen sollten normalerweise direkt oder indirekt von der Klasse

:exc:`Exception` abgeleitet werden, zum Beispiel::

>>> class MyError(Exception):

... def __init__(self, value):

... self.value = value

... def __str__(self):

. .. return repr(self.value)

...

>>> try:

... raise MyError(2*2)

... außer MyError als e:

... print 'Meine Ausnahme ist aufgetreten, Wert:', e.value

...

My Ausnahme aufgetreten, Wert: 4

>>> raise MyError('oops!')

   Traceback (letzter Aufruf zuletzt):

     Datei „“, Zeile 1, in ?

   __main__.MyError: 'oops!'

In diesem Beispiel wurde der Standardwert :meth:`__init__` von :class:`Exception`

überschrieben.  Das neue Verhalten erstellt einfach das Attribut *value*.  Dies

ersetzt das Standardverhalten beim Erstellen des *args*-Attributs.

在这个例子中，:class:`Exception`简单的创建

value 属性。这就替换了原来创建 *args* 属性的方式。

Ausnahmeklassen können definiert werden, die alles tun, was jede andere Klasse tun kann, aber

sind normalerweise einfach gehalten und bieten oft nur eine Reihe von Attributen, die es ermöglichen

Informationen über den Fehler durch Handler für die Ausnahme zu extrahieren.  Wenn

ein Modul erstellt wird, das mehrere unterschiedliche Fehler auslösen kann, ist es üblich,

eine Basisklasse für Ausnahmen zu erstellen, die von diesem Modul definiert werden, und eine Unterklasse zu erstellen, die

zu erstellen ist Spezifische Ausnahmeklassen für unterschiedliche Fehlerbedingungen:在

其中加入几个属性信息，以供异常处理句柄提取.如果一个新创建的模块中需要

抛出几种不同的错误时，一个通常的作法是为该模块定义一个异常基类，然后针

   class Error(Exception):

       """Basisklasse für Ausnahmen in diesem Modul."""

       pass

   class InputError(Error):

       """Ausnahme bei Fehlern in der Eingabe ausgelöst.

       Attributes:

           expr - - Eingabeausdruck, in dem der Fehler aufgetreten ist

           msg  -- Erklärung des Fehlers

       ""

       def __init__(self, expr, msg):

           self.expr = expr

           self.msg = msg

   class TransitionError(Error):

       """Wird ausgelöst, wenn eine Operation einen Zustandsübergang versucht, der nicht

       erlaubt.

       Attribute:

           prev – Zustand zu Beginn des Übergangs

           next – versuchter neuer Zustand

           msg. -- Erklärung, warum der spezifische Übergang nicht zulässig ist

       """

       def __init__(self, prev, next, msg):

           self.prev = prev

           self.next = next

           self.msg = msg

Die meisten Ausnahmen werden mit Namen definiert, die auf „Error“ enden, ähnlich der

Benennung der Standardausnahmen.

与标准异常相似，大多数异常的命名都以„Error“结尾.

Viele Standardmodule definieren ihre eigenen Ausnahmen, um Fehler zu melden, die auftreten können

treten in den von ihnen definierten Funktionen auf.  Weitere Informationen zu den Kursen finden Sie im

Kapitel :ref:`tut-classes`义的函数中的错误Reinigung up Aktionen 定义清理行为

====================================== =============

Die :keyword:`try`-Anweisung enthält eine weitere optionale Klausel, die

Bereinigungsaktionen definieren soll, die ausgeführt werden müssen unter allen Umständen.  Zum

Beispiel:

:keyword:`try`执行的功

能。例如 ::

   >>> versuche:

   ...    Tastaturunterbrechen erhöhen

   ... endlich:

   ...     drucke „Auf Wiedersehen, Welt!“

   ...

   Auf Wiedersehen, Welt!

   Traceback (letzter Aufruf zuletzt):

     Datei „“, Zeile 2, in ?

   KeyboardInterrupt

Eine *finally-Klausel* wird immer ausgeführt, bevor die :keyword:`try`

Anweisung verlassen wird, unabhängig davon, ob eine Ausnahme aufgetreten ist oder nicht. Wenn eine Ausnahme

in der :keyword:`try`-Klausel aufgetreten ist und nicht von einem

behandelt wurde

:keyword:`exclusive` Klausel (oder es ist in einer :keyword:`exclusive` oder

:keyword:`else` Klausel vorgekommen), wird es nach dem :keyword:` erneut ausgelöst Die Klausel „finally“ wurde

ausgeführt. Die Klausel „finally“ wird auch „auf dem Weg nach draußen“ ausgeführt,

wenn eine andere Klausel der Anweisung „try“ ausgeführt wird links über eine

:keyword:`break`, :keyword:`continue` oder :keyword:`return`-Anweisung. Ein

komplizierteres Beispiel (mit :keyword:`exclusive` und :keyword:`finally`-Klauseln in

die gleiche :keyword:`try`-Anweisung funktioniert ab Python 2.5):

Unabhängig davon, ob eine Ausnahme auftritt oder nicht, die *finally-Klausel* endet, wenn das Programm verlässt :keyword:`try` wird definitiv nach

ausgeführt. Wenn eine

-Ausnahme, die nicht von :keyword:`exclusive` abgefangen wird, in einer :keyword:`try`-Anweisung auftritt (oder in einer :keyword:`exclusive- oder :keyword:`else`-Klausel auftritt), Es wird erneut ausgelöst, nachdem die

:keyword:`finally`-Klausel ausgeführt wurde. :keyword:`try`-Anweisung ist

gefolgt von :keyword:`break`, :keyword:`continue` oder :keyword:`return`-Anweisung, die

beendet, führt weiterhin aus:keyword: „finally“-Klausel. Hier ist ein komplexeres Beispiel (die Funktionsweise der Klauseln :keyword:`exclusive` und :keyword:`finally`

in derselben :keyword:`try`-Anweisung. Die Methode ist die gleiche wie in Python 2.5): :

>>> def dividieren(x, y):

... versuchen Sie:

... Ergebnis = x / y

... außer ZeroDivisionError:

... drucke „Division durch Null!“

... sonst:

.. . drucke „Ergebnis ist“, Ergebnis

... Endlich:

... „Ausführung der Endgültigen Klausel“

...

& GT ;>> (2, 1)

Ergebnis ist 2

Ausführung der Finalklausel

>>> Division(2, 0)

Division durch Null !

Ausführung der Final-Klausel

>>> Divide("2", "1")

Ausführung der Final-Klausel

Traceback (most letzter Aufruf zuletzt):

Datei „“, Zeile 1, in ?

Datei „“, Zeile 3, in teilen

TypeError : nicht unterstützte Operandentypen für /: 'str' und 'str'

Wie Sie sehen können, wird die :keyword:`finally`-Klausel in jedem Fall ausgeführt.

: exc:`TypeError`, der durch die Division zweier Zeichenfolgen ausgelöst wird, wird von der Klausel

:keyword:`exclusive` nicht behandelt und daher erneut ausgelöst, nachdem die Klausel :keyword:`finally`

beendet wurde ausgeführt.

Wie Sie sehen können, wird die :keyword:`finally`-Klausel in jedem Fall

ausgeführt. :exc:`TypeError`

wird ausgelöst, wenn zwei Zeichenfolgen geteilt werden und wird nicht von der :keyword:`exclusive-Klausel abgefangen, also in

:keyword:`finally` Wird nach dem erneut ausgelöst Klausel wird ausgeführt.

In realen Anwendungen ist die :keyword:`finally`-Klausel nützlich für

die Freigabe externer Ressourcen (wie Dateien oder Netzwerkverbindungen), unabhängig davon

ob die Die Nutzung der Ressource war erfolgreich.

In realen Anwendungen wird die :keyword:`finally`-Klausel verwendet, um externe Ressourcen (Dateien

oder Netzwerkverbindungen usw.) freizugeben. Unabhängig davon ob bei der Verwendung Fehler vorliegen.

.. _tut-cleanup-with:

Vordefinierte Reinigungsaktionen Vordefinierte Reinigungsaktionen

================ ======================================

Einige Objekte definieren Standards Bereinigungsaktionen, die durchgeführt werden sollen, wenn das Objekt

nicht mehr benötigt wird, unabhängig davon, ob der Vorgang mit dem Objekt

erfolgreich war oder nicht. Sehen Sie sich das folgende Beispiel an, das dies versucht Öffnen Sie eine Datei

und geben Sie ihren Inhalt auf dem Bildschirm aus:

Einige Objekte definieren ein Standardbereinigungsverhalten, unabhängig davon, ob die Objektoperation erfolgreich ist oder nicht, wenn das Objekt nicht mehr benötigt wird

Es wird bald in Kraft treten. Im folgenden Beispiel wird versucht, eine Datei zu öffnen und ihren Inhalt auf dem Bildschirm auszugeben. ::

for line in open("myfile.txt"):

print line

Das Problem mit diesem Code besteht darin, dass er die Datei für eine unbestimmte Zeit geöffnet lässt

Zeitspanne, nachdem die Ausführung des Codes abgeschlossen ist. Dies ist in

einfachen Skripten kein Problem, kann aber bei größeren Anwendungen ein Problem darstellen Mit der Anweisung können Objekte wie Dateien so verwendet werden, dass

sichergestellt wird, dass sie immer umgehend und korrekt bereinigt werden:

Das Problem bei diesem Code ist, dass er nicht sofort danach bereinigt wird Der Code wird ausgeführt. Geöffnete Dateien schließen. Dies ist in einfachen Skripten in Ordnung

, kann aber in größeren Anwendungen zu Problemen führen. Mit der :keyword:`with`-Anweisung können Objekte wie Dateien

sicherstellen, dass sie immer zeitnah und genau bereinigt werden. ::

mit open("myfile.txt") as f:

für Zeile in f:

print line

Nachdem die Anweisung ausgeführt wurde, wird die Datei *f * ist immer geschlossen, auch wenn bei der Verarbeitung der Zeilen ein

Problem aufgetreten ist. Andere Objekte, die

vordefinierte Bereinigungsaktionen bereitstellen, geben dies in ihrer Dokumentation an.

Die Datei *f* wird immer geschlossen, nachdem die Anweisung ausgeführt wurde, auch wenn bei der Verarbeitung der Daten in der Datei ein Fehler aufgetreten ist.

Wenn andere Objekte vordefinierte Bereinigungsverhalten bieten, überprüfen Sie bitte deren Dokumentation.

Das Obige ist das grundlegende Tutorial von Python 2.7: Fehler und Ausnahmen. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn).