Outils/Utilitaires Python

Outils et utilitaires de développement Python

L’écosystème Python comprend divers modules intégrés et outils tiers qui facilitent le développement, le débogage et l’analyse des performances. Voici quelques exemples clés de la bibliothèque standard.

Le module dis : Désassembleur Python

Le module dis vous aide à comprendre le bytecode Python, la représentation intermédiaire dans laquelle CPython compile votre code source avant l’exécution. Il peut être utile pour l’optimisation des performances ou pour comprendre comment Python exécute des constructions spécifiques.

Vous pouvez utiliser dis depuis la ligne de commande (python -m dis your_script.py) ou de manière programmatique dans votre code. La fonction dis.dis() accepte des fonctions, des méthodes, des classes ou des objets code.

Exemple

Désassemblons une fonction simple :

import dis

def calculate_sum(a, b):
    """Calcule la somme de deux nombres."""
    result = a + b
    print(f"{a} + {b} = {result}")
    return result

# Désassembler la fonction
dis.dis(calculate_sum)

Ceci pourrait produire une sortie similaire à (le bytecode peut varier légèrement entre les versions de Python) :

  4           0 LOAD_FAST                0 (a)
              2 LOAD_FAST                1 (b)
              4 BINARY_ADD
              6 STORE_FAST               2 (result)

  5           8 LOAD_GLOBAL              0 (print)
             10 LOAD_FAST                0 (a)
             12 FORMAT_VALUE             0
             14 LOAD_CONST               1 (' + ')
             16 LOAD_FAST                1 (b)
             18 FORMAT_VALUE             0
             20 LOAD_CONST               2 (' = ')
             22 LOAD_FAST                2 (result)
             24 FORMAT_VALUE             0
             26 BUILD_STRING             5
             28 CALL_FUNCTION            1
             30 POP_TOP

  6          32 LOAD_FAST                2 (result)
             34 RETURN_VALUE

Le module pdb : Débogueur Python

Le module pdb fournit un débogueur de code source interactif pour les programmes Python. Il vous permet de définir des points d’arrêt (breakpoints), d’exécuter le code ligne par ligne (step through), d’inspecter les variables et de comprendre le flux du programme.

Vous pouvez invoquer pdb depuis la ligne de commande (python -m pdb your_script.py) ou définir des points d’arrêt (breakpoints) directement dans votre code en utilisant import pdb; pdb.set_trace(). Depuis Python 3.7, la fonction intégrée breakpoint() est la méthode recommandée pour entrer dans le débogueur.

Exemple :

Considérons ce script (sum_debug.py) :

def calculate_sum(a, b):
    result = a + b
    breakpoint() # Entrer dans le débogueur ici
    print(f"{a} + {b} = {result}")
    return result

num1 = 10
num2 = 20
calculate_sum(num1, num2)
print("Finished.")

L’exécution de python sum_debug.py mettra en pause l’exécution à la ligne breakpoint() et entrera dans la session interactive pdb :

-> print(f"{a} + {b} = {result}")
(Pdb)

Vous pouvez ensuite utiliser des commandes comme n (ligne suivante), c (continuer l’exécution), p <variable> (afficher la valeur de la variable), l (afficher le code source), q (quitter). Tapez help pour une liste complète des commandes.

Les modules profile et cProfile : Profilage des performances

cProfile (recommandé en raison de sa surcharge plus faible) et profile sont des modules Python standard pour le profilage des performances. Ils aident à identifier les goulots d’étranglement dans votre code en mesurant le temps passé dans différentes fonctions.

Vous pouvez exécuter le profileur depuis la ligne de commande : python -m cProfile your_script.py

Exemple

Profilons un script simple (profile_example.py) :

def slow_function():
    total = 0
    for i in range(10000):
        total += i
    return total

def fast_function():
    return sum(range(10000))

slow_function()
fast_function()
print("Profiling done.")

L’exécution de python -m cProfile -s cumulative profile_example.py pourrait produire la sortie suivante :

Profiling done.
         4 function calls in 0.001 CPU seconds

   Ordered by: cumulative time

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.000    0.000    0.001    0.001 {built-in method builtins.exec}
        1    0.000    0.000    0.001    0.001 profile_example.py:1(<module>)
        1    0.001    0.001    0.001    0.001 profile_example.py:1(slow_function)
        1    0.000    0.000    0.000    0.000 profile_example.py:7(fast_function)
        1    0.000    0.000    0.000    0.000 {built-in method builtins.sum}
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}

La sortie affiche le nombre d’appels (ncalls), le temps total passé dans la fonction elle-même (tottime), le temps par appel (percall), le temps cumulé passé dans la fonction et toutes les fonctions qu’elle a appelées (cumtime), ainsi que des informations sur la fonction. Des outils comme snakeviz peuvent analyser visuellement les fichiers de sortie de cProfile pour de meilleures informations.

Remarque : Le module tabnanny mentionné dans les anciens tutoriels est obsolète et a été supprimé dans Python 3. Les outils modernes de qualité de code comme les linters (flake8, pylint) et les formateurs (black) gèrent les vérifications d’indentation et de style.