Was ist die Methode zur Ausnahmebehandlung im Python-Grundlagen-Tutorial?

Ausnahme

In Python wird das Ausnahmeobjekt (Ausnahmeobjekt) verwendet, um abnormale Situationen darzustellen, die während der Codeausführung auftreten, wenn im ausführenden Programm ein Fehler auftritt Es wird eine Ausnahme ausgelöst. Python中，使用异常对象（exception object）来表示代码执行过程中所发生的异常情况，当执行程序爆出错误的时候则会抛出异常。

如果没有正确处理异常，则会终止运行。

你可以想象一下，如果你在开发一款产品时，出现异常而不报告出发生异常的原因，是不是会很难受，也很难解决异常的问题。

为了提高产品的稳定性与灵活性，Python运行开发者捕捉并处理各类异常，一般的内部模块报错如KeyError异常类较为常见，当然也有很多其他的。

错误与异常

简单了解下，Python将代码执行错误分为两类：语法错误（syntax error）和异常（exception）。

语法错误

首先，是语法错误的问题。字面可知，代码解析错误。

这种错误通常出现在初学者，主要原因是所执行的代码不符合Python语法的规范，故会报出语法错误导致code停机。

下面给出一个错误示范：

>>> if for not in list(1,2,3,4)
  File "<stdin>", line 1
    if for not in list(1,2,3,4)
       ^
SyntaxError: invalid syntax

从上面的报错中可以知道是语法错误，无效的语法。并且指出了错误的地方在for的位置，很显然if和for不能用在一起。

异常

异常则是在代码执行过程中发现的错误，这是很难提前被发现的，即使代码写的很规范标准，但也可能会出现执行异常的情况。

下面给出一个错误示例。在数学运算中，经常讨论的问题是除数为零的情况。然而，0作为除数是不被允许的，因为这样会导致异常情况。

>>> a = 5 / 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

很明显报错指出0作为除数是不对的。

异常处理

当我们了解了错误和异常后，就得处理异常情况。对于语法错误这种问题多多练习即可避免，对于第二种异常，python给出了try-except语句来处理。

为了更清晰的解释，还是以上面的除数为0的情况作为例子，我们通过添加try-except语句捕捉并处理异常情况：

def division(x, y):
	try:
		return x / y
	except ZeroDivisionError:
		print("0不能作为除数！！！")

然后我们再在terminal调用函数试试：

division(x=1, y=0)

输出：

0不能作为除数！！！

虽然我们的输入是错误的理论应该报错，但是并没有报错而且还返回了一段话。

下面解释一下try-except语句的工作原理:

1. Try-except中的代码会被正常执行

2. 如果没有出现异常则跳过except代码块并结束try-except

3. 如果try-except中的某一句代码出现了问题异常，剩余代码停止执行，如果出现的异常与except所指定的一致，则执行except中的代码块，异常处理结束整个应用程序继续执行

4. 如果出现的异常与except中指定的不符合，那么则跳出try语句，程序继续抛出异常并终止执行代码

当然，我们所编写的代码可能会出现多种异常情况，因此我们可以将所有的异常情况写在一个except语句块中，具体实现如下：

except (RuntimeError, TypeError, NameError):pass

如果捕捉到异常列表中的任意一项异常表达式，则都会进入except

Wenn die Ausnahme nicht korrekt behandelt wird, wird der Lauf abgebrochen.

Sie können sich vorstellen, dass es sehr unangenehm sein wird und es schwierig sein wird, das abnormale Problem zu lösen, wenn Sie ein Produkt entwickeln und eine Ausnahme auftritt und Sie die Ursache der Ausnahme nicht melden.

Um die Stabilität und Flexibilität des Produkts zu verbessern, führt Python Entwickler aus, um verschiedene Ausnahmen zu erfassen und zu behandeln, wie z. B. KeyError-Ausnahmeklasse . Natürlich gibt es auch viele andere.

Fehler und Ausnahmen

Eine kurze Einführung: Python unterteilt Codeausführungsfehler in zwei Kategorien: Syntaxfehler (Syntaxfehler) und Ausnahme (Ausnahme) .

Grammatikfehler

Zuallererst gibt es das Problem der Grammatikfehler. Aus den Worten geht hervor, dass der Code-Parsing-Fehler falsch ist.

Diese Art von Fehler tritt normalerweise bei Anfängern auf. Der Hauptgrund dafür ist, dass der ausgeführte Code nicht den Python-Syntaxspezifikationen entspricht, sodass ein Syntaxfehler gemeldet wird und der Code angehalten wird.

Ein Fehlerbeispiel finden Sie unten:

def passpass(x=1):
	try:
		return print(x+x)
	except (RuntimeError, TypeError, NameError):
		pass
	except TypeError:
		print('参数错误啦~')
	except NameError:
		print('名称错误啦~')

Aus dem obigen Fehlerbericht können wir erkennen, dass es sich um einen Syntaxfehler und eine ungültige Syntax handelt. Und wies darauf hin, dass der Fehler an der Stelle von for liegt. Offensichtlich können if und for nicht zusammen verwendet werden.

Ausnahme

Eine Ausnahme ist ein Fehler, der während der Ausführung des Codes gefunden wird. Es ist schwierig, ihn im Voraus zu finden. Selbst wenn der Code auf eine sehr standardmäßige Weise geschrieben ist, können Ausführungsausnahmen auftreten.

Ein Fehlerbeispiel finden Sie unten. Ein häufig diskutiertes Problem bei mathematischen Operationen ist die Division durch Null. Allerdings ist 0 als Teiler nicht zulässig, da dies eine Ausnahme auslösen würde.

class A(Exception):
	pass
class B(A):
	pass
class C(B):
	pass

for cls in [A, B, C]:
	try:
		raise cls()
	except C:
		print('C')
	except B:
		print('B')
	except A:
		print('A')

Offensichtlich deutet die Fehlermeldung darauf hin, dass 0 als Teiler falsch ist.

Ausnahmebehandlung

Nachdem wir Fehler und Ausnahmen verstanden haben, müssen wir Ausnahmen behandeln. Probleme wie Syntaxfehler können durch mehr Übung vermieden werden. Für die zweite Ausnahme stellt python eine try-exclusive-Anweisung zur Verfügung, um sie zu behandeln.

Für eine klarere Erklärung nehmen wir den obigen Fall, in dem der Divisor 0 ist, als Beispiel. Wir erfassen und behandeln Ausnahmen, indem wir eine try-exclusive-Anweisung hinzufügen:

class A(Exception):
	pass
class B(A):
	pass
class C(B):
	pass

for cls in [A, B, C]:
	try:
		raise cls()
	except A:
		print('A')
	except B:
		print('B')
	except C:
		print('C')

Dann rufen wir die Funktion auf das Terminal Versuchen Sie:

def passpass(x=1):
	try:
		return print(x/x)

	except TypeError:
		print('参数错误啦~')
	except NameError:
		print('名称错误啦~')
	except:
		print('报错啦~自己查')

Ausgabe:

0 kann nicht als Teiler verwendet werden! ! !

Obwohl unsere Eingabe falsch war und theoretisch ein Fehler gemeldet werden müsste, wurde kein Fehler gemeldet und ein Absatz zurückgegeben.

Im Folgenden wird erklärt, wie die try-exclusive-Anweisung funktioniert:

1. Der Code in Try-exclusive wird normal ausgeführt🎜 li>
2. 🎜Wenn keine Ausnahme auftritt, überspringen Sie den Except-Codeblock und beenden Sie try-exclusive🎜
3. 🎜Wenn in einer bestimmten Codezeile in try-exclusive eine Problemausnahme auftritt, stoppt der verbleibende Code Wird ausgeführt. Wenn die auftretende Ausnahme mit den Angaben in „außer“ übereinstimmt, wird der Codeblock in „außer“ ausgeführt und die Ausnahmebehandlung endet und die gesamte Anwendung wird weiterhin ausgeführt 🎜
4. 🎜Wenn die Ausnahme auftritt Wenn das auftritt, stimmt es nicht mit dem überein, was in „außer“ angegeben ist. Dann wird die try-Anweisung ausgegeben, das Programm löst weiterhin Ausnahmen aus und beendet die Ausführung des Codes🎜

🎜Natürlich ist der Code, den wir haben Beim Schreiben können mehrere Ausnahmen vorhanden sein, sodass wir alle Ausnahmen in einen Ausnahme-Anweisungsblock schreiben können. Die spezifische Implementierung lautet wie folgt: 🎜

try:
	pass
except:
	pass
else:
	pass

🎜Wenn ein Ausnahmeausdruck in der Ausnahmeliste abgefangen wird, wird außer eingegeben Verarbeitung. 🎜🎜Wenn Sie jede Ausnahme einzeln behandeln möchten, können Sie sie natürlich auch einzeln behandeln: 🎜

def passpass(x=1):
	try:
		return print(x/x)

	except TypeError as error:
		print('参数错误啦~', error)
	except NameError:
		print('名称错误啦~')
	except:
		print('报错啦~自己查')

🎜🎜Ich werde heute hier aktualisieren und morgen werde ich das Seil überspringen. roll rolls every day, old Beijing Chicken roll inside~ (2022.4.20)🎜🎜🎜Python-Ausnahmetypen können hier nur geerbt werden, wenn die nachfolgende Ausnahme von der vorherigen Ausnahme erbt abgefangen werden. Das Beispiel lautet wie folgt: 🎜

>>> raise NameError('HiThere')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: HiThere

🎜 wird ausgegeben: 🎜🎜🎜A🎜B🎜C🎜🎜🎜Wenn die Reihenfolge von „außer“ umgekehrt ist, wird nur „A“ ausgegeben, da die Ausnahmen „B“ und „C“ sind beide erben von A, also wird nach dem Abfangen der B-Ausnahme beendet: 🎜

class Error(Exception):
	"""Base class for exception in this module."""
	pass

class InputError(Error):
	"""Exception raised for errors in the input.

	Attributes:
		expression -- input expression in which the error occurred
		message -- explanation of the winerror

	"""
	def __init__(self, expression, message):
		self.expression = expression
		self.message = message

🎜Die Ausgabe ist ganz A: 🎜🎜🎜A🎜A🎜A🎜🎜🎜Wenn alle Ausnahmen einzeln extrahiert werden, ist dies sehr Dies ist problematisch. Wenn der Ausnahmetyp nicht in einer Ausnahme festgelegt ist, werden alle verbleibenden nicht abgefangenen Ausnahmen abgefangen: 🎜

def passpass(x=1):
	try:
		return print(x/x)

	except TypeError as error:
		print('参数错误啦~', error)
	except NameError:
		print('名称错误啦~')
	except:
		print('报错啦~自己查')
	finally:
		print('运算结束~')

🎜Eine wichtige Funktion: else.🎜🎜Die else-Anweisung wird verwendet, um einige zusätzliche Vorgänge auszuführen, z Beim Ausführen im Try-Codeblock können einige Dateivorgänge Ressourcen in else freigeben. Das Syntaxformat von else lautet wie folgt: 🎜rrreee🎜Natürlich können wir auch Ausnahmen wie folgt ausführen: 🎜rrreee🎜Ausnahmen unabhängig auslösen🎜🎜Entwickler tun dies nicht Machen Sie in einigen normalen Situationen Ausführungsfehler, aber es entspricht nicht der Designlogik, daher müssen Entwickler aktiv Ausnahmen auslösen. Zu diesem Zeitpunkt müssen wir die Raise-Anweisung verwenden, um Ausnahmen auszulösen: 🎜rrreee🎜Benutzerdefinierte Ausnahmen🎜🎜Wenn Python Integrierte Ausnahmen können die Entwicklungsanforderungen nicht erfüllen. Sie können Ausnahmen anpassen. 🎜

自定义异常类必须要直接或间接继承自Exception类。尽管自定义异常类与其他类具有相同的功能，但为保持简洁，应该仅提高必要的属性。

class Error(Exception):
	"""Base class for exception in this module."""
	pass

class InputError(Error):
	"""Exception raised for errors in the input.

	Attributes:
		expression -- input expression in which the error occurred
		message -- explanation of the winerror

	"""
	def __init__(self, expression, message):
		self.expression = expression
		self.message = message

finally子句

else在代码正常执行后才会被执行的代码块，但有些情况无论代码块是否出现异常都要执行，则需要用到finally语句：

def passpass(x=1):
	try:
		return print(x/x)

	except TypeError as error:
		print('参数错误啦~', error)
	except NameError:
		print('名称错误啦~')
	except:
		print('报错啦~自己查')
	finally:
		print('运算结束~')

Das obige ist der detaillierte Inhalt vonWas ist die Methode zur Ausnahmebehandlung im Python-Grundlagen-Tutorial?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!