Quelle est la méthode de gestion des exceptions dans le didacticiel de base Python ?

Exception

Dans Python, l'objet d'exception (objet d'exception) est utilisé pour représenter des situations anormales qui se produisent lors de l'exécution du code lorsqu'une erreur se produit dans le programme en cours d'exécution. une exception sera levée. 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

Si l'exception n'est pas gérée correctement, l'exécution sera terminée.

Vous pouvez imaginer, si vous développez un produit et qu'une exception se produit et que vous ne signalez pas la cause de l'exception, ce sera très inconfortable et il sera difficile de résoudre le problème anormal.

Afin d'améliorer la stabilité et la flexibilité du produit, Python exécute les développeurs pour capturer et gérer diverses exceptions. Les erreurs générales du module interne telles que la Classe d'exception KeyError sont plus courantes. . Bien sûr, il y en a bien d’autres aussi.

Erreurs et exceptions

Une brève introduction, Python divise les erreurs d'exécution de code en deux catégories : l'erreur de syntaxe (erreur de syntaxe) et l'exception (exception) .

Erreur de grammaire

Tout d’abord, il y a le problème des erreurs grammaticales. Il ressort des mots que l'erreur d'analyse du code est fausse.

Ce type d'erreur se produit généralement chez les débutants. La raison principale est que le code en cours d'exécution n'est pas conforme aux spécifications de syntaxe Python, donc une erreur de syntaxe sera signalée et le code s'arrêtera.

Un exemple d'erreur est donné ci-dessous :

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

D'après le rapport d'erreur ci-dessus, nous pouvons savoir qu'il s'agit d'une erreur de syntaxe et d'une syntaxe invalide. Et a souligné que l'erreur est dans la position de for. Évidemment, if et for ne peuvent pas être utilisés ensemble.

Exception

Une exception est une erreur trouvée lors de l'exécution du code. Il est difficile de la trouver à l'avance Même si le code est écrit de manière très standard, des exceptions d'exécution peuvent survenir.

Un exemple d'erreur est donné ci-dessous. Dans les opérations mathématiques, un problème fréquemment discuté est le cas de la division par zéro. Cependant, 0 n'est pas autorisé comme diviseur car cela provoquerait une exception.

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')

Évidemment, le message d'erreur indique que 0 est incorrect comme diviseur.

Gestion des exceptions

Après avoir compris les erreurs et les exceptions, nous devons gérer les exceptions. Des problèmes tels que les erreurs de syntaxe peuvent être évités en pratiquant davantage. Pour la deuxième exception, python fournit une instruction try-sauf pour la gérer.

Pour une explication plus claire, prenons comme exemple le cas ci-dessus où le diviseur est 0. Nous capturons et gérons les exceptions en ajoutant une instruction try-sauf :

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')

Ensuite, nous appelons la fonction dans. le terminal Essayez :

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

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

Sortie :

0 ne peut pas être utilisé comme diviseur ! ! !

Bien que notre saisie soit erronée et devrait théoriquement signaler une erreur, aucune erreur n'a été signalée et un paragraphe a été renvoyé.

Ce qui suit explique le fonctionnement de l'instruction try-sauf :

1. Le code dans Try-sauf sera exécuté normalement🎜 li>
2. 🎜Si aucune exception ne se produit, ignorez le bloc de code except et terminez try-sauf🎜
3. 🎜Si une exception de problème se produit dans une certaine ligne de code dans try-sauf, le code restant s'arrête exécution. Si Si l'exception qui se produit est cohérente avec ce qui est spécifié dans except, le bloc de code dans except est exécuté, la gestion des exceptions se termine et l'application entière continue de s'exécuter 🎜
4. 🎜Si l'exception. qui se produit n'est pas cohérent avec ce qui est spécifié dans except, alors l'instruction try apparaîtra, le programme continue de lever des exceptions et termine l'exécution du code🎜

🎜Bien sûr, le code que nous avons. write peut avoir plusieurs exceptions, nous pouvons donc écrire toutes les exceptions dans un bloc d'instruction except, l'implémentation spécifique est la suivante : 🎜

try:
	pass
except:
	pass
else:
	pass

🎜Si une expression d'exception dans la liste d'exceptions est interceptée, elle entrera sauf traitement. 🎜🎜Bien sûr, si vous souhaitez gérer chaque exception individuellement, vous pouvez également la gérer une par une : 🎜

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

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

🎜🎜Je m'arrêterai ici aujourd'hui et je mettrai à jour demain, je vais sauter à la corde. jour, vieux rouleau de poulet de Pékin à l'intérieur ~ (2022.4.20)🎜🎜🎜Les types d'exception de Python peuvent être hérités. Nous avons seulement besoin de savoir ici que si l'exception spécifiée après except hérite de l'exception précédente, l'exception suivante sera également interceptée. , un exemple est le suivant : 🎜

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

🎜 affichera : 🎜🎜🎜A🎜B🎜C🎜🎜🎜Au contraire, si l'ordre de except est inversé, seul A sera affiché puisque les exceptions B et C héritent toutes deux de. A, donc après avoir détecté l'exception B, cela se terminera : 🎜

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

🎜La sortie est entièrement A : 🎜🎜🎜A🎜A🎜A🎜🎜🎜Si toutes les exceptions sont extraites une par une, ce sera très gênant. cette fois, vous pouvez Si le type d'exception n'est pas défini dans un except, toutes les exceptions non interceptées restantes seront interceptées : 🎜

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

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

🎜Une fonction importante : else.🎜🎜L'instruction else est utilisée pour effectuer certaines opérations supplémentaires, telles que l'exécution dans le bloc de code try Certaines opérations sur les fichiers peuvent libérer des ressources dans else. Le format de syntaxe de else est le suivant : 🎜rrreee🎜Bien sûr, nous pouvons également opérer des exceptions, comme suit : 🎜rrreee🎜Lancer des exceptions indépendamment🎜🎜Les développeurs ne font pas d'erreurs d'exécution. dans certaines situations normales, mais cela n'est pas conforme à la logique de conception, les développeurs doivent donc lancer activement des exceptions. À ce stade, nous devons utiliser l'instruction raise pour lancer des exceptions : 🎜rrreee🎜Exceptions personnalisées🎜🎜Lorsque Python est intégré. les exceptions ne peuvent pas répondre aux besoins de développement, vous pouvez personnaliser les exceptions. 🎜

自定义异常类必须要直接或间接继承自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('运算结束~')

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!