Usar declaraciones de impresión solo para depurar

He estado codificando mucho en Python últimamente. Y he estado trabajando con datos con los que no había trabajado antes, usando fórmulas nunca antes vistas y tratando con archivos enormes. Todo esto me hizo escribir muchas declaraciones impresas para verificar si todo va bien e identificar los puntos de falla. Pero, en general, generar tanta información no es una buena práctica. ¿Cómo utilizo las declaraciones de impresión solo cuando quiero depurar y permitir que se omitan cuando no quiero que se impriman?

El loggingmódulo tiene todo lo que pueda desear. Puede parecer excesivo al principio, pero solo use las piezas que necesita. Me gustaría recomendar el uso logging.basicConfigpara cambiar el nivel de registro stderry los métodos de registro sencilla , debug, info, warning, errory critical.

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

Una forma sencilla de hacer esto es llamar a una función de registro:

DEBUG = True

def log(s):
    if DEBUG:
        print s

log("hello world")

Luego, puede cambiar el valor de DEBUGy ejecutar su código con o sin registro.

El loggingmódulo estándar tiene un mecanismo más elaborado para esto.

Utilice el módulo de biblioteca integrado de registro en lugar de imprimir.

Creas un Loggerobjeto (por ejemplo logger), y luego, cada vez que insertas una impresión de depuración, simplemente pones:

logger.debug("Some string")

Puede utilizar logger.setLevelal inicio del programa para establecer el nivel de salida. Si lo configura en DEBUG, imprimirá todas las depuraciones. Configúrelo en INFO o superior e inmediatamente todas las depuraciones desaparecerán.

También puedes usarlo para registrar cosas más serias, en diferentes niveles (INFO, ADVERTENCIA y ERROR).

En primer lugar, respaldaré la nominación del marco de registro de Python . Sin embargo, tenga un poco de cuidado con la forma en que lo usa. Específicamente: deje que el marco de registro amplíe sus variables, no lo haga usted mismo. Por ejemplo, en lugar de:

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

asegúrese de hacer:

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

porque aunque se ven similares, la primera versión incurre en el costo repr () incluso si está deshabilitada . La segunda versión evita esto. Del mismo modo, si lanza el suyo, sugeriría algo como:

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

debug = debug_stdout

llamado a través de:

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

que, de nuevo, evitará la sobrecarga si la desactiva haciendo:

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

debug = debug_noop

La sobrecarga de calcular esas cadenas probablemente no importe a menos que sean 1) costosas de calcular o 2) la declaración de depuración esté en medio de, digamos, un ciclo n ^ 3 o algo así. No es que yo sepa nada de eso.

No sé sobre otros, pero estaba acostumbrado a definir una "constante global" ( DEBUG) y luego una función global ( debug(msg)) que se imprimiría msgsolo si DEBUG == True.

Luego escribo mis declaraciones de depuración como:

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

... luego retomé las pruebas unitarias y ¡nunca volví a hacer esto! :)