Shulou(Shulou.com)06/03 Report--

This article shows you the Python log module detailed explanation and how to apply, the content is concise and easy to understand, absolutely can make your eyes bright, through the detailed introduction of this article, I hope you can get something.

Log Overview

Summary of Baidu encyclopedia's log:

Windows network operating systems are designed to have a variety of log files, such as application logs, security logs, system logs, Scheduler service logs, FTP logs, WWW logs, DNS server logs, etc., which vary depending on the service your system opens. When we do some operations on the system, these log files usually record some relevant contents of our operations, which are very useful to the system security staff. For example, if someone carries out IPC detection on the system, the system will quickly record the IP, time, user name and so on used by the explorer in the security log. After using FTP to detect, the system will record the IP, time, user name used in the FTP log, and so on.

The log in my image:

Viewing logs is the best way for developers to obtain information, troubleshoot anomalies and find problems. Log records are usually marked with information such as the cause of the exception, the time of occurrence, the specific number of error lines, and so on. This greatly saves our troubleshooting time and virtually improves the coding efficiency.

Log classification

We can classify by output terminal or by log level. The output terminal refers to the display of the log in the console output and the storage of the log to the file; the log level refers to the classification of severity levels such as Debug, Info, WARNING, ERROR and CRITICAL.

Logging of Python

Logging provides a set of convenient logging functions: debug (), info (), warning (), error (), and critical (). The logging functions are named according to the level or severity of the events they use to track. The standard levels and their applicability are described as follows (sorted by increasing severity):

The numerical value for each level is

CRITICAL:50,ERROR:40,WARNING:30,INFO:20,DEBUG:10,NOTSET:0 .

Logs whose default levels are WARNING,DEBUG and INFO in Python will not be displayed. Change the settings in logging.

Log output to console

Use logging to print the log on the console, here we use the Pycharm editor to observe:

Import logging

Logging.debug ('Cui Qingcai, Jingxiu, Wei Shidong and Quinn')

Logging.warning ('invite you to follow the official account of Wechat [attacking Coder]')

Logging.info ('coding together with bosses, make progress together')

From the results of the above figure, it does show only the WARNING-level information, which verifies the above point of view. At the same time, the log content is also output in the console. By default, the log is printed using the function in the logging module in Python, and the log is only output in the console, not saved to the daily file.

Is there any way to change the default log level?

Of course, basicConfig is provided in logging so that users can adjust the default log level at the right time. We can change the above code to:

Import logging

Logging.basicConfig (level=logging.DEBUG)

Logging.debug ('Cui Qingcai, Jingxiu, Wei Shidong and Quinn')

Logging.warning ('invite you to follow the official account of Wechat [attacking Coder]')

Logging.info ('coding together with bosses, make progress together')

You can set the level of the level parameter in basicConfig.

Consider: if the level is set to logging.INFO, can the DEBUG information be displayed?

Save to Fil

Just demonstrated how to output the contents of the log on the console and set the level of the log freely, so now take a look at how to save the log to a file. Still powerful basicConfig, let's change the above code to:

Import logging

Logging.basicConfig (level=logging.DEBUG, filename='coder.log', filemode='a')

Logging.debug ('Cui Qingcai, Jingxiu, Wei Shidong and Quinn')

Logging.warning ('invite you to follow the official account of Wechat [attacking Coder]')

Logging.info ('coding together with bosses, make progress together')

Enter filename (specify file name) and filemode (file writing method) in the configuration, and the log output of the console will be lost, so will coder.log be generated?

A log named coder.log is generated in the sibling directory of the .py file.

Through simple code setup, we have completed the output of the log file in the console and in the file. What if it can be displayed on the console and saved to a file?

Powerful logging

The module-level logging function provided by logging encapsulates the related classes of logging logging system.

The logging module provides two ways to log:

Use the module-level functions provided by logging

Use the four components of the Logging log system

The level functions mentioned here are DEBGE, ERROR and other levels used above, while the four major components refer to loggers, handlers, filters and formatters. The following figure simply illustrates their respective functions:

The logger is the entrance, and the real work is the processor (handler). The processor (handler) can also filter and format the log content to be output through filter and formatter. Four major components

The following describes the classes related to the four major components of logging: Logger, Handler, Filter, and Formatter.

Logger class

The Logger object has three tasks to do:

1) expose several methods to the application code so that the application can log messages at run time

2) decide which logs are to be processed later based on the log severity level (the default filtering facility) or the filter object

3) send log messages to all interested log handlers.

The most commonly used methods for Logger objects are divided into two categories: configuration methods and message sending methods.

The most common configuration methods are as follows:

Description of the Logger.setLevel () method:

Among the built-in levels, the lowest level is DEBUG and the highest level is CRITICAL. For example, setLevel (logging.INFO), if the function argument is INFO, then the logger will only process logs at INFO, WARNING, ERROR and CRITICAL levels, while messages at DEBUG level will be ignored / discarded.

After the logger object is configured, you can use the following methods to create logging:

So, how do you get a Logger object? One way is to create an instance of the Logger class through the instantiation method of the Logger class, but we usually use the second way-the logging.getLogger () method.

The logging.getLogger () method has an optional parameter, name, that represents the name identity of the logger to be returned, or a value of 'root' if it is not provided. If the getLogger () method is called multiple times with the same name parameter value, a reference to the same logger object will be returned.

Description of the hierarchical structure and effective level of logger:

The name of logger is a'.' The hierarchical structure of segmentation, each'.' The following logger are all'.' The children of the previous logger, for example, has a logger named foo, and the other names are foo.bar, foo.bar.baz and foo.bam are descendants of foo.

Logger has a concept of "effective level". If a level is not explicitly set on a logger, then the logger is the level; that uses its parent. If its parent does not explicitly set level, it continues to look up the valid level of parent's parent, and so on, until an ancestor with level explicitly set is found. It is important to note that root logger always has an explicit level setting (default is WARNING). When deciding whether to handle an event that has occurred, the validity level of the logger will be used to determine whether to pass the event to the handlers of the logger for processing.

When child loggers finishes processing log messages, it passes the log messages to the handlers associated with their ancestor loggers by default. Therefore, instead of defining and configuring handlers for all the loggers used in an application, we just need to configure handlers for a top-level logger, and then create a child loggers as needed. We can also turn off this delivery mechanism by setting the propagate property of a logger to False.

Handler

The purpose of the Handler object is (based on the level of the log message) to distribute the message to the location specified by handler (file, network, mail, and so on). The Logger object can add zero or more handler objects for itself through the addHandler () method. For example, an application might want to implement the following logging requirements:

1) send all logs to a log file

2) send all logs with a severity level greater than or equal to error to stdout (standard output)

3) send all logs with a severity level of critical to an email email address.

This scenario requires three different handlers, each handler complex sending a log of a specific severity level to a specific location.

There are only a few methods in an handler that need application developers to care about. To application developers using built-in handler objects, it seems that the only relevant handler methods are the following configuration methods:

It is important to note that application code should not instantiate and use Handler instances directly. Because Handler is a base class, it only defines the interfaces that all handlers should have, and provides some default behaviors that subclasses can directly use or override. Here are some common Handler:

Formater

The Formater object is used to configure the final order, structure, and content of the log information. Unlike the logging.Handler base class, the application code can instantiate the Formatter class directly. In addition, if your application requires some special processing behavior, you can also implement a subclass of Formatter to do so.

The constructor of the Formatter class is defined as follows:

Logging.Formatter.__init__ (fmt=None, datefmt=None, style='%')

The constructor accepts three optional parameters:

Fmt: specifies the message format string. If this parameter is not specified, the original value of message is used by default.

Datefmt: specifies the date format string, which defaults to "% Y-%m-%d% H:%M:%S" if this parameter is not specified

Style:Python 3.2New parameter. Available values are'%','{'and' $'. If this parameter is not specified,'%'is used by default

Filter

Filter can be used by Handler and Logger to do finer-grained and more complex filtering functions than level. Filter is a filter base class that only allows log events under a certain logger level to be filtered. The class is defined as follows:

Class logging.Filter (name='')

Filter (record)

For example, if the name parameter value passed when a filter is instantiated is' A.Barrier, then the filter instance will only allow the log records generated by the loggers whose name is similar to the following rule to be filtered: 'A.BBQ', 'A.BBJ', 'A.B.D', while the logs generated by the loggers with the name 'A.BB',' B.A.B' will be filtered out. If the value of name is an empty string, all log events are allowed to be filtered.

The filter method is used to specifically control whether the passed record records can be filtered. If the method returns a value of 0, it cannot pass the filter, and a return value of non-0 means it can pass the filter.

Description:

If necessary, you can also change the record within the filter (record) method, such as adding, removing, or modifying properties.

We can also do some statistical work through filter, such as calculating the number of record processed by a particular logger or handler, and so on.

Actual combat exercise

The above has said so much (copy / paste) that it is time to put it into practice.

Now that I need to output the log to the console and save the log to a file, what should I do?

Using what we have just learned, we can conceive:

It doesn't seem difficult, it's quite simple, but is it really so?

In the actual work or application, we may also need to specify the file storage path, use a random number as the log file name, display the specific number of lines of information output code, log information output date and log writing method and so on. Think about it again:

The specific code is as follows: import os

Import logging

Import uuid

From logging import Handler, FileHandler, StreamHandler

Class PathFileHandler (FileHandler):

Def _ _ init__ (self, path, filename, mode='a', encoding=None, delay=False):

Filename = os.fspath (filename)

If not os.path.exists (path):

Os.mkdir (path)

Self.baseFilename = os.path.join (path, filename)

Self.mode = mode

Self.encoding = encoding

Self.delay = delay

If delay:

Handler.__init__ (self)

Self.stream = None

Else:

StreamHandler.__init__ (self, self._open ())

Class Loggers (object):

# Log level relation mapping

Level_relations = {

'debug': logging.DEBUG, 'info': logging.INFO,' warning': logging.WARNING

'error': logging.ERROR, 'critical': logging.CRITICAL

}

Def _ _ init__ (self, filename=' {uid} .log '.format (uid=uuid.uuid4 ()), level='info', log_dir='log'

Fmt='% (asctime) s -% (filename) s [line:% (lineno) d] -% (levelname) s:% (message) s'):

Self.logger = logging.getLogger (filename)

Abspath = os.path.dirname (os.path.abspath (_ _ file__))

Self.directory = os.path.join (abspath, log_dir)

Format_str = logging.Formatter (fmt) # set the log format

Self.logger.setLevel (self.level_relations.get (level)) # sets the log level

Stream_handler = logging.StreamHandler () # output to the screen

Stream_handler.setFormatter (format_str)

File_handler = PathFileHandler (path=self.directory, filename=filename, mode='a')

File_handler.setFormatter (format_str)

Self.logger.addHandler (stream_handler)

Self.logger.addHandler (file_handler)

If _ name__ = = "_ _ main__":

Txt = "follow the official account [attacking Coder], reply to" log code "to get the complete code and flow chart in the article"

Log = Loggers (level='debug')

Log.logger.info (4)

Log.logger.info (5)

Log.logger.info (txt)

Run the file after it is saved, and the running result is shown below:

The log is indeed output in the console. Let's see if the specified files and folders are generated in the directory:

When you open the file, you can see the output:

The above content is the detailed explanation of the Python log module and how to apply it. Have you learned the knowledge or skills? If you want to learn more skills or enrich your knowledge reserve, you are welcome to follow the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.