Introduction aux erreurs Python, aux exceptions et aux méthodes de débogage des programmes (avec code)

Cet article vous présente une introduction aux erreurs python, aux exceptions et aux méthodes de débogage des programmes (avec code). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Les exceptions sont des erreurs causées par les programmes Python lors de l'exécution. Si une exception non gérée est levée dans le programme, le programme se terminera en raison de l'exception. Ce n'est qu'en ajoutant la gestion des exceptions au programme que le programme pourra être plus "robuste". ".

Python a sa propre forme grammaticale pour gérer les exceptions. Apprenez à gérer les exceptions et le débogage des programmes en Python. Le contenu principal est :

• Éléments de la liste
• Liste. items
• Erreurs de syntaxe;
• Le concept d'exceptions;
• Utiliser les instructions try pour intercepter les exceptions;
• Gestion des exceptions courantes;
• Exception personnalisée ;
• Utilisez pdb pour déboguer les programmes Python.

7.1 Erreur de syntaxe

1. Les fautes d'orthographe

font référence à une faute d'orthographe de mots-clés dans le langage Python, à une faute d'orthographe de noms de variables, de noms de fonctions, etc.

Si le mot-clé est mal orthographié, SyntaxError（语法错误） sera invité, et si le nom de la variable ou le nom de la fonction est mal orthographié, une invite NameError的错误 sera émise au moment de l'exécution

<.>2. Le programme de script n'est pas conforme aux spécifications de syntaxe de Python

, telles que les crochets manquants, les deux-points et autres symboles, ainsi que les erreurs d'expression dans l'écriture.

3． Erreur d'indentation

Parce que la syntaxe Python stipule que l'indentation est l'une des syntaxes du programme, ce qui devrait être un aspect unique du langage Python. De manière générale, l'indentation standard de Python est de 4 espaces. Bien entendu, vous pouvez utiliser Tab selon vos propres habitudes. Cependant, le même style d’indentation doit être utilisé de manière cohérente dans le même programme ou projet.

7.2 Gestion des exceptions

Les exceptions sont des erreurs causées par les programmes Python lors de leur exécution. Si une exception non gérée est levée dans le programme, le script se terminera en raison de l'exception. Ce n'est qu'en détectant ces exceptions dans le programme et en effectuant le traitement approprié que le programme ne pourra pas être interrompu.

7.2.1 Syntaxe de base pour la gestion des exceptions

L'instruction try est utilisée en Python pour gérer les exceptions. Comme d'autres instructions en Python, l'instruction try utilise également une structure d'indentation. a un bloc d’instructions Selected else facultatif. La forme de base d’une instruction try générale est la suivante.

try:
　　   <语句（块）>            #可能产生异常的语句（块）
　　except <异常名1>:          #要处理的异常
　　   <语句（块）>            #异常处理语句
　　except <异常名2>:          #要处理的异常
　　   <语句（块）>            #异常处理语句
　　else:
　　   <语句（块）>            #未触发异常，则执行该语句（块）
　　finally:
　　   <语句（块）>            #始终执行该语，一般为了达到释放资源等目的
　　

Dans les applications réelles, certaines déclarations peuvent être utilisées en fonction des besoins du programme :

Formulaire 1 :

try:
　　   <语句（块）>
　　except <异常名1>:
　　   <语句（块）>
　　

Exemple :

def testTry (index, flag=False):
　　   stulst = ["John","Jenny","Tom"]
　　   if flag:                         #flag为True时，捕获异常
　　      try:
　　         astu = stulst [index]
　　      except IndexError:
　　         print("IndexError")
　　      return "Try Test Finished!"
　　   else:                            #flag为False时，不捕获异常
　　      astu =stulst [index]
　　      return "No Try Test Finished!"
　　print("Right params testing start...")
　　print (testTry (1, True))           #不越界参数，捕获异常（正常）
　　print (testTry (1, False))          #不越界参数，不捕获异常（正常）
　　print("Error params testing start...")
　　print (testTry (4, True))           #越界参数，捕获异常（正常）
　　print (testTry (4, False))          #越界参数，不捕获异常(程序运行会中断)
　　

Formulaire 2 :

>7.2.2 Principales exceptions intégrées de Python et leur gestion

 try:
　      　<语句（块）>
　   　except < 异常名1>:
　      　<语句（块）>
　　   finally:
　　      <语句（块）>
　

Les exceptions courantes en Python ont été prédéfinies. Dans un environnement interactif, utilisez la commande dir (__builtins__), Toutes les exceptions prédéfinies seront affichées.

except语句主要有以下几种用法：

except:                              #捕获所有异常；
except <异常名>:                      #捕获指定异常；
except （异常名1，异常名2):            #捕获异常名1或者异常名2；
except <异常名> as <数据>:            #捕获指定异常及其附加的数据；
except（异常名1，异常名2）as <数据>：  #捕获异常名1或者异常名2及异常的附加数据。

7.3　手工抛出异常

为了程序的需要，程序员还可以自定义新的异常类型，例如对用户输入文本的长度有要求，则可以使用raise引发异常，以确保文本输入的长度符合要求。

7.3.1　用raise手工抛出异常

使用raise引发异常十分简单，raise有以下几种使用方式。

　　raise　异常名
　　raise　异常名，附加数据
　　raise　类名
使用raise可以抛出各种预定的异常，即使程序在运行时根本不会引发该异常。

def testRaise2():
        for i in range (5):
             try:
                if i==2:    #i==2抛出NameError异常
                  raise NameError
             except NameError:
                print('Raise a NameError!')
             print (i)
        print('end...')

testRaise2 ()

运行结果:

0
1
Raise a NameError!
2
3
4
end...

7.3.2　assert语句

assert语句的一般形式如下。

assert <条件测试>, <异常附加数据>           #其中异常附加数据是可选的

assert语句是简化的raise语句，它引发异常的前提是其后面的条件测试为假。

举例：

def testAssert()：
　　   for i in range (3):
　　      try:
　　         assert i<2
　　      except AssertionError:
　　         print('Raise a AssertionError!')
　　      print (i)
　　   print('end...')

　　testAssert()

运行结果：

0
1
Raise a AssertionError!
2
end...

assert语句一般用于在程序开发时测试代码的有效性。比如某个变量的值必须在一定范围内，而运行时得到的值不符合要求，则引发该异常，对开发者予以提示。所以一般在程序开发中，不去捕获这个异常，而是让它中断程序。原因是程序中已经出现了问题，不应继续运行。

assert语句并不是总是运行的，只有Python内置的一个特殊变量__debug__为True时才运行。要关闭程序中的assert语句就使用python-O（短画线，后接大写字母O）来运行程序。

7.3.3　自定义异常类

在Python中定义异常类不用从基础完全自己定义，只要通过继承Exception类来创建自己的异常类。异常类的定义和其他类没有区别，最简单的自定义异常类甚至可以只继承Exception类，类体为pass如：

class MyError (Exception):          #继承Exception类
　　   pass

如果需要异常类带有一定的提示信息，也可以重载__init__和__str__这两个方法。【相关推荐：python视频教程】

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!