The solution to this problem is to configure Python using YAML format logging, load and combine pyyaml to parse configuration files; first define logging_config.yaml file containing fields such as version, formatters, handlers, loggers, etc., in which formatters set two output formats: simple and detailed, handlers configure four processors: console, file, rotating_file and timed_rotating, and loggers are myap p and myapp.special set different log levels and processors, root sets the root log processor, and then use os in Python code to determine whether the configuration file exists. If it exists, use yaml.safe_load to load and call logging.config.dictConfig to take effect. Otherwise, use basicConfig as an alternative, and finally obtain the corresponding logger instance output log through getLogger. This method supports multi-environment isolation and flexible maintenance, suitable for use in production environments, and requires installation of pyyaml dependencies in advance.

Below is a practical example of Python logging configuration file that uses YAML format to define log configuration. This approach is suitable for medium and large projects, making it easy to maintain and environmental isolation.

Note: The Python standard library supports the configuration of loading dictionary formats through dictConfig , and YAML files need to be parsed into dictionaries first.

? 1. logging_config.yaml sample file

 version: 1
disable_existing_loggers: false

formatters:
  simple:
    format: '%(levelname)s %(message)s'
  Detailed:
    format: '%(asctime)s - %(name)s - %(levelname)s - %(filename)s:%(lineno)d - %(funcName)s() - %(message)s'

handlers:
  console:
    class: logging.StreamHandler
    level: INFO
    formatter: simple
    stream: ext://sys.stdout

  file:
    class: logging.FileHandler
    level: DEBUG
    formatter: detailed
    filename: app.log
    mode: a
    encoding: utf-8

  rotating_file:
    class: logging.handlers.RotatingFileHandler
    level: DEBUG
    formatter: detailed
    filename: app_rotating.log
    maxBytes: 10485760 # 10 MB
    backupCount: 5
    encoding: utf-8

  timed_rotating:
    class: logging.handlers.TimedRotatingFileHandler
    level: WARNING
    formatter: detailed
    filename: warnings.log
    when: midninght
    interval: 1
    backupCount: 7
    encoding: utf-8

loggers:
  myapp:
    level: DEBUG
    handlers: [console, rotating_file]
    propagate: false

  myapp.special:
    level: INFO
    handlers: [timed_rotating]
    propagate: true

root:
  level: WARNING
  handlers: [console, file]

? 2. Load the configured Python code

 import logging
import logging.config
import yaml
import os

def setup_logging(config_path='logging_config.yaml', default_level=logging.INFO):
    if os.path.exists(config_path):
        with open(config_path, 'r', encoding='utf-8') as f:
            config = yaml.safe_load(f)
            logging.config.dictConfig(config)
    else:
        logging.basicConfig(level=default_level)

# Use example if __name__ == "__main__":
    setup_logging()

    logger = logging.getLogger('myapp')
    logger.debug("This is a debugging information")
    logger.info("This is a normal message")
    logger.warning("This is a warning")

    special_logger = logging.getLogger('myapp.special')
    special_logger.warning("This will be written to the timed_rotating log file")

? 3. Explain the key points

• version: 1 : A must field, indicating the configuration format version.
• disable_existing_loggers: false : Avoid disabling existing loggers (usually set to false is safer).
• formatters : defines the output format, reusable.
• handlers :
  • StreamHandler output to the console.
  • FileHandler writes to fixed log files.
  • RotatingFileHandler splits logs by size.
  • TimedRotatingFileHandler is divided by time (such as daily).
• loggers : Custom named loggers, such as myapp and myapp.special , which can be managed layered.
• root : root logger, handles other logs that are not specified.

? 4. Installation dependencies (if using YAML)

 pip install pyyaml

? 5. Alternative: Hard coded using JSON or dictionary

You can also write the above configuration into a .json file or define it directly in the code with a dictionary, but YAML is easier to read.

Basically that's it. This configuration structure is clear and suitable for use in production environments. It supports console output, file recording, log rotation and other functions.

The above is the detailed content of python logging configuration file example. For more information, please follow other related articles on the PHP Chinese website!