Python + salida de registro a la pantalla, escriba el registro de registro en el archivo (prueba profesional)

Registro

Los registros son un método de seguimiento de eventos que ocurren mientras se ejecuta el software. El desarrollador de software llama a la función de registro en el código para indicar que se ha producido un evento específico. El evento se describe mediante un mensaje descriptivo que puede contener opcionalmente datos variables (es decir, datos potencialmente diferentes para cada ocurrencia del evento). Los incidentes también tienen la importancia que los desarrolladores atribuyen a los incidentes; la importancia también puede denominarse nivel o gravedad.

El registro proporciona un conjunto de funciones convenientes para el registro simple. Son depuración (), información (), advertencia (), error () y crítica ().

 

Las funciones de registro se nombran de acuerdo con el nivel o la gravedad de los eventos que se utilizan para rastrear. Los niveles estándar y su aplicabilidad se describen a continuación (en orden de gravedad creciente):

Nivel	Cuando usar
DEBUG	La información detallada generalmente solo se usa cuando se depuran problemas.
INFO	Probar que las cosas funcionan como se esperaba.
WARNING	Solicitar algunos eventos inesperados o problemas que pueden aparecer en el futuro. Por ejemplo: espacio en disco insuficiente. Pero el software seguirá funcionando como de costumbre.
ERROR	Debido a problemas más serios, el software ya no puede realizar algunas funciones.
CRITICAL	Un error grave indica que el software ya no puede ejecutarse.

 

Nivel	Valor numérico
CRITICAL	50
ERROR	40
WARNING	30
INFO	20
DEBUG	10
NOTSET	0 0

 

El nivel predeterminado es WARNING, lo que significa que solo este nivel y los superiores enviarán información a menos que el módulo de registro se use para hacer otras cosas.

Los eventos rastreados se pueden manejar de diferentes maneras. La forma más fácil de lidiar con esto es imprimirlos en la consola. Otro método común es escribir en un archivo de disco.

 

1. Imprimir en la consola

importar registro 
logging.debug ('información de depuración') 
logging.warning ('Solo esto generará ...') 
logging.info ('información de información')

Dado que el nivel predeterminado es advertencia, toda la información solo de advertencia se enviará a la consola.

ADVERTENCIA: root: solo esto saldrá. . .

 

Use logging.basicConfig () para imprimir información en la consola

registro de importación 
logging.basicConfig (format = '% (asctime) s -% (ruta) s [línea:% (lineno) d] -% (levelname) s:% (mensaje) s', 
                    nivel = logging.DEBUG) 
registro .debug ('debug 信息') 
logging.info ('info 信息') 
logging.warning ('warning 信息') 
logging.error ('error 信息') 
logging.critical ('critial 信息')

Dado que el valor de nivel en logging.basicConfig () se establece en logging.DEBUG, todos los registros de depuración, información, advertencia, error y críticos se imprimirán en la consola.

Nivel de registro: depuración <información <advertencia <error < 
logging.debug crítico ('nivel de depuración, el nivel más bajo, los desarrolladores generales usan para imprimir alguna información de depuración') 
logging.info ('nivel de información, información de salida normal, generalmente utilizada para imprimir Algunas operaciones normales ') 
logging.warning (' nivel de advertencia, generalmente utilizado para imprimir mensajes de advertencia ') 
logging.error (' nivel de error, generalmente utilizado para imprimir algunos mensajes de error ') 
logging.critical (' nivel crítico, generalmente utilizado para Imprima algunos mensajes de error fatales, el nivel más alto ')

Entonces, si configura level = logging.info (), la información de depuración no se enviará a la consola.

 

En segundo lugar, use logging.basicConfig () para guardar el registro en un archivo

logging.basicConfig (nivel = logging.DEBUG, # Nivel de registro impreso por la consola 
                    filename = 'new.log', 
                    filemode = 'a', ## modo, hay w y a, w es el modo de escritura, se reescribirá cada vez Registro, sobrescribir el registro anterior 
                    #a es el modo de agregar, si no lo escribe de manera predeterminada, el modo de agregar es 
                    format = 
                    '% (asctime) s-% (pathname) s [line:% (lineno) d] -% (levelname) s :% (mensaje) s ' 
                    # formato de registro 
                    )

Si configura el nombre de archivo y el modo de archivo en logging.basicConfig (), solo el registro se guardará en el archivo y no se enviará a la consola.

 

En tercer lugar, la entrada de pantalla anterior, pero también escribe el registro en el archivo

 

La biblioteca de registro tiene un diseño modular y proporciona muchos componentes: registradores, procesadores, filtros y formateadores.

• Logger expone una interfaz que el código de la aplicación puede usar directamente.
• El controlador envía los registros de registro (generados por el registrador) al destino apropiado.
• El filtro proporciona un mejor control de granularidad, puede decidir qué registros de registro generar.
• El formateador indica el diseño de los registros en la salida final.

Madereros:

Los objetos registradores hacen tres cosas. Primero, exponen muchos métodos al código de la aplicación para que la aplicación pueda registrar mensajes en tiempo de ejecución. En segundo lugar, el objeto de registro determina qué mensajes de registro deben registrarse por gravedad (la función de filtrado predeterminada) u objeto de filtro. En tercer lugar, el objeto registrador pasa los mensajes de registro relacionados a todos los procesadores de registro interesados.

Los métodos comunes de los objetos registradores se dividen en dos categorías: configuración y envío de mensajes.

Estos son los métodos de configuración más utilizados:

Logger.setLevel () especifica la información de registro del nivel de seguridad más bajo que procesará el registrador, la depuración es el nivel de seguridad incorporado más bajo y crítico es el nivel de seguridad incorporado más alto. Por ejemplo, si la gravedad es INFO, la grabadora solo procesará los mensajes INFO, WARNING, ERROR y CRITICAL, y se ignorarán los mensajes DEBUG.
Logger.addHandler () y Logger.removeHandler () agregan y eliminan objetos del controlador del objeto logger. Ver Handlers para más detalles.
Logger.addFilter () y Logger.removeFilter () agregan y eliminan objetos de filtro del objeto logger.

Manipuladores

处理程序El objeto es responsable de enviar el mensaje de registro apropiado (en función de la gravedad del mensaje de registro) al destino designado del controlador. Logger Los objetos pueden addHandler()agregar cero o más objetos de controlador a través de métodos. Por ejemplo, una aplicación puede enviar todos los mensajes de registro a un archivo de registro, todos los mensajes de registro de nivel de error y superiores a la salida estándar, y todos los mensajes de registro de nivel crítico (crítico) a una dirección de correo electrónico. En este ejemplo, se requieren tres procesadores independientes, cada uno de los cuales es responsable de enviar mensajes de un nivel específico a una ubicación específica.

Hay 4 de uso común: 

1) logging.StreamHandler-> salida de consola 

Utilice este controlador para enviar información a cualquier objeto de archivo similar a sys.stdout o sys.stderr.

Su constructor es:
StreamHandler ([strm])
donde el parámetro strm es un objeto de archivo. El valor predeterminado es sys.stderr

2)    logging.FileHandler-> salida de archivo

Similar a StreamHandler, se usa para enviar información de registro a un archivo. Pero FileHandler lo ayudará a abrir este archivo. Su constructor es:
FileHandler (nombre de archivo [, modo])
nombre de archivo es el nombre del archivo, debe especificar un nombre de archivo.
modo es la forma en que se abre el archivo. El valor predeterminado es 'a', que se agrega al final del archivo.

3)    logging.handlers.RotatingFileHandler-  > divide automáticamente el archivo de registro de acuerdo con el tamaño y regenera el archivo una vez que alcanza el tamaño especificado 

Este controlador es similar al FileHandler anterior, pero puede administrar el tamaño del archivo. Cuando el archivo alcanza un cierto tamaño, cambiará automáticamente el nombre del archivo de registro actual y luego creará un nuevo archivo de registro con el mismo nombre para continuar con la salida. Por ejemplo, el archivo de registro es chat.log. Cuando chat.log alcanza el tamaño especificado, RotatingFileHandler cambia automáticamente el nombre del archivo a chat.log.1. Sin embargo, si chat.log.1 ya existe, primero cambiará el nombre de chat.log.1 a chat.log.2. . . Finalmente, vuelva a crear chat.log y continúe generando información de registro. Su constructor es:
RotatingFileHandler (nombre de archivo [, modo [, maxBytes [, backupCount]]])
donde nombre de archivo y modo son los mismos que FileHandler.
maxBytes se usa para especificar el tamaño máximo de archivo del archivo de registro. Si maxBytes es 0, lo que significa que el archivo de registro puede ser infinitamente grande, el proceso de cambio de nombre descrito anteriormente no ocurrirá.
backupCount se usa para especificar el número de archivos de copia de seguridad reservados. Por ejemplo, si se especifica como 2, cuando se produce el proceso de cambio de nombre descrito anteriormente, el chat.log.2 original no se cambiará de nombre, sino que se eliminará.

4)    logging.handlers.TimedRotatingFileHandler->  divide automáticamente los archivos de registro según el tiempo 

Este controlador es similar a RotatingFileHandler, pero no determina cuándo volver a crear el archivo de registro al juzgar el tamaño del archivo, sino que crea automáticamente un nuevo archivo de registro en un intervalo determinado. El proceso de cambio de nombre es similar a RotatingFileHandler, pero el nuevo archivo no se agrega con números, sino con la hora actual. Su constructor es:
TimedRotatingFileHandler (nombre de archivo [, cuando [, intervalo [, backupCount]]])
donde el parámetro de nombre de archivo y el parámetro backupCount tienen el mismo significado que RotatingFileHandler.
intervalo es el intervalo de tiempo.
cuando el parámetro es una cadena. La unidad para el intervalo de tiempo no distingue entre mayúsculas y minúsculas. Tiene los siguientes valores:
S segundos
M minutos
H horas
D días
W cada semana (intervalo == 0 representa el lunes)
medianoche todas las mañanas
 

Método de configuración:

• setLevel()El método es el mismo que para el objeto de registro, que indica el nivel más bajo en el que se distribuirán los registros. ¿Por qué hay dos setLevel()métodos? El nivel del registrador determina si el mensaje se entregará al procesador. El nivel de cada procesador determina si el mensaje se distribuirá.
• setFormatter()Elija un formateador para el procesador.
• addFilter()Y removeFilter()configure y desconfigure los objetos de filtro en el controlador por separado.

Formateadores

El objeto Formateador establece las reglas finales, la estructura y el contenido de la información de registro. El formato de hora predeterminado es% Y-% m-% d% H:% M:% S. La siguiente es información de formateador comúnmente utilizada.

% (nombre) s	Nombre del registrador
% (levelno) s	Nivel de registro en números
% (nombre de nivel) s	Nivel de registro en texto
% (nombre de ruta) s	El nombre de ruta completo del módulo que llama a la función de salida de registro puede no ser
% (nombre de archivo) s	Nombre de archivo del módulo que llama a la función de salida de registro
% (módulo) s	El nombre del módulo que llama a la función de salida de registro
% (funcName) s	Nombre de función que llama a la función de salida de registro
% (lineno) d	La línea de código donde se encuentra la instrucción que llama a la función de salida del registro
% (creado) f	La hora actual, expresada como un número de coma flotante que representa la hora en el estándar UNIX
% (relativo creado) d	El número de milisegundos desde la creación del registrador al generar información de registro
% (asctime) s	La hora actual como una cadena. El formato predeterminado es "2003-07-08 16: 49: 45,896". Milisegundos después de la coma
% (hilo) d	ID de hilo. Probablemente no
% (threadName) s	El nombre del hilo. Probablemente no
% (proceso) d	ID de proceso. Probablemente no
% (mensaje) s	Mensaje de salida del usuario

 

Requisitos:

Salida de registro a la consola y escritura de registro en el archivo de registro.
Guarde 2 tipos de registros, all.log guarda depuración, información, advertencia, información crítica, error.log solo guarda información de errores y divide automáticamente el archivo de registro según el tiempo.

registro de importación 
desde registro 

clase de controladores de importación Registrador (objeto): 
    level_relations = { 
        'debug': logging.DEBUG, 
        'info': logging.INFO, 
        'warning': logging.WARNING, 
        'error': logging.ERROR, 
        'crit' : logging.CRITICAL 
    } 

    # Mapeo de relación de nivel de registro def __init __ (self, filename, level = 'info', when = 'D', backCount = 3, fmt = '% (asctime) s-% (pathname) s (line: % (lineno) d] -% (levelname) s:% (message) s '): 
        self.logger = logging.getLogger (filename) 
        format_str = logging.Formatter (fmt) 
        # Establezca el formato de registro self.logger.setLevel (self .level_relations.get (level)) # Establecer el nivel de registro 
        sh = logging.StreamHandler () # Salida a la pantalla 
        sh.setFormatter (format_str) # Establecer el formato que se muestra en la pantalla 
        th = handlers.TimedRotatingFileHandler (filename = filename, when = when, backupCount = backCount, encoding = 'utf-8') # Escriba en el archivo # Especifique el tiempo de intervalo automáticamente El procesador que generó el archivo 
        #instantiated TimedRotatingFileHandler 
        #interval es el intervalo de tiempo, backupCount es el número de archivos de copia de seguridad, si excede este número, se eliminará automáticamente, cuando es la unidad de tiempo de intervalo, la unidad tiene los siguientes tipos: 
        # S segundos 
        # M 分
        # H horas, 
        # D días, 
        # W cada semana (intervalo == 0 representa el lunes) 
        # medianoche todos los días 
        th.setFormatter (format_str) 
        # Establezca el formato escrito en el archivo self.logger.addHandler (sh ) 
        # Agregue el objeto al registrador self.logger.addHandler (th) 
si __name__ == '__main__': 
    log = Logger ('all.log', level = 'debug')
    log.logger.debug ('debug')  
    log.logger.info ('info') 
    log.logger.warning ('Advertencia')
    log.logger.error ('报错') 
    log.logger.critical ('严重') 
    Logger ('error.log', nivel = 'error'). logger.error (' error')

Los resultados en la pantalla son los siguientes:

2018-03-13 21: 06: 46,092 - D: /write_to_log.py [línea: 25] - 
DEPURACIÓN : depuración 2018-03-13 21: 06: 46,092 - D: /write_to_log.py [línea: 26] - INFORMACIÓN : información 
2018-03-13 21: 06: 46,092 - D: /write_to_log.py [línea: 27] - ADVERTENCIA: 警告
2018-03-13 21: 06: 46,099 - D: /write_to_log.py [línea: 28] - ERROR: 报错
2018-03-13 21: 06: 46,099 - D: /write_to_log.py [línea: 29] - CRÍTICO: 严重
2018-03-13 21: 06: 46,100 - D: /write_to_log.py [línea: 30] - ERROR: error

Como when = D, el nombre del archivo recién generado tendrá tiempo como se muestra a continuación.