Verstehen Sie den Ausnahmemechanismus von Python

Vorwort: Als ich zuvor gearbeitet habe, habe ich Python verwendet, um ein Befehlszeilenfenster zu vervollständigen, das den seriellen Port zum Senden von SCPI und zum Interagieren mit dem Mikrocontroller verwendet. Bei der Implementierung der Funktion habe ich festgestellt, dass die Verwendung von Python zum Zurückgeben des endgültiger korrekter Wert oder falscher Wert des Datenergebnisses Sie können direkt zur Hauptschnittstelle zurückkehren. Offensichtlich ist es nicht möglich, Daten mit unterschiedlichen Bedeutungen direkt zurückzugeben. Daher wird ein Ausnahmemechanismus verwendet, um Daten mit falschen Werten zu verarbeiten. Da ich vorher nicht viel über Anomalien wusste, habe ich hier einige Informationen überprüft und einige Notizen zusammengestellt.

Artikelverzeichnis

• 1. Was sind Ausnahmen
• 2. Der Unterschied zwischen Fehlern und Ausnahmen
  • 3
  • 2. Die fünf wichtigsten Ausnahmebehandlungsmechanismen von Python
  2. Versuchen Sie ... außer ... schließlich ... ..Verarbeitungsmechanismus
• 5 mit ... als Verarbeitungsmechanismus
• • 1. Ausnahmeanpassung
  • 3. Ausnahmeerfassung
  • 4. Vorsichtsmaßnahmen für die Verwendung von Ausnahmen
  • 1. Verlassen Sie sich nicht zu sehr auf den Ausnahmemechanismus
3 Ignorieren Sie nicht die erfassten Ausnahmen
• • Zusammenfassung
  • (kostenlose Lernempfehlung:
• Python-Video-Tutorial
• )
  • 1. Verständnis von Ausnahmen
• 1. Was ist Abnormal

Abnormalität bedeutet „anders als normal“ Was ist normal? Normal bedeutet, dass der Code, den wir schreiben, den vom Interpreter definierten Regeln entspricht, wenn der Interpreter feststellt, dass ein bestimmter Code der Grammatik entspricht, aber möglicherweise abnormal ist Der Interpreter wird ein Ereignis ausgeben, das die normale Ausführung des Programms unterbricht. Dieses unterbrochene Signal ist ein

anormales Signal

. Daher besteht die allgemeine Erklärung darin, dass der Interpreter eine Ausnahme generiert, wenn er einen Fehler im Programm erkennt. Wenn das Programm ihn nicht behandelt, wird die Ausnahme ausgelöst und das Programm wird beendet. Wir können ein int („m“) in eine leere .py-Datei schreiben und das Ergebnis nach der Ausführung ist wie folgt.   Diese Schriftartenfolge ist eine Reihe von Fehlermeldungen, die vom Interpreter ausgegeben werden. Da die in int() übergebenen Parameter nur numerische Zeichenfolgen und Zahlen unterstützen, gehört „m“ offensichtlich nicht zur übergebenen numerischen Zeichenfolge ist falsch, daher lautet die Erklärung: Das Gerät meldet einen „valueError“-Fehler. 2. Der Unterschied zwischen Fehlern und Ausnahmen

  Übersicht über Python-Fehler: Es bezieht sich auf Syntax- oder logische Fehler, bevor der Code ausgeführt wird . Nehmen Sie als Beispiel normale Syntaxfehler. Wenn der von uns geschriebene Code den Syntaxtest nicht besteht, muss er korrigiert werden, bevor das Programm ausgeführt wird und kann nicht ausgeführt werden. Wenn beispielsweise a = 1 print("hello") in die .py-Datei eingegeben wird, lautet das Ausgabeergebnis wie folgt:

  Traceback (most recent call last):
  	File "E:/Test_code/test.py",line 1
    	if a = 1 print("hello")
                ^SyntaxError: invalid syntax

  Bei der Funktion print() wurde ein Fehler festgestellt, da ihr ein Doppelpunkt fehlte: in davor, damit der Parser die Codezeile mit dem Syntaxfehler reproduziert und mit einem kleinen „Pfeil“ auf den ersten in der Zeile erkannten Fehler zeigt, sodass wir direkt die entsprechende Position finden und deren Syntax ändern können. Natürlich gibt es neben Grammatikfehlern auch viele Programmabsturzfehler wie Speicherüberlauf usw. Solche Fehler sind oft relativ versteckt.

 Im Vergleich zu Fehlern Python-Ausnahmen treten hauptsächlich auf, wenn das Programm während der Programmausführung auf logische oder algorithmische Probleme stößt. Wenn der Interpreter damit umgehen kann, wird das Programm direkt beendet und ausgelöst Ausnahme, wie im Beispiel int('m') im ersten Punkt, tritt der Programmfehler auf, weil der Parameter falsch übergeben wird. Es gibt alle Arten von Ausnahmen, die durch die Logik verursacht werden. Glücklicherweise verfügt unser Dolmetscher über integrierte Ausnahmetypen, sodass wir wissen, welche Ausnahmen auftreten, sodass wir „die richtigen Medikamente verschreiben“ können. Beachten Sie hier, dass es sich bei den oben genannten Syntaxfehlern um erkannte Fehler handelt, sodass der Interpreter standardmäßig auch eine SyntaxError-Ausnahmemeldung auslöst, um eine Rückmeldung an den Programmierer zu geben. Im Wesentlichen können die meisten Fehler ausgegeben und gedruckt werden. Da der Fehlercode jedoch nicht ausgeführt wird, kann er nicht behandelt werden, sodass die Erfassung der Fehlerausnahmeinformationen bedeutungslos wird.

3. Häufige Arten von Python-Ausnahmen  Hier sind die häufigsten Ausnahmetypen, wenn wir Code schreiben. Wenn Sie auf andere Ausnahmetypen stoßen, wählen Sie natürlich Baidu~

ReferenceEr rorEinrückungsfehler gemischt mit LeerzeichenAllgemeiner Interpreter-SystemfehlerUngültiger Vorgang für TypUngültige Parameter übergeben bezogene Fehler Fehler beim Dekodieren Fehler beim Kodieren Fehler bei der KonvertierungBasisklasse für WarnungenWarnung vor veralteten FunktionenWarnung vor Konstrukten, deren Semantik sich in Zukunft ändern wirdAlte Warnung vor automatischer Hochstufung zu lang Warnung vor veralteter FunktionVerdächtiges Laufzeitverhalten WarnungVerdächtige SyntaxwarnungVon Benutzercode generierte Warnung

Ausnahmename	Namensauflösung
BaseException	Basisklasse für alle Ausnahmen
SystemExit	Interpreter Request Exit
KeyboardInter. rupt	Benutzer unterbricht die Ausführung (normalerweise Eingabe ^ C )
Exception	Allgemeine Fehlerbasisklasse
StopIteration	Iterator hat keine weiteren Werte
GeneratorExit	Im Generator ist eine Ausnahme aufgetreten, um den Exit zu benachrichtigen
. StandardErr oder	Basiskurs für alle Integrierte Standardausnahmen
ArithmeticError	Basisklasse für alle numerischen Berechnungsfehler
FloatingPointError	Gleitkomma-Berechnungsfehler
OverflowError	Numerische Operation überschreitet die Höchstgrenze
ZeropisionError	Division (oder Modulo) Null (alle Datentypen). , EOF-Flag erreicht
EnvironmentError	Betriebssystemfehler-Basisklasse
IOError	Eingabe-/Ausgabevorgang fehlgeschlagen
OSerror	Betriebssystemfehler
WindowsError	Systemaufruf fehlgeschlagen
ImportError	Modul/Objekt konnte nicht importiert werden. LookupError. Ungültige Datenabfrage-Basisklasse. IndexError. Kein solcher Index in der Reihenfolge
Speicherfehler	Nicht genügend Speicherfehler (nicht schwerwiegend für Python-Interpreter)
NameError	Nicht deklariertes/initialisiertes Objekt (keine Attribute)
UnboundLocalError	Zugriff auf nicht initialisierte lokale Variable
Schwache Referenz versucht es Greifen Sie auf ein Objekt zu, das durch Garbage Collection gesammelt wurde	IndentationError
	TabError Tab
	SystemError
	TypeError
	ValueError
	UnicodeError Unicode
	UnicodeDecodeError Unicode
	UnicodeEncodeError Unicode
	UnicodeTranslateError Unicode
	Warning
	DeprecationWarning
	FutureWarning
	OverflowWarning
	PendingDeprecationWarning
	RuntimeWarning
	SyntaxWarning
	UserWarning
	二、python五大异常处理机制   我们明白了什么是异常后，那么发现异常后怎么处理，便是我们接下来要解决的问题。这里将处理异常的方式总结为五种。 1、默认异常处理机制   “默认”则说明是解释器默认做出的行为，如果解释器发现异常，并且我们没有对异常进行任何预防，那么程序在执行过程中就会中断程序，调用python默认的异常处理器，并在终端输出异常信息。刚才举过的例子：int(“m”)，便是解释器因为发现参数传入异常，这种异常解释器“无能为力”，所以它最后中断了程序，并将错误信息打印输出，告诉码农朋友们：你的程序有bug！！！ 2、try…except…处理机制   我们把可能发生错误的语句放在try语句里，用except来处理异常。每一个try，都必须至少有一个或者多个except。举一个最简单的例子如下，在try访问number的第500个元素，很明显数组越界访问不了，这时候解释器会发出异常信号：IndexError，接着寻找后面是否有对应的异常捕获语句except ，如果有则执行对应的except语句，待except语句执行完毕后，程序将继续往下执行。如果没有对应的except语句，即用户没有处理对应的异常，这时解释器会直接中断程序并将错误信息打印输出。 number = &#39;hello&#39;try： print(number[500]) #数组越界访问except IndexError： print("下标越界啦！")except NameError： print("未声明对象！")print("继续运行...") 输出结果如下，因为解释器发出异常信号是IndexError，所以执行下标越界语句。 下标越界啦！ 继续运行...   为了解锁更多用法，我们再将例子改一下，我们依然在try访问number的第500个元素，造成访问越界错误，这里的except用了as关键字可以获得异常对象，这样子便可获得错误的属性值来输出信息。 number = &#39;hello&#39;try： print(number[500]) #数组越界访问except IndexError as e： print(e)except Exception as e： #万能异常 print(e)except： #默认处理所有异常 print("所有异常都可处理")print("继续运行...") 输出结果如下所示，会输出系统自带的提示错误：string index out of range，相对于解释器因为异常自己抛出来的一堆红色刺眼的字体，这种看起来舒服多了（能够“运筹帷幄”的异常才是好异常嘛哈哈哈）。另外这里用到“万能异常”Exception，基本所有没处理的异常都可以在此执行。最后一个except表示，如果没有指定异常，则默认处理所有的异常。 string index out of range继续运行... 3、try…except…finally…处理机制   finally语句块表示，无论异常发生与否，finally中的语句都要执行完毕。也就是可以很霸气的说，无论产生的异常是被except捕获到处理了，还是没被捕获到解释器将错误输出来了，都统统要执行这个finally。还是原来简单的例子加上finally语句块如下，代码如下： number = &#39;hello&#39;try： print(number[500]) #数组越界访问，抛出IndexError异常except IndexError： print("下标越界啦！")finally： print("finally！")print("继续运行...") #运行 结果如下，数据越界访问异常被捕获到后，先执行except 语句块，完毕后接着执行了finally语句块。因为异常被执行，所以后面代码继续运行。 下标越界啦！finally！ 继续运行...   对try语句块进行修改，打印abc变量值，因为abc变量没定义，所以会出现不会被捕获的NameError异常信号，代码如下所示： number = &#39;hello&#39;try： print(abc) #变量未被定义，抛出NameError异常except IndexError： print("下标越界啦！")finally： print("finally！")print("继续运行...") #不运行 结果如下，因为NameError异常信号没法被处理，所以解释器将程序中断，并将错误信息输出，但这过程中依然会执行finally语句块的内容。因为程序被迫中断了，所以后面代码不运行。 finally！ #异常没被捕获，也执行了finallyTraceback (most recent call last): File "E:/Test_code/test.py",line 3,in <module> print("abc")NameError: name &#39;abc&#39; is not defined   理解到这里，相信:try…finally…这种机制应该也不难理解了，因为省略了except 捕获异常机制，所以异常不可能被处理，解释器会将程序中断，并将错误信息输出，但finally语句块的内容依然会被执行。例子代码如下： number = &#39;hello&#39;try： print(abc) #变量未被定义，抛出NameError异常finally： print("finally！")print("继续运行...") 运行结果： finally！ #异常没被捕获，也执行了finallyTraceback (most recent call last): File "E:/Test_code/test.py",line 3,in <module> print("abc")NameError: name &#39;abc&#39; is not defined 4、assert断言处理机制   assert语句先判断assert后面紧跟的语句是True还是False，如果是True则继续往下执行语句，如果是False则中断程序，将错误信息输出。 assert 1 == 1 #为True正常运行assert 1 == 2 #为False,终止程序，错误信息输出 5、with…as处理机制   with…as一般常用在文件处理上，我们平时在使用类似文件的流对象时，使用完毕后要调用close方法关闭，很麻烦，这里with…as语句提供了一个非常方便且人性的替代方法，即使突发情况也能正常关闭文件。举个例子代码如下，open打开文件后将返回的文件流对象赋值给fd，然后在with语句块中使用。 with open(&#39;e:/test.txt&#39;,&#39;r&#39;) as fd: fd.read() print(abc) #变量未被定义，程序终止，错误信息输出print("继续运行...")   正常情况下，这里的with语句块完毕之后，会自动关闭文件。但如果with语句执行中发生异常，如代码中的变量未定义异常，则会采用默认异常处理机制，程序终止，错误信息输出，后面代码不被运行，文件也会正常关闭。 三、python异常自定义   说了这么多异常的使用，终于可以回到我前言所说的在实际项目中存在的问题，即错误码的返回和数值的返回是冲突的（因为错误码也是数值），这时候便可以用异常的抛出和捕获来完成错误码的传递，即try和except 。但系统发生异常时抛出的是系统本身定义好的异常类型，跟自己的错误码又有何关系？这就是我接下来要说的内容：如何定义自己的异常并且能够被except 所捕获。 1、异常自定义   实际开发中，有时候系统提供的异常类型往往都不能满足开发的需求。这时候就要使用到异常的自定义啦，你可以通过创建一个新的异常类来拥有自己的异常。自己定义的异常类继承自 Exception 类，可以直接继承，或者间接继承。栗子举起来： class MyException(Exception): &#39;&#39;&#39;自定义的异常类&#39;&#39;&#39; def __init__(self, error_num): #异常类对象的初始化属性 self.error_num = error_num def __str__(self): #返回异常类对象说明信息 err_info = [&#39;超时错误&#39;,&#39;接收错误&#39;] return err_info[self.error_num]   该类继承自Exception 类，并且新类的名字为MyException，这跟前面我们一直在用的IndexError这个异常类一样，都是继承自Exception 类。__init__为构造函数，当我们创建对象时便会自动调用，__str__为对象说明信息函数，当使用print输出对象的时候，只要自己定义了__str__方法，那么就会打印从在这个方法中return的数据。   即print(MyException(0))时，便可打印“超时错误”这个字符串，print(MyException(1))时，便可打印“接收错误”这个字符串，心细的你应该可以理解，MyException(x)为临时对象（x是传入错误码参数，这里只定义了0和1），与a = MyException(x)，a为对象一个样子 。 这里有一个好玩的说法，在python中方法名如果是__xxxx__()的，那么就有特殊的功能，因此叫做“魔法”方法。 2、异常抛出raise   现在我们自己定义的错误定义好了（上面的MyException），怎么能像IndexError一样让except捕获到呢？于是乎raise关键字派上用场。我们在异常机制中用try…except时，一般都是将可能产生的错误代码放到try语句块中，这时出现异常则系统便会自动将其抛出，比如IndexError，这样except就能捕获到，所以我们只要将自定义的异常在需要的时候将其抛出即可。   raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类），那么我们刚刚定义的异常类就可以用啦，举个简单例子： try: raise MyException(0) # 自己定义的错误类，将错误码为0的错误抛出except MyException as e: print(e) # 输出的是__str__返回的内容，即“超时错误”   这里我直接将自己定义的错误抛出，…as e就是把得到的错误当成对象e，这样才可以访问其属性和方法。因为自己定义的错误中可以支持多个错误码（本质还是MyException这个错误），所以便可实现传入不同错误码就可打印不同错误信息。 3、异常捕获   只要我们在try中将错误raise出来，except就可以捕获到（当然，异常必须是Exception 子类才能被捕获），将前面两个例子整合起来，代码如下： &#39;&#39;&#39;错误码：0代表超时错误，1代表接收错误&#39;&#39;&#39;class MyException(Exception): &#39;&#39;&#39;自定义的异常类&#39;&#39;&#39; def __init__(self, error_num): # 异常类对象的初始化属性 self.error_num= error_num def __str__(self): # 返回异常类对象指定错误码的信息 err_info = [&#39;超时错误&#39;,&#39;接收错误&#39;] return err_info[self.error_num]def fun() raise MyException(1) # 抛出异常对象，传入错误码1def demo_main(): try: fun() except MyException as ex: # 这里要使用MyException进行捕获，对象为ex print(ex) # 输出的是__str__部分返回的内容，即“接收错误” print(ex.error_num) # 输出的是__init__中定义的error_num，即1demo_main() #此处开始运行   代码从demo_main函数开始执行，进入try语句块，语句块中的fun()函数模拟代码运行失败时raise 自定义的异常，except 正常接收后通过as 关键字得到异常对象，访问该异常对象，便可正常输出自定义的异常信息和自定义的错误码。 四、异常使用注意事项 此注意事项参考博文：异常机制使用细则. 1、不要太依赖异常机制   python 的异常机制非常方便，对于信息的传递中十分好用（这里信息的传递主要有三种，参数传递，全局变量传递，以及异常机制传递），但滥用异常机制也会带来一些负面影响。过度使用异常主要表现在两个方面：①把异常和普通错误混淆在一起，不再编写任何错误处理代码，而是以简单地引发异常来代苦所有的错误处理。②使用异常处理来代替流程控制。例子如下： buf = "hello"#例1：使用异常处理来遍历arr数组的每个元素try: i = 0 while True: print (buf [i]) i += 1except: pass#例2：使用流程控制避免下标访问异常i = 0while i < len(buf ): print(buf [i]) i += 1   例1中假如循环过度便会下标访问异常，这时候把错误抛出，再进行一系列处理，显然是不可取的，因为异常机制的效率比正常的流程控制效率差，显然例2中简单的业务流程就可以避开这种错误。所以不要熟悉了异常的使用方法后，遇到这种简单逻辑，便不管三七二十一引发异常后再进行解决。对于完全己知的错误和普通的错误，应该编写处理这种错误的代码，增加程序的健壮性。只有对于外部的、不能确定和预知的运行时错误才使用异常。 2、不要在 try 块中引入太多的代码 Das Platzieren einer großen Menge Code im Try-Block erscheint „einfach“ und das Code-Framework ist leicht zu verstehen. Da der Code im Try-Block jedoch zu umfangreich und das Geschäft zu komplex ist, besteht die Möglichkeit von Ausnahmen im Try-Block haben stark zugenommen, wodurch es schwieriger wird, die Ursache der Anomalie zu analysieren.   Und wenn der Block zu groß ist, ist es unvermeidlich, dem Try-Block eine große Anzahl von Ausnahmeblöcken zu folgen, um unterschiedliche Verarbeitungslogik für verschiedene Ausnahmen bereitzustellen. Wenn auf denselben Try-Block eine große Anzahl von Except-Blöcken folgt, müssen Sie die logische Beziehung zwischen ihnen analysieren, was die Programmierkomplexität erhöht. Deshalb Sie können den großen Try-Block in mehrere kleine Blöcke aufteilen und dann die Ausnahmen abfangen und behandeln. 3. Ignorieren Sie keine abgefangenen Ausnahmen  Ignorieren Sie keine Ausnahmen! Nachdem die Ausnahme nun abgefangen wurde, sollte der Exception-Block etwas Nützliches tun und die Ausnahme behandeln und beheben. Es ist unangemessen, den gesamten Ausnahmeblock leer zu lassen oder nur einfache Ausnahmeinformationen auszugeben! Die spezifischen Behandlungsmethoden sind: ① Behandlung von Ausnahmen. Machen Sie entsprechende Reparaturen an der Ausnahme durch und umgehen Sie dann die Stelle, an der die Ausnahme aufgetreten ist, oder verwenden Sie andere Daten, um Berechnungen anstelle des erwarteten Methodenrückgabewerts durchzuführen, oder fordern Sie den Benutzer auf, das Programm erneut auszuführen Sie sollten versuchen, die Ausnahme zu reparieren, damit das Programm den Betrieb wieder aufnehmen kann. ② Eine neue Ausnahme erneut auslösen. Vervollständigen Sie so weit wie möglich, was in der aktuellen Betriebsumgebung möglich ist, übersetzen Sie dann die Ausnahme, packen Sie die Ausnahme in eine Ausnahme der aktuellen Ebene und übergeben Sie sie erneut an den Aufrufer der oberen Ebene. ③ Behandeln Sie Ausnahmen auf der entsprechenden Ebene. Wenn die aktuelle Schicht nicht weiß, wie die Ausnahme behandelt werden soll, verwenden Sie nicht die Ausnahmeanweisung in der aktuellen Schicht, um die Ausnahme abzufangen, und lassen Sie den Aufrufer der oberen Schicht für die Behandlung der Ausnahme verantwortlich sein. Zusammenfassung  Dieser Artikel beginnt mit den Standardausnahmen des Systems, erklärt, was Ausnahmen sind, fasst die allgemeinen Ausnahmeklassen im System zusammen und beschreibt dann, wie Ausnahmen angepasst werden, von der Definition von Ausnahmen über das Auslösen bis zum Abrufen der benutzerdefinierten Ausnahmen Definieren Sie die Definition und Verwendung von Ausnahmen und fassen Sie abschließend die Vorsichtsmaßnahmen bei der Verwendung von Python-Ausnahmen zusammen. Verwandte kostenlose Lernempfehlungen: Python-Tutorial(Video)

Das obige ist der detaillierte Inhalt vonVerstehen Sie den Ausnahmemechanismus von Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!