Python屏蔽输出信息怎样关闭函数执行时的日志输出 Python屏蔽输出信息的日志管控方法​

print()

os.devnull

import os import sys from io import StringIO  class SuppressOutput:     def __enter__(self):         self._original_stdout = sys.stdout         self._original_stderr = sys.stderr         sys.stdout = open(os.devnull, 'w')         sys.stderr = open(os.devnull, 'w')      def __exit__(self, exc_type, exc_val, exc_tb):         sys.stdout.close()         sys.stderr.close()         sys.stdout = self._original_stdout         sys.stderr = self._original_stderr  # 示例函数 def noisy_function():     print("这条信息会被打印出来吗？")     sys.stderr.write("错误信息也来了！n")  print("--- 正常输出开始 ---") noisy_function() print("--- 正常输出结束 ---")  print("n--- 屏蔽输出开始 ---") with SuppressOutput():     noisy_function() print("--- 屏蔽输出结束 ---")  # 如果想捕获输出而不是完全丢弃，可以重定向到StringIO class CaptureOutput:     def __enter__(self):         self._original_stdout = sys.stdout         self.captured_output = StringIO()         sys.stdout = self.captured_output         return self      def __exit__(self, exc_type, exc_val, exc_tb):         sys.stdout = self._original_stdout  def another_noisy_function():     print("这条信息会被捕获。")  print("n--- 捕获输出开始 ---") with CaptureOutput() as co:     another_noisy_function()     print("这行也会被捕获。") print(f"捕获到的内容:n{co.captured_output.getvalue()}") print("--- 捕获输出结束 ---")

NullHandler

import logging  # 示例函数，使用logging def logging_function():     logger = logging.getLogger(__name__) # 获取当前模块的logger     logger.debug("这是一个调试信息")     logger.info("这是一个普通信息")     logger.warning("这是一个警告")     logger.error("这是一个错误")     logger.critical("这是一个严重错误")  # 默认配置，通常会输出到控制台 logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s') print("n--- logging 正常输出开始 (INFO及以上) ---") logging_function() print("--- logging 正常输出结束 ---")  # 方式一：设置日志级别到更高，比如CRITICAL，或直接到NOTSET（但通常配合处理器） print("n--- logging 屏蔽输出方式一：提高级别 ---") logger = logging.getLogger(__name__) original_level = logger.level logger.setLevel(logging.CRITICAL + 1) # 设置一个高于所有级别的级别，实际上就是关闭 logging_function() logger.setLevel(original_level) # 恢复级别 print("--- logging 屏蔽输出方式一：结束 ---")  # 方式二：移除所有处理器或添加NullHandler print("n--- logging 屏蔽输出方式二：移除处理器或使用NullHandler ---") # 清空所有现有处理器（如果不是根logger，可能需要遍历父logger） for handler in logger.handlers[:]: # 遍历副本以安全修改     logger.removeHandler(handler)  # 或者，更优雅地，添加一个NullHandler来阻止日志传播 # logging.NullHandler() 会接收日志但不做任何处理，也不会传播给父logger logger.addHandler(logging.NullHandler()) logger.propagate = False # 确保不传播给父logger  logging_function()  # 恢复，移除NullHandler并恢复传播 for handler in logger.handlers[:]:     if isinstance(handler, logging.NullHandler):         logger.removeHandler(handler) logger.propagate = True # 重新配置或添加回原来的处理器 # logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s') # 如果是根logger，可以重新basicConfig # 对于非根logger，需要手动添加处理器 # logger.addHandler(logging.StreamHandler(sys.stdout)) # 示例：重新添加一个流处理器 print("--- logging 屏蔽输出方式二：结束 ---")

sys

import sys import os  class SuppressPrints:     """     一个上下文管理器，用于临时抑制函数内部的print输出。     它将sys.stdout重定向到/dev/null。     """     def __enter__(self):         # 保存原始的stdout         self._original_stdout = sys.stdout         # 打开/dev/null文件并将其设置为新的stdout         # 注意：在Windows上，os.devnull通常是'NUL'         self._devnull = open(os.devnull, 'w')         sys.stdout = self._devnull         return self      def __exit__(self, exc_type, exc_val, exc_tb):         # 恢复原始的stdout         sys.stdout = self._original_stdout         # 关闭/dev/null文件         self._devnull.close()  # 假设这是你不想看到其print输出的函数 def some_legacy_function():     print("我是一个旧函数，我喜欢打印东西。")     print("比如这个计算结果：", 123 * 456)     # 甚至可能有一些第三方库的内部打印     # import requests     # requests.get("http://example.com") # 某些库在调试模式下可能会打印  print("--- 调用 'some_legacy_function' (有输出) ---") some_legacy_function() print("--- 调用结束 ---")  print("n--- 调用 'some_legacy_function' (屏蔽输出) ---") with SuppressPrints():     some_legacy_function()     print("这行代码在上下文管理器内部，它也会被屏蔽。") # 证明内部的print也会被屏蔽 print("--- 调用结束 ---") print("现在又可以正常打印了。")

import logging import sys  # 1. 获取一个日志器实例 # 通常推荐使用 __name__ 作为日志器的名称，这样可以根据模块来控制日志 app_logger = logging.getLogger('my_app.module_a') # 默认情况下，日志器没有处理器，日志会传播到父日志器，最终到根日志器 # 根日志器默认级别是WARNING，并且有一个StreamHandler输出到sys.stderr  # 2. 设置日志器的级别 # 这决定了哪些级别的消息会被该日志器处理。 # 比如，设置为INFO，那么DEBUG级别的消息就不会被处理。 app_logger.setLevel(logging.DEBUG) # 让这个logger能够处理DEBUG及以上的所有消息  # 3. 添加处理器：决定日志去哪里 # 通常，你需要为你的日志器添加处理器，否则日志会一直向上级传播。 # 如果不添加，日志会传播到根logger，而根logger可能已经有默认的处理器。  # 示例1：控制台输出处理器 console_handler = logging.StreamHandler(sys.stdout) # 输出到标准输出 console_handler.setLevel(logging.INFO) # 这个处理器只处理INFO及以上的消息 formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') console_handler.setFormatter(formatter) app_logger.addHandler(console_handler)  # 示例2：文件输出处理器 file_handler = logging.FileHandler('app_debug.log') file_handler.setLevel(logging.DEBUG) # 文件处理器可以处理更详细的DEBUG信息 file_handler.setFormatter(formatter) app_logger.addHandler(file_handler)  # 4. 控制日志的传播行为 # 默认情况下，日志器会将日志消息传播给它的父日志器。 # 如果你不想让日志传播到父日志器（包括根日志器），可以设置 propagate = False # app_logger.propagate = False  # 示例日志记录 app_logger.debug("这是一个调试信息，应该只出现在文件日志中。") app_logger.info("这是一个信息，应该出现在控制台和文件日志中。") app_logger.warning("这是一个警告，控制台和文件都会有。")  # 5. 临时或永久关闭某个日志器或其部分输出 # 方式A: 提高日志器级别 def silent_function_with_logging():     original_level = app_logger.level     app_logger.setLevel(logging.CRITICAL + 1) # 设置一个不可能达到的级别，有效关闭     app_logger.info("这条信息不会被看到。")     app_logger.setLevel(original_level) # 恢复级别  print("n--- 临时静音日志器 ---") silent_function_with_logging() app_logger.info("现在又可以正常记录了。")  # 方式B: 移除处理器或使用NullHandler # 移除所有处理器：这会阻止日志器将消息发送到任何地方 # 但如果 propagate=True，消息仍然会传播给父日志器 print("n--- 移除处理器，完全静音 ---") for handler in app_logger.handlers[:]: # 遍历副本以安全修改     app_logger.removeHandler(handler)  # 此时，如果 propagate=True，日志会传播到根logger # 如果根logger有处理器（如basicConfig设置的），你仍然会看到输出 # app_logger.propagate = False # 彻底阻止传播  app_logger.info("这条信息不会被这个logger处理，也不会传播（如果propagate=False）。")  # 恢复处理器 (通常在实际项目中不会频繁移除和添加，而是通过配置管理) app_logger.addHandler(console_handler) app_logger.addHandler(file_handler) app_logger.info("处理器已恢复。")  # 方式C: 使用 NullHandler # NullHandler 接收日志但不做任何处理，也不会传播。 # 当你希望一个库的日志器不输出任何东西，但又不想影响到根日志器时，这很有用。 # 比如，第三方库 `some_lib` 内部使用了 `logging.getLogger('some_lib')` # 你可以在你的主程序中这样做： # logging.getLogger('some_lib').addHandler(logging.NullHandler()) # logging.getLogger('some_lib').propagate = False # 确保不传播

setLevel

addHandler

.json

.yaml

logging.config

logging_config.yaml

version: 1 disable_existing_loggers: False # 不禁用已存在的logger  formatters:   simple:     format: '%(asctime)s - %(name)s - %(levelname)s - %(message)s'   detailed:     format: '%(asctime)s - %(levelname)s - %(module)s:%(lineno)d - %(message)s'  handlers:   console:     class: logging.StreamHandler     level: INFO     formatter: simple     stream: ext://sys.stdout # 输出到标准输出    file:     class: logging.handlers.RotatingFileHandler     level: DEBUG     formatter: detailed     filename: app.log     maxBytes: 10485760 # 10MB     backupCount: 5  loggers:   my_app: # 定义一个名为 'my_app' 的logger     level: DEBUG     handlers: [console, file] # 同时输出到控制台和文件     propagate: False # 不传播到根logger    my_app.sub_module: # 更具体的子模块logger     level: WARNING     handlers: [console] # 只输出到控制台，且只输出WARNING及以上     propagate: False  root: # 根logger的配置   level: WARNING   handlers: [console] # 根logger也输出到控制台，但只输出WARNING及以上

main.py

import logging.config import yaml import os  def setup_logging(config_path):     """从YAML文件加载日志配置"""     with open(config_path, 'r') as f:         config = yaml.safe_load(f)     logging.config.dictConfig(config)  # 假设在生产环境，我们可能希望只看到INFO及以上 # 在开发环境，我们可能需要DEBUG级别的详细信息  # 通过环境变量来选择不同的配置，或直接在代码中判断环境 env = os.getenv('APP_ENV', 'development') # 默认开发环境  if env == 'production':     # 假设有一个针对生产环境的logging_config_prod.yaml     # 或者直接在代码中修改部分配置     print("加载生产环境日志配置...")     setup_logging('logging_config_prod.yaml') # 假设存在这个文件     # 生产环境可能只允许 INFO 级别输出到控制台     logging.getLogger('my_app').setLevel(logging.INFO)     logging.getLogger('my_app.sub_module').setLevel(logging.ERROR) else:     print("加载开发环境日志配置...")     setup_logging('logging_config.yaml') # 使用上面的示例配置  # 获取日志器 app_logger = logging.getLogger('my_app') sub_logger = logging.getLogger('my_app.sub_module') root_logger = logging.getLogger() # 获取根logger  app_logger.debug("这是主应用的调试信息。") app_logger.info("这是主应用的信息。") app_logger.warning("这是主应用的警告。")  sub_logger.debug("这是子模块的调试信息。") # 如果sub_module级别是WARNING，则不会显示 sub_logger.info("这是子模块的信息。") # 如果sub_module级别是WARNING，则不会显示 sub_logger.error("这是子模块的错误。")

 # 假设我们有一个HTTP接口来动态调整 # from flask import Flask, request # app = Flask(__name__)  # @app.route('/log_level', methods=['POST']) # def