Comment déboguer Python ?

La probabilité que le programme puisse être écrit une fois et exécuté normalement est très faible, fondamentalement pas plus de 1 %. Il y a toujours divers bugs qui doivent être corrigés. Certains bugs sont très simples. Vous pouvez le savoir en regardant le message d'erreur. Certains bugs sont très compliqués. Nous devons donc savoir quelles variables ont des valeurs correctes et quelles variables ont des valeurs incorrectes lorsqu'une erreur se produit. un ensemble complet de moyens pour déboguer le programme afin de corriger le bug. L'article suivant vous présentera la méthode de débogage Python, j'espère qu'il vous sera utile.

Méthode 1 : imprimer

Utilisez print pour imprimer les variables qui peuvent avoir des problèmes. Cette méthode est la plus simple. la brutalité est efficace.

# err.py
def foo(s):
  n = int(s)
  print '>>> n = %d' % n
  return 10 / n

def main():
  foo('0')

main()

Après l'exécution, recherchez la valeur de la variable imprimée dans la sortie :

$ python err.py
>>> n = 0
Traceback (most recent call last):
 ...
ZeropisionError: integer pision or modulo by zero

Le plus gros inconvénient de l'utilisation de print est que vous devrez la supprimer à l'avenir. Pensez au fait qu'il y en a. s'imprime partout dans le programme, et les résultats en cours d'exécution sont également Il contiendra beaucoup de spam.

Méthode 2 : assert

Partout où l'impression est utilisée pour faciliter la visualisation, l'assertion peut être utilisée à la place :

# err.py
def foo(s):
  n = int(s)
  assert n != 0, 'n is zero!'
  return 10 / n

def main():
  foo('0')

assert signifie que le l'expression n != 0 doit être vraie, sinon le code suivant fonctionnera mal.

Si l'assertion échoue, l'instruction assert elle-même lancera AssertionError :

$ python err.py
Traceback (most recent call last):
 ...
AssertionError: n is zero!

Si le programme est plein d'assertions, ce ne sera pas mieux que print. Cependant, vous pouvez utiliser le paramètre -O pour désactiver assert lors du démarrage de l'interpréteur Python :

$ python -O err.py
Traceback (most recent call last):
 ...
ZeropisionError: integer pision or modulo by zero

Après l'avoir désactivé, vous pouvez afficher toutes les instructions assert comme des passes.

Méthode 3 : journalisation

Vous pouvez également remplacer print par logging Par rapport à assert, la journalisation ne générera pas d'erreur et peut être sortie dans un fichier. :

# err.py
import logging

s = '0'
n = int(s)
logging.info('n = %d' % n)
print 10 / n

logging.info() peut générer un morceau de texte. Exécutez-le et constatez qu'il n'y a aucune information à l'exception de ZeropisionError. Que se passe-t-il?

Ne vous inquiétez pas, ajoutez une ligne de configuration après la journalisation de l'importation et réessayez :

import logging
logging.basicConfig(level=logging.INFO)

Voir le résultat :

$ python err.py
INFO:root:n = 0
Traceback (most recent call last):
 File "err.py", line 8, in <module>
  print 10 / n
ZeropisionError: integer pision or modulo by zero

C'est l'avantage de la journalisation , cela vous permet de spécifier le niveau d'informations de journalisation, y compris le débogage, les informations, l'avertissement, l'erreur, etc. Lorsque nous spécifions level=INFO, logging.debug ne fonctionnera pas. De la même manière, après avoir spécifié level=WARNING, le débogage et les informations ne fonctionneront pas. De cette façon, vous pouvez générer en toute sécurité différents niveaux d'informations sans les supprimer, et enfin contrôler quel niveau d'informations est généré.

Un autre avantage de la journalisation est que grâce à une configuration simple, une instruction peut être sortie simultanément vers différents endroits, tels que la console et le fichier.

Méthode 4 : Débogueur pdb

Démarrez le débogueur Python pdb, laissez le programme s'exécuter en mode une seule étape et vous pouvez vérifier l'état d'exécution à tout moment. On prépare d'abord le programme :

# err.py
s = '0'
n = int(s)
print 10 / n

puis on démarre :

$ python -m pdb err.py
> /Users/michael/Github/sicp/err.py(2)<module>()
-> s = &#39;0&#39;

Après avoir démarré avec le paramètre -m pdb, pdb localise le code à exécuter ensuite -> Saisissez la commande l pour afficher le code :

(Pdb) l
 1   # err.py
 2 -> s = '0'
 3   n = int(s)
 4   print 10 / n
[EOF]

Saisissez la commande n pour parcourir le code :

(Pdb) n
> /Users/michael/Github/sicp/err.py(3)<module>()
-> n = int(s)
(Pdb) n
> /Users/michael/Github/sicp/err.py(4)<module>()
-> print 10 / n

A tout moment, vous pouvez saisir la commande p nom de la variable pour visualiser la variable :

(Pdb) p s
'0'
(Pdb) p n
0

Entrez la commande q pour terminer le débogage et quitter le programme :

(Pdb) n
ZeropisionError: 'integer pision or modulo by zero'
> /Users/michael/Github/sicp/err.py(4)<module>()
-> print 10 / n
(Pdb) q

Cette méthode de débogage en ligne de commande via pdb est théoriquement omnipotente, mais elle est vraiment gênante s'il y en a. mille lignes de code, vous devez l'exécuter jusqu'à la première. Combien de commandes faut-il pour taper 999 lignes ?

Résumé

La chose la plus pénible dans l'écriture d'un programme est le débogage. Le programme s'exécute souvent selon un processus inattendu et les instructions que vous attendez d'être exécutées ne sont pas exécutées. du tout, à ce stade, le débogage est nécessaire.

Recommandations d'apprentissage associées : Tutoriel 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!