Débogage et analyse de scripts Python (exemples de code)

Le contenu de cet article concerne le débogage et l'analyse des scripts Python (exemples de code). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Le débogage et le profilage jouent un rôle important dans le développement Python. Les débogueurs aident les programmeurs à analyser le code complet. Le débogueur définit des points d'arrêt, tandis que le profileur exécute notre code et nous fournit des détails sur le temps d'exécution, le profileur identifiera les goulots d'étranglement dans le programme.

Technologie de débogage Python

Le débogage est le processus de résolution des problèmes qui surviennent dans le code et empêchent le logiciel de fonctionner correctement. En Python, le débogage est très simple. Le débogueur Python définit des points d'arrêt conditionnels et débogue le code source une ligne à la fois. Nous utiliserons le module pdb de la bibliothèque standard Python pour déboguer nos scripts Python.

Pour mieux déboguer les programmes Python, diverses techniques peuvent être utilisées. Nous aborderons quatre techniques de débogage Python :

• Instruction print() : C'est le moyen le plus simple de comprendre ce qui se passe, afin que vous puissiez inspecter ce qui a été exécuté.
• logging : c'est comme une déclaration imprimée, mais avec plus d'informations contextuelles afin que vous puissiez bien la comprendre.
• débogueur pdb : Il s'agit d'une technique de débogage couramment utilisée. L'avantage d'utiliser pdb est que vous pouvez utiliser pdb à partir de la ligne de commande, de l'interpréteur et du programme.
• Débogueur IDE : L'IDE dispose d'un débogueur intégré. Il permet aux développeurs d'exécuter leur code, qui peut ensuite inspecter le programme au fur et à mesure de son exécution.

Gestion des erreurs (gestion des exceptions)

Dans cette section, nous apprendrons comment Python gère les exceptions. Les exceptions sont des erreurs qui se produisent lors de l'exécution du programme. Chaque fois qu'une erreur se produit, Python génère une exception, qui sera gérée à l'aide d'un bloc try...sauf. Le programme ne peut pas gérer certaines exceptions, provoquant ainsi des messages d'erreur. Voyons maintenant quelques exemples inhabituels.

Dans le terminal, lancez la console interactive python3 et nous verrons quelques exemples d'exceptions :

student@ubuntu:~$ python3
Python 3.5.2 (default, Nov 23 2017, 16:37:01)
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>
>>> 50 / 0

Traceback (most recent call last):
 File "", line 1, in ZeropisionError: pision by zero
>>>
>>> 6 + abc*5
Traceback (most recent call last):
  File "", line 1, in NameError: name 'abc' is not defined
>>>
>>> 'abc' + 2
Traceback (most recent call last):
  File "", line 1, in TypeError: Can't convert 'int' object to str implicitly
>>>
>>> import abcd
Traceback (most recent call last):
  File "", line 1, in ImportError: No module named 'abcd'
>>>

Voici quelques exemples d'exceptions. Nous allons maintenant voir comment gérer les exceptions.

Chaque fois qu'une erreur se produit dans un programme Python, une exception est levée. Nous pouvons également utiliser le mot-clé raise pour forcer le déclenchement d’une exception.

Nous allons maintenant voir un bloc try...sauf qui gère les exceptions. Dans le bloc try, nous écrirons du code pouvant générer des exceptions. Dans le bloc except, nous écrirons la solution pour cette exception.

La syntaxe try...sauf est la suivante :

try:
            statement(s)
except:
            statement(s)

Un bloc try peut avoir plusieurs instructions except. Nous pouvons également gérer des exceptions spécifiques en entrant le nom de l'exception après le mot-clé except. La syntaxe de gestion d'une exception spécifique est la suivante :

try:
            statement(s)
except exception_name:
            statement(s)

Nous allons créer un script exception_example.py pour intercepter ZeropisionError. Écrivez le code suivant dans le script :

a = 35
b = 57
try:
            c = a + b
            print("The value of c is: ", c)
            d = b / 0
            print("The value of d is: ", d)
 
except:
            print("pision by zero is not possible")
 
print("Out of try...except block")

Exécutez le script comme indiqué ci-dessous et vous obtiendrez le résultat suivant :

student@ubuntu:~$ python3 exception_example.py
The value of c is:  92
pision by zero is not possible
Out of try...except block

Outil de débogage

Python prend en charge de nombreux outils de débogage :

• winpdb
• pydev
• pydb
• pdb
• gdb
• pyDebug

Dans cette section, nous découvrirons le débogueur pdb Python. pdbmodule fait partie de la bibliothèque standard Python et est toujours disponible.

Débogueur pdb

Le module pdb est utilisé pour déboguer les programmes Python. Les programmes Python utilisent le débogueur de code source interactif pdb pour déboguer les programmes. pdb définit des points d'arrêt, inspecte les cadres de pile et répertorie le code source.

Nous allons maintenant apprendre à utiliser le débogueur pdb. Il y a trois manières d'utiliser ce débogueur :

· Dans l'interpréteur

· Depuis la ligne de commande

· Dans un script Python

Nous allons créer Un script pdb_example.py et ajoutez le contenu suivant dans ce script :

class Student:
            def __init__(self, std):
                        self.count = std
 
            def print_std(self):
                        for i in range(self.count):
                                    print(i)
                        return
if __name__ == '__main__':
            Student(5).print_std()

En prenant ce script comme exemple pour apprendre le débogage Python, nous verrons comment démarrer le débogueur en détail.

Dans l'interpréteur

Pour démarrer le débogueur depuis la console interactive Python, on utilise run() ou runeval().

Démarrez la console interactive python3. Exécutez la commande suivante pour démarrer la console :

$ python3

Importez notre nom de script pdb_example et notre module pdb. Maintenant, nous allons utiliser run() et nous passons l'expression de chaîne comme argument à run() L'interpréteur Python lui-même :

student@ubuntu:~$ python3
Python 3.5.2 (default, Nov 23 2017, 16:37:01)
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>
>>> import pdb_example
>>> import pdb
>>> pdb.run('pdb_example.Student(5).print_std()')
> (1)()
(Pdb)

Pour continuer le débogage, entrez continue après l'invite (Pdb) et appuyez sur Entrée. Si vous souhaitez connaître les options que nous pouvons utiliser ici, appuyez deux fois sur la touche Tab après l'invite (Pdb).

Maintenant, après avoir tapé continuer, nous obtiendrons le résultat suivant :

student@ubuntu:~$ python3
Python 3.5.2 (default, Nov 23 2017, 16:37:01)
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>
>>> import pdb_example
>>> import pdb
>>> pdb.run('pdb_example.Student(5).print_std()')
> (1)()
(Pdb) continue
0
1
2
3
4
>>>

Le moyen le plus simple et le plus efficace d'exécuter le débogueur est à partir de la ligne de commande

La manière directe est depuis la ligne de commande. Notre programme servira d'entrée au débogueur. Vous pouvez utiliser le débogueur depuis la ligne de commande comme suit :

$ python3 -m pdb pdb_example.py

Lorsque vous exécutez le débogueur depuis la ligne de commande, le code source sera chargé et il arrêtera l'exécution à la première ligne trouvée. Entrez continuer pour continuer le débogage. Voici le résultat :

student@ubuntu:~$ python3 -m pdb pdb_example.py
> /home/student/pdb_example.py(1)()
-> class Student:
(Pdb) continue
0
1
2
3
4
The program finished and will be restarted
> /home/student/pdb_example.py(1)()
-> class Student:
(Pdb)

Dans un script Python

Les deux premières techniques lanceront le débogueur au début du programme Python. Mais cette troisième technique est la mieux adaptée aux processus de longue durée. Pour démarrer le débogueur dans un script, utilisez set_trace().

Maintenant, modifiez votre fichier pdb_example.py comme suit :

import pdb
class Student:
            def __init__(self, std):
                        self.count = std
 
            def print_std(self):
                        for i in range(self.count):
                                    pdb.set_trace()
                                    print(i)
                        return
 
if __name__ == '__main__':
            Student(5).print_std()

现在，按如下方式运行程序：

student@ubuntu:~$ python3 pdb_example.py
> /home/student/pdb_example.py(10)print_std()
-> print(i)
(Pdb) continue
0
> /home/student/pdb_example.py(9)print_std()
-> pdb.set_trace()
(Pdb)

set_trace() 是一个Python函数，因此您可以在程序中的任何位置调用它。

因此，这些是启动调试器的三种方式。

调试基本程序崩溃

在本节中，我们将看到跟踪模块。跟踪模块有助于跟踪程序执行。因此，每当您的Python程序崩溃时，我们都可以理解崩溃的位置。我们可以通过将跟踪模块导入您的脚本以及命令行来使用它。

现在，我们将创建一个名为脚本trace_example.py并在脚本中编写以下内容：

class Student:
            def __init__(self, std):
                        self.count = std
 
            def go(self):
                        for i in range(self.count):
                                    print(i)
                        return
if __name__ == '__main__':
            Student(5).go()

输出如下：

student@ubuntu:~$ python3 -m trace --trace trace_example.py
 --- modulename: trace_example, funcname: trace_example.py(1): class Student:
 --- modulename: trace_example, funcname: Student
trace_example.py(1): class Student:
trace_example.py(2):   def __init__(self, std):
trace_example.py(5):   def go(self):
trace_example.py(10): if __name__ == '__main__':
trace_example.py(11):             Student(5).go()
 --- modulename: trace_example, funcname: init
trace_example.py(3):               self.count = std
 --- modulename: trace_example, funcname: go
trace_example.py(6):               for i in range(self.count):
trace_example.py(7):                           print(i)
0
trace_example.py(6):               for i in range(self.count):
trace_example.py(7):                           print(i)
1
trace_example.py(6):               for i in range(self.count):
trace_example.py(7):                           print(i)
2
trace_example.py(6):               for i in range(self.count):
trace_example.py(7):                           print(i)
3
trace_example.py(6):               for i in range(self.count):
trace_example.py(7):                           print(i)
4

因此，通过trace --trace在命令行使用，开发人员可以逐行跟踪程序。因此，只要程序崩溃，开发人员就会知道崩溃的实例。

分析和计时程序

分析Python程序意味着测量程序的执行时间。它衡量每个功能所花费的时间。Python的cProfile模块用于分析Python程序。

cProfile模块

如前所述，分析意味着测量程序的执行时间。我们将使用cProfile Python模块来分析程序。

现在，我们将编写一个 cprof_example.py 脚本并在其中编写以下代码：

mul_value = 0
def mul_numbers( num1, num2 ):
            mul_value = num1 * num2;
            print ("Local Value: ", mul_value)
            return mul_value
mul_numbers( 58, 77 )
print ("Global Value: ", mul_value)

运行程序，您将看到如下输出：

student@ubuntu:~$ python3 -m cProfile cprof_example.py
Local Value:  4466
Global Value:  0
         6 function calls in 0.000 seconds
   Ordered by: standard name
 
   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.000    0.000    0.000    0.000 cprof_example.py:1()
        1    0.000    0.000    0.000    0.000 cprof_example.py:2(mul_numbers)
        1    0.000    0.000    0.000    0.000 {built-in method builtins.exec}
        2    0.000    0.000    0.000    0.000 {built-in method builtins.print}
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}

因此，使用时cProfile，所有被调用的函数都将打印出每个函数所花费的时间。现在，我们将看到这些列标题的含义：

· ncalls： 通话次数

· tottime： 在给定函数中花费的总时间

· percall：商数tottime除以ncalls

· cumtime：在此和所有方面花费的累计时间 subfunctions

· percall：cumtime除以原始调用的商数

· filename:lineno(function)：提供每个功能的相应数据

timeit

timeit是一个Python模块，用于计算Python脚本的一小部分。您可以从命令行调用timeit，也可以将timeit模块导入到脚本中。我们将编写一个脚本来计算一段代码。创建一个timeit_example.py脚本并将以下内容写入其中：

import timeit
prg_setup = "from math import sqrt"
prg_code = '''
def timeit_example():
            list1 = []
            for x in range(50):
                        list1.append(sqrt(x))
'''
# timeit statement
print(timeit.timeit(setup = prg_setup, stmt = prg_code, number = 10000))

使用timeit，我们可以决定我们要测量的代码片段。因此，我们可以轻松定义设置代码以及我们要单独执行测试的代码段。主代码运行100万次，这是默认时间，而设置代码只运行一次。

使程序运行得更快

有多种方法可以使Python程序运行得更快，例如：

• 描述您的代码，以便识别瓶颈
• 使用内置函数和库，因此解释器不需要执行循环
• 避免使用全局变量，因为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!