Utilisation des instructions d'impression uniquement pour déboguer

Question

J'ai beaucoup codé en Python ces derniers temps. Et j'ai travaillé avec des données avec lesquelles je n'avais jamais travaillé auparavant, en utilisant des formules jamais vues auparavant et en traitant d'énormes fichiers. Tout cela m'a fait écrire beaucoup de déclarations imprimées pour vérifier si tout se passe bien et identifier les points d'échec. Mais, en général, produire autant d’informations n’est pas une bonne pratique. Comment utiliser les instructions print uniquement lorsque je souhaite déboguer et les laisser être ignorées lorsque je ne souhaite pas qu'elles soient imprimées?

Answer 1

L' logging module a tout ce que vous voulez. Il peut paraître excessif au premier abord, mais n'utilisez que les pièces dont vous avez besoin. Je vous recommande d'utiliser logging.basicConfig pour basculer le niveau de consignation stderr et le simple journal des méthodes, debug, info, warning, error et critical.

logging.basicConfig(stream=sys.stderr, level=logging.DEBUG)
logging.debug('A debug message!')
logging.info('We processed %d records', len(processed_records))

Answer 2

Une méthode simple consiste à appeler une fonction de journalisation:

 DEBUG = True

def log(s):
    if DEBUG:
        print s

log("hello world")
 

Ensuite, vous pouvez modifier la valeur de DEBUG et exécuter votre code avec ou sans journalisation.

Le module standard logging a un mécanisme plus élaboré à cet effet.

Answer 3

Utilisez la journalisation intégré dans le module bibliothèque, au lieu de l'impression.

Vous créez un Logger objet (disons logger), puis, après que, à chaque fois que vous insérez un débogage imprimer, il vous suffit de mettre:

logger.debug("Some string")

Vous pouvez utiliser logger.setLevel au début du programme pour régler le niveau de sortie. Si vous le réglez à DÉBOGUER, il permet d'imprimer tous les debugs. Ensemble pour INFO ou supérieur et immédiatement tous les debugs va disparaître.

Vous pouvez également l'utiliser pour enregistrer des choses plus sérieuses, à différents niveaux (INFO, d'AVERTISSEMENT et d'ERREUR).

Answer 4

Tout d'abord, je vais appuyer la candidature de python journalisation cadre. Être un peu prudent sur la façon dont vous l'utilisez, cependant. Plus précisément: que la journalisation développez vos variables, ne le faites pas vous-même. Par exemple, au lieu de:

logging.debug("datastructure: %r" % complex_dict_structure)

assurez-vous de faire:

logging.debug("datastructure: %r", complex_dict_structure)

parce que pendant qu'ils se ressemblent, la première version encourt la repr() le coût , même si elle est désactivée. La deuxième version de l'éviter. De même, si vous lancez votre propre, je proposerais quelque chose comme:

def debug_stdout(sfunc):
    print(sfunc())

debug = debug_stdout

appelé par le biais de:

debug(lambda: "datastructure: %r" % complex_dict_structure)

qui, encore une fois, éviter la surcharge si vous désactivez-le en faisant:

def debug_noop(*args, **kwargs):
    pass

debug = debug_noop

La surcharge de calcul de ces chaînes n'a probablement pas d'importance, sauf s'ils sont soit 1) onéreux ou 2) l'instruction de débogage est dans le milieu de, disons, un n^3 boucle ou quelque chose. Pas que je sache à ce sujet.

Answer 5

Je ne connais pas les autres, mais j'avais l'habitude de définir une "constante globale" ( DEBUG ) puis une fonction globale ( debug(msg) ) qui imprimait msg seulement si DEBUG == True .

Ensuite, j'écris mes instructions de débogage comme suit:

 debug('My value: %d' % value)
 

... alors je me lance dans les tests unitaires et je ne le fais plus jamais! :)