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

print

print

sys.stdout

logging

logging

sys.stdout

print()

sys.stdout

sys.stderr

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("--- 捕获输出结束 ---")

logging

logging

sys.stdout

logging

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 屏蔽输出方式二：结束 ---")

print

sys

sys.stdout

print

print

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("现在又可以正常打印了。")

sys.stdout

logging

print

sys.stdout

sys.stderr

logging

logging

print

logging

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 # 确保不传播

sys.stdout

setLevel

addHandler

.ini

.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("这是子模块的错误。")

INFO

DEBUG

# 假设我们有一个HTTP接口来动态调整
# from flask import Flask, request
# app = Flask(__name__)

# @app.route('/log_level', methods=['POST'])
# def