首都高赛车免安装正式中文版
6.7G · 2025-10-10
在 Python 编程中，print 函数是开发者最常用的工具之一。然而，多数人对其认知仅停留在基础的文本输出层面。随着 Python 3.13.6 的发布，print 函数在兼容性和功能支持上得到进一步优化，使得高级用法更加稳定可靠。本文将深入探讨 print 函数的进阶应用，包括终端彩色输出的实现原理、复杂数据结构的格式化打印技巧，以及如何利用 print 进行高效代码调试，帮助开发者充分发挥这个基础函数的强大潜力。
终端彩色输出能够显著提升信息的可读性，尤其在日志打印、错误提示和用户交互场景中具有重要价值。Python 的 print 函数之所以能实现彩色输出，核心在于对 ANSI 转义序列 的支持。
ANSI 转义序列是一套用于控制终端光标位置、颜色、字体样式的标准编码。这些序列以特殊字符 33（ESC 字符的 ASCII 码）开头，以字母或符号结尾，终端解析后会执行相应的格式控制操作。
基本语法结构：
33[参数;参数;...m
33[：转义序列起始标识m：转义序列结束标识最常用的控制参数分类：
完整的基础颜色参数对应表：
| 文本颜色 | 高亮度文本 | 背景颜色 | 高亮度背景 | 颜色描述 |
|---|---|---|---|---|
| 30 | 90 | 40 | 100 | 黑色 |
| 31 | 91 | 41 | 101 | 红色 |
| 32 | 92 | 42 | 102 | 绿色 |
| 33 | 93 | 43 | 103 | 黄色 |
| 34 | 94 | 44 | 104 | 蓝色 |
| 35 | 95 | 45 | 105 | 洋红色 |
| 36 | 96 | 46 | 106 | 青色 |
| 37 | 97 | 47 | 107 | 白色 |
Python 的 print 函数可以直接输出包含 ANSI 转义序列的字符串，从而实现彩色效果。以下是基础用法示例：
# 案例1：基础文本颜色设置
print("默认文本")
print(" 33[31m红色文本 33[0m") # 红色文本
print(" 33[32m绿色文本 33[0m") # 绿色文本
print(" 33[33m黄色文本 33[0m") # 黄色文本
print(" 33[34m蓝色文本 33[0m") # 蓝色文本
print(" 33[35m洋红色文本 33[0m")# 洋红色文本
print(" 33[36m青色文本 33[0m") # 青色文本
print(" 33[37m白色文本 33[0m") # 白色文本
# 案例2：高亮度文本颜色
print("n高亮度颜色示例：")
print(" 33[91m高亮度红色 33[0m")
print(" 33[92m高亮度绿色 33[0m")
print(" 33[93m高亮度黄色 33[0m")
print(" 33[94m高亮度蓝色 33[0m")
# 案例3：背景颜色设置
print("n背景颜色示例：")
print(" 33[41m红色背景 33[0m")
print(" 33[42m绿色背景 33[0m")
print(" 33[44m蓝色背景 33[0m")
print(" 33[103m高亮度黄色背景 33[0m")
# 案例4：文本样式与颜色组合
print("n样式组合示例：")
print(" 33[1;31m加粗红色文本 33[0m") # 1=加粗
print(" 33[4;32m下划线绿色文本 33[0m") #4=下划线
print(" 33[1;4;33m加粗下划线黄色文本 33[0m") # 组合样式
print(" 33[7;34m反显蓝色文本（前景背景互换） 33[0m") #7=反显
# 案例5：在同一行输出多种颜色
print("n混合颜色示例：")
print("这是 33[31m红色 33[0m，这是 33[32m绿色 33[0m，这是 33[34m蓝色 33[0m")
上述代码运行后，终端会显示不同颜色和样式的文本。需要注意的是，并非所有终端都默认支持 ANSI 转义序列（如 Windows 系统的默认命令提示符）。在不支持的终端中，会直接显示转义序列的原始字符。
Windows 系统兼容性处理：
对于 Windows 终端，可以通过 colorama 库解决兼容性问题，该库会自动将 ANSI 转义序列转换为 Windows 可识别的格式：
# 安装：pip install colorama
from colorama import init
init(autoreset=True) # 自动重置样式，无需手动添加 33[0m
print(" 33[31m这行文字在Windows终端也会显示为红色 33[0m")
直接使用 ANSI 转义序列虽然灵活，但代码可读性差且容易出错。我们可以封装一个工具类，将常用的颜色和样式定义为常量，通过简洁的方法实现彩色输出。
class ColorPrinter:
"""彩色输出工具类，封装常用的ANSI转义序列"""
# 重置所有样式
RESET = " 33[0m"
# 文本颜色（基础）
BLACK = " 33[30m"
RED = " 33[31m"
GREEN = " 33[32m"
YELLOW = " 33[33m"
BLUE = " 33[34m"
MAGENTA = " 33[35m"
CYAN = " 33[36m"
WHITE = " 33[37m"
# 文本颜色（高亮度）
LIGHT_BLACK = " 33[90m"
LIGHT_RED = " 33[91m"
LIGHT_GREEN = " 33[92m"
LIGHT_YELLOW = " 33[93m"
LIGHT_BLUE = " 33[94m"
LIGHT_MAGENTA = " 33[95m"
LIGHT_CYAN = " 33[96m"
LIGHT_WHITE = " 33[97m"
# 背景颜色
BG_BLACK = " 33[40m"
BG_RED = " 33[41m"
BG_GREEN = " 33[42m"
BG_YELLOW = " 33[43m"
BG_BLUE = " 33[44m"
BG_MAGENTA = " 33[45m"
BG_CYAN = " 33[46m"
BG_WHITE = " 33[47m"
# 高亮度背景
BG_LIGHT_BLACK = " 33[100m"
BG_LIGHT_RED = " 33[101m"
BG_LIGHT_GREEN = " 33[102m"
BG_LIGHT_YELLOW = " 33[103m"
BG_LIGHT_BLUE = " 33[104m"
BG_LIGHT_MAGENTA = " 33[105m"
BG_LIGHT_CYAN = " 33[106m"
BG_LIGHT_WHITE = " 33[107m"
# 文本样式
BOLD = " 33[1m"
UNDERLINE = " 33[4m"
BLINK = " 33[5m" # 部分终端不支持
REVERSE = " 33[7m" # 反显
@classmethod
def print_color(cls, text, color=None, bg_color=None, style=None):
"""
打印带颜色和样式的文本
参数:
text: 要打印的文本内容
color: 文本颜色（使用类中的颜色常量）
bg_color: 背景颜色（使用类中的背景颜色常量）
style: 文本样式（使用类中的样式常量，多个样式用分号分隔）
"""
# 构建样式前缀
prefix = []
if style:
prefix.append(style)
if color:
prefix.append(color)
if bg_color:
prefix.append(bg_color)
# 组合前缀和重置标识
if prefix:
formatted_text = f"{''.join(prefix)}{text}{cls.RESET}"
else:
formatted_text = text
# 打印格式化后的文本
print(formatted_text)
# 使用示例
if __name__ == "__main__":
# 基础颜色打印
ColorPrinter.print_color("普通信息", ColorPrinter.WHITE)
ColorPrinter.print_color("成功信息", ColorPrinter.GREEN)
ColorPrinter.print_color("警告信息", ColorPrinter.YELLOW)
ColorPrinter.print_color("错误信息", ColorPrinter.RED)
# 带背景色的打印
ColorPrinter.print_color("重要提示", ColorPrinter.BLACK, ColorPrinter.BG_YELLOW)
# 带样式的打印
ColorPrinter.print_color("加粗的标题", ColorPrinter.CYAN, style=ColorPrinter.BOLD)
ColorPrinter.print_color("下划线链接", ColorPrinter.BLUE, style=ColorPrinter.UNDERLINE)
# 组合样式
combined_style = f"{ColorPrinter.BOLD};{ColorPrinter.UNDERLINE}"
ColorPrinter.print_color("加粗且下划线的文本", ColorPrinter.MAGENTA, style=combined_style)
这个工具类的优势在于：
在实际开发中，彩色输出最常见的应用是日志系统。不同级别的日志（DEBUG、INFO、WARNING、ERROR、CRITICAL）使用不同颜色显示，能帮助开发者快速定位关键信息。
import time
from color_printer import ColorPrinter # 导入前面定义的ColorPrinter类
class ColorLogger:
"""彩色日志系统，支持不同级别日志的彩色输出"""
# 日志级别
DEBUG = "DEBUG"
INFO = "INFO"
WARNING = "WARNING"
ERROR = "ERROR"
CRITICAL = "CRITICAL"
@classmethod
def _get_timestamp(cls):
"""获取当前时间戳，格式：YYYY-MM-DD HH:MM:SS"""
return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
@classmethod
def debug(cls, message):
"""调试日志（灰色）"""
timestamp = cls._get_timestamp()
log_msg = f"[{timestamp}] [{cls.DEBUG}] {message}"
ColorPrinter.print_color(log_msg, ColorPrinter.LIGHT_BLACK)
@classmethod
def info(cls, message):
"""信息日志（蓝色）"""
timestamp = cls._get_timestamp()
log_msg = f"[{timestamp}] [{cls.INFO}] {message}"
ColorPrinter.print_color(log_msg, ColorPrinter.LIGHT_BLUE)
@classmethod
def warning(cls, message):
"""警告日志（黄色）"""
timestamp = cls._get_timestamp()
log_msg = f"[{timestamp}] [{cls.WARNING}] {message}"
ColorPrinter.print_color(log_msg, ColorPrinter.LIGHT_YELLOW)
@classmethod
def error(cls, message):
"""错误日志（红色）"""
timestamp = cls._get_timestamp()
log_msg = f"[{timestamp}] [{cls.ERROR}] {message}"
ColorPrinter.print_color(log_msg, ColorPrinter.LIGHT_RED)
@classmethod
def critical(cls, message):
"""严重错误日志（红色背景+白色文字+加粗）"""
timestamp = cls._get_timestamp()
log_msg = f"[{timestamp}] [{cls.CRITICAL}] {message}"
style = ColorPrinter.BOLD
ColorPrinter.print_color(log_msg, ColorPrinter.WHITE, ColorPrinter.BG_LIGHT_RED, style)
# 使用示例
if __name__ == "__main__":
# 模拟程序运行中的日志输出
ColorLogger.debug("开始初始化配置文件")
ColorLogger.info("配置文件加载完成")
ColorLogger.info("数据库连接成功")
ColorLogger.warning("磁盘空间不足，剩余空间低于20%")
ColorLogger.error("用户认证失败：密码错误")
ColorLogger.critical("数据库连接丢失，程序无法继续运行！")
运行上述代码后，不同级别的日志会以不同颜色显示：
这种视觉区分能显著提高日志阅读效率，尤其在日志量较大的情况下。
在处理列表、字典等复杂数据结构时，默认的 print 输出往往格式混乱，难以阅读。Python 提供了多种方式优化复杂数据的打印格式，其中 pprint 模块是最常用的工具之一。
当打印嵌套层次较深的字典或列表时，print 函数的输出通常是紧凑的单行或格式混乱的多行，例如：
# 复杂嵌套数据
complex_data = {
"name": "Python 3.13.6",
"features": ["优化的性能", "更好的类型提示", "改进的错误信息"],
"compatibility": {
"python_3_10": True,
"python_3_11": True,
"python_3_12": True,
"python_2": False
},
"released": {
"year": 2024,
"month": 9,
"day": 15
},
"maintainers": [
{"name": "John Doe", "role": "Core Developer"},
{"name": "Jane Smith", "role": "Release Manager"}
]
}
# 默认print输出
print(complex_data)
输出结果（格式混乱，可读性差）：
{'name': 'Python 3.13.6', 'features': ['优化的性能', '更好的类型提示', '改进的错误信息'], 'compatibility': {'python_3_10': True, 'python_3_11': True, 'python_3_12': True, 'python_2': False}, 'released': {'year': 2024, 'month': 9, 'day': 15}, 'maintainers': [{'name': 'John Doe', 'role': 'Core Developer'}, {'name': 'Jane Smith', 'role': 'Release Manager'}]}
这种输出格式在数据结构复杂时几乎无法直接阅读，需要更智能的格式化方式。
pprint（pretty-print）模块是 Python 标准库的一部分，专门用于美化复杂数据结构的输出格式。它能自动处理缩进、换行和排序，使输出更具可读性。
import time
from color_printer import ColorPrinter # 导入前面定义的ColorPrinter类
class ColorLogger:
"""彩色日志系统，支持不同级别日志的彩色输出"""
# 日志级别
DEBUG = "DEBUG"
INFO = "INFO"
WARNING = "WARNING"
ERROR = "ERROR"
CRITICAL = "CRITICAL"
@classmethod
def _get_timestamp(cls):
"""获取当前时间戳，格式：YYYY-MM-DD HH:MM:SS"""
return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
@classmethod
def debug(cls, message):
"""调试日志（灰色）"""
timestamp = cls._get_timestamp()
log_msg = f"[{timestamp}] [{cls.DEBUG}] {message}"
ColorPrinter.print_color(log_msg, ColorPrinter.LIGHT_BLACK)
@classmethod
def info(cls, message):
"""信息日志（蓝色）"""
timestamp = cls._get_timestamp()
log_msg = f"[{timestamp}] [{cls.INFO}] {message}"
ColorPrinter.print_color(log_msg, ColorPrinter.LIGHT_BLUE)
@classmethod
def warning(cls, message):
"""警告日志（黄色）"""
timestamp = cls._get_timestamp()
log_msg = f"[{timestamp}] [{cls.WARNING}] {message}"
ColorPrinter.print_color(log_msg, ColorPrinter.LIGHT_YELLOW)
@classmethod
def error(cls, message):
"""错误日志（红色）"""
timestamp = cls._get_timestamp()
log_msg = f"[{timestamp}] [{cls.ERROR}] {message}"
ColorPrinter.print_color(log_msg, ColorPrinter.LIGHT_RED)
@classmethod
def critical(cls, message):
"""严重错误日志（红色背景+白色文字+加粗）"""
timestamp = cls._get_timestamp()
log_msg = f"[{timestamp}] [{cls.CRITICAL}] {message}"
style = ColorPrinter.BOLD
ColorPrinter.print_color(log_msg, ColorPrinter.WHITE, ColorPrinter.BG_LIGHT_RED, style)
# 使用示例
if __name__ == "__main__":
# 模拟程序运行中的日志输出
ColorLogger.debug("开始初始化配置文件")
ColorLogger.info("配置文件加载完成")
ColorLogger.info("数据库连接成功")
ColorLogger.warning("磁盘空间不足，剩余空间低于20%")
ColorLogger.error("用户认证失败：密码错误")
ColorLogger.critical("数据库连接丢失，程序无法继续运行！")
运行结果对比：
print 输出：紧凑的单行或混乱的多行，难以阅读pprint.pprint 输出：自动缩进、换行，层次清晰pprint.pformat：返回格式化后的字符串，可用于日志记录或进一步处理pprint 模块的核心功能：
pprint 模块提供了丰富的参数，可根据需求定制输出格式。常用参数包括：
indent：缩进空格数（默认 1）width：最大输出宽度（默认 80）depth：控制递归打印的深度（避免深层嵌套导致的过长输出）sort_dicts：是否对字典的键进行排序（默认 True）import pprint
# 深层嵌套的数据结构
deep_nested_data = {
"level1": {
"level2": {
"level3": {
"level4": {
"level5": "这是深层嵌套的数据",
"items": [1, 2, 3, 4, 5]
},
"attributes": {"a": 10, "b": 20, "c": 30}
},
"list_data": ["apple", "banana", "cherry", "date", "elderberry"]
}
}
}
print("=== 默认pprint输出 ===")
pprint.pprint(deep_nested_data)
print("n=== 增加缩进和调整宽度 ===")
pprint.pprint(deep_nested_data, indent=4, width=100)
print("n=== 限制递归深度（depth=3） ===")
pprint.pprint(deep_nested_data, depth=3) # 超过3层的嵌套会显示为...
print("n=== 不排序字典键（sort_dicts=False） ===")
# 注意：Python 3.8+ 才支持sort_dicts参数
pprint.pprint(deep_nested_data, sort_dicts=False)
print("n=== 使用PrettyPrinter对象进行多次配置 ===")
# 创建自定义配置的PrettyPrinter对象
printer = pprint.PrettyPrinter(
indent=2,
width=90,
depth=4,
sort_dicts=True
)
print("自定义打印机输出1：")
printer.pprint(deep_nested_data)
print("n自定义打印机输出2（同一配置）：")
another_data = {"a": [1, 2, 3], "b": {"x": 10, "y": 20}}
printer.pprint(another_data)
通过这些参数，我们可以：
sort_dicts=False），这在需要保持数据原始顺序时非常有用将 pprint 的格式化能力与前面介绍的彩色输出结合，可以进一步提升复杂数据的可读性。例如，为字典的键和值设置不同颜色，或为不同类型的数据（字符串、数字、布尔值）使用不同颜色。
# 案例1：基础文本颜色设置
print("默认文本")
print(" 33[31m红色文本 33[0m") # 红色文本
print(" 33[32m绿色文本 33[0m") # 绿色文本
print(" 33[33m黄色文本 33[0m") # 黄色文本
print(" 33[34m蓝色文本 33[0m") # 蓝色文本
print(" 33[35m洋红色文本 33[0m")# 洋红色文本
print(" 33[36m青色文本 33[0m") # 青色文本
print(" 33[37m白色文本 33[0m") # 白色文本
# 案例2：高亮度文本颜色
print("n高亮度颜色示例：")
print(" 33[91m高亮度红色 33[0m")
print(" 33[92m高亮度绿色 33[0m")
print(" 33[93m高亮度黄色 33[0m")
print(" 33[94m高亮度蓝色 33[0m")
# 案例3：背景颜色设置
print("n背景颜色示例：")
print(" 33[41m红色背景 33[0m")
print(" 33[42m绿色背景 33[0m")
print(" 33[44m蓝色背景 33[0m")
print(" 33[103m高亮度黄色背景 33[0m")
# 案例4：文本样式与颜色组合
print("n样式组合示例：")
print(" 33[1;31m加粗红色文本 33[0m") # 1=加粗
print(" 33[4;32m下划线绿色文本 33[0m") #4=下划线
print(" 33[1;4;33m加粗下划线黄色文本 33[0m") # 组合样式
print(" 33[7;34m反显蓝色文本（前景背景互换） 33[0m") #7=反显
# 案例5：在同一行输出多种颜色
print("n混合颜色示例：")
print("这是 33[31m红色 33[0m，这是 33[32m绿色 33[0m，这是 33[34m蓝色 33[0m")
这个 color_pprint 函数通过以下步骤实现彩色格式化输出：
pprint.pformat 生成格式化的字符串运行结果中：
这种方式使得复杂数据结构的不同组成部分一目了然，极大提升了数据阅读效率。
除了 pprint 模块，Python 生态中还有其他工具可用于特定场景的格式化打印：
如果处理的是 JSON 格式数据（或类 JSON 结构的字典和列表），json.dumps() 函数提供了格式化功能：
import json
data = {
"name": "JSON格式化演示",
"version": 2.0,
"features": ["缩进", "排序", "中文支持"]
}
# 格式化JSON输出
formatted_json = json.dumps(data, indent=2, ensure_ascii=False, sort_keys=True)
print(formatted_json)
输出：
{
"features": [
"缩进",
"排序",
"中文支持"
],
"name": "JSON格式化演示",
"version": 2.0
}
json.dumps() 的优势在于对 JSON 语法的严格遵循，适合 API 响应、配置文件等 JSON 场景。
PyYAML 库（第三方库）可以将 Python 数据结构转换为 YAML 格式，这种格式比 JSON 更简洁易读：
# 安装：pip install pyyaml
import yaml
data = {
"name": "YAML格式化演示",
"version": 3.0,
"features": ["简洁", "易读", "支持注释"]
}
# 转换为YAML格式
formatted_yaml = yaml.dump(data, allow_unicode=True, sort_keys=False)
print(formatted_yaml)
输出：
name: YAML格式化演示
version: 3.0
features:
- 简洁
- 易读
- 支持注释
YAML 格式特别适合配置文件和需要人工编辑的场景。
在开发过程中，调试是必不可少的环节。虽然现代 IDE 提供了强大的断点调试工具，但在很多场景下（如远程服务器、CI 环境），使用 print 函数进行调试仍然是最便捷高效的方式。掌握 print 调试技巧，能显著提升问题定位效率。
最基础的调试方式是在关键位置打印变量值和执行步骤，确认程序是否按预期运行。
def calculate_average(numbers):
"""计算列表中数字的平均值"""
# 调试点1：打印输入参数
print(f"[调试] 输入的数字列表：{numbers}")
# 检查输入是否为空
if not numbers:
print(f"[调试] 输入为空列表，返回0") # 调试点2：打印特殊情况
return 0
# 计算总和
total = 0
for i, num in enumerate(numbers):
total += num
# 调试点3：打印循环过程中的中间结果
print(f"[调试] 第{i+1}次循环：当前数字={num}，累计总和={total}")
# 计算平均值
average = total / len(numbers)
# 调试点4：打印计算结果
print(f"[调试] 总和={total}，元素个数={len(numbers)}，平均值={average}")
return average
# 测试函数
if __name__ == "__main__":
print("测试1：正常输入")
result1 = calculate_average([10, 20, 30, 40, 50])
print(f"结果：{result1}n")
print("测试2：空列表")
result2 = calculate_average([])
print(f"结果：{result2}n")
print("测试3：单元素列表")
result3 = calculate_average([25])
print(f"结果：{result3}")
这种调试方式的核心是：
通过这些打印信息，我们可以清晰地跟踪程序的执行流程和数据变化，快速定位问题。
在复杂程序中，单纯打印变量值可能不足以定位问题，还需要打印更多上下文信息（如文件名、函数名、行号）。结合彩色输出，可以让调试信息更醒目。
import inspect
from color_printer import ColorPrinter # 导入彩色打印工具类
def debug_print(message, variable_name=None, variable_value=None):
"""
增强版调试打印函数，包含上下文信息和彩色标识
参数:
message: 调试信息
variable_name: 变量名（可选）
variable_value: 变量值（可选）
"""
# 获取调用者的上下文信息
caller_frame = inspect.stack()[1]
filename = caller_frame.filename.split('/')[-1] # 文件名（只保留最后部分）
function_name = caller_frame.function # 函数名
line_number = caller_frame.lineno # 行号
# 构建上下文前缀
context = f"[{filename}:{function_name}:{line_number}]"
# 构建完整调试信息
debug_msg = f"{ColorPrinter.YELLOW}[调试]{ColorPrinter.RESET} {context} {message}"
# 如果提供了变量信息，添加变量名和值
if variable_name is not None and variable_value is not None:
debug_msg += f" | {ColorPrinter.CYAN}{variable_name}{ColorPrinter.RESET} = {variable_value}"
print(debug_msg)
def process_data(data_list):
"""处理数据列表的示例函数"""
debug_print("开始处理数据", "数据列表长度", len(data_list))
if not data_list:
debug_print("数据列表为空，直接返回", "data_list", data_list)
return []
processed = []
for i, item in enumerate(data_list):
if i % 2 == 0: # 只处理偶数索引的元素
debug_print(f"处理第{i}个元素", "原始值", item)
processed_item = item * 2
processed.append(processed_item)
debug_print(f"处理完成", "处理后的值", processed_item)
debug_print("数据处理完成", "处理后的数据长度", len(processed))
return processed
# 测试调试函数
if __name__ == "__main__":
sample_data = [1, 2, 3, 4, 5]
result = process_data(sample_data)
print(f"n最终结果：{result}")
这个增强版调试函数的优势在于：
在大型项目中，这种调试方式能帮助开发者快速定位问题发生的位置和原因。
在调试复杂程序时，过多的调试信息会干扰正常输出。可以通过设置调试级别或条件，控制调试信息的输出。
import inspect
from color_printer import ColorPrinter
# 调试级别常量
DEBUG_LEVEL_NONE = 0 # 不输出任何调试信息
DEBUG_LEVEL_BASIC = 1 # 输出基本调试信息
DEBUG_LEVEL_DETAILED = 2 # 输出详细调试信息
DEBUG_LEVEL_VERBOSE = 3 # 输出冗长调试信息
# 全局调试级别设置
current_debug_level = DEBUG_LEVEL_DETAILED
def debug_print(message, level=DEBUG_LEVEL_BASIC, variable_name=None, variable_value=None):
"""
带级别控制的调试打印函数
参数:
message: 调试信息
level: 调试级别（数字越大越详细）
variable_name: 变量名（可选）
variable_value: 变量值（可选）
"""
# 如果当前级别低于设置的级别，则不输出
if level > current_debug_level:
return
# 获取级别标签和颜色
level_info = {
DEBUG_LEVEL_BASIC: ("基础", ColorPrinter.LIGHT_BLUE),
DEBUG_LEVEL_DETAILED: ("详细", ColorPrinter.LIGHT_YELLOW),
DEBUG_LEVEL_VERBOSE: ("冗长", ColorPrinter.LIGHT_RED)
}
level_name, level_color = level_info.get(level, ("未知", ColorPrinter.WHITE))
# 获取上下文信息
caller_frame = inspect.stack()[1]
filename = caller_frame.filename.split('/')[-1]
function_name = caller_frame.function
line_number = caller_frame.lineno
context = f"[{filename}:{function_name}:{line_number}]"
# 构建调试信息
debug_msg = f"{level_color}[{level_name}调试]{ColorPrinter.RESET} {context} {message}"
# 添加变量信息
if variable_name is not None and variable_value is not None:
debug_msg += f" | {ColorPrinter.CYAN}{variable_name}{ColorPrinter.RESET} = {variable_value}"
print(debug_msg)
def complex_algorithm(input_data):
"""复杂算法示例，包含不同级别的调试信息"""
debug_print("开始执行复杂算法", DEBUG_LEVEL_BASIC, "输入数据长度", len(input_data))
# 预处理阶段
debug_print("开始预处理数据", DEBUG_LEVEL_DETAILED)
processed = [x for x in input_data if x is not None]
debug_print("预处理完成", DEBUG_LEVEL_DETAILED, "处理后数据长度", len(processed))
# 核心计算（输出冗长调试信息）
result = 0
for i, value in enumerate(processed):
debug_print(f"处理第{i}个元素", DEBUG_LEVEL_VERBOSE, "当前值", value)
result += value * 2
debug_print(f"累计结果更新", DEBUG_LEVEL_VERBOSE, "当前结果", result)
debug_print("算法执行完成", DEBUG_LEVEL_BASIC, "最终结果", result)
return result
# 测试条件调试
if __name__ == "__main__":
test_data = [10, None, 20, 30, None, 40]
print("=== 当前调试级别：详细（只输出级别1和2的信息） ===")
complex_algorithm(test_data)
print("n=== 修改调试级别为基础（只输出级别1的信息） ===")
current_debug_level = DEBUG_LEVEL_BASIC
complex_algorithm(test_data)
print("n=== 修改调试级别为冗长（输出所有级别的信息） ===")
current_debug_level = DEBUG_LEVEL_VERBOSE
complex_algorithm(test_data)
这种条件调试方式的核心优势：
在实际开发中，还可以将调试级别通过命令行参数或配置文件进行设置，实现更灵活的控制。
在处理异常和复杂状态时，print 调试可以帮助我们捕获关键的状态快照和异常信息。
import traceback
from color_printer import ColorPrinter
def debug_exception(e, additional_info=None):
"""打印异常信息的调试函数"""
print(f"n{ColorPrinter.RED}[异常发生]{ColorPrinter.RESET}")
print(f"类型：{type(e).__name__}")
print(f"消息：{str(e)}")
if additional_info:
print(f"附加信息：{additional_info}")
print("堆栈跟踪：")
print(traceback.format_exc())
print()
def process_user_data(users):
"""处理用户数据的函数，包含异常处理和状态调试"""
# 打印初始状态快照
print(f"n{ColorPrinter.BLUE}[初始状态快照]{ColorPrinter.RESET}")
print(f"用户总数：{len(users)}")
print(f"用户ID列表：{[user.get('id') for user in users]}")
processed_users = []
for i, user in enumerate(users):
try:
# 打印当前处理的用户信息
print(f"n{ColorPrinter.GREEN}[处理用户 #{i+1}]{ColorPrinter.RESET}")
print(f"当前用户原始数据：{user}")
# 验证必要字段
if 'id' not in user:
raise ValueError("用户数据缺少'id'字段")
if 'name' not in user:
raise ValueError("用户数据缺少'name'字段")
# 处理用户数据
processed = {
'user_id': user['id'],
'full_name': user['name'],
'is_active': user.get('active', True),
'registration_year': int(user.get('reg_date', '2020').split('-')[0])
}
processed_users.append(processed)
print(f"处理后的数据：{processed}")
except Exception as e:
# 打印异常信息和当前状态
debug_exception(e, f"处理第{i+1}个用户时发生错误")
print(f"{ColorPrinter.YELLOW}[警告] 跳过错误用户数据{ColorPrinter.RESET}")
# 打印最终状态快照
print(f"n{ColorPrinter.BLUE}[最终状态快照]{ColorPrinter.RESET}")
print(f"成功处理的用户数：{len(processed_users)}")
print(f"处理失败的用户数：{len(users) - len(processed_users)}")
return processed_users
# 测试数据（包含正常和异常数据）
test_users = [
{'id': 1, 'name': '张三', 'reg_date': '2022-03-15'},
{'id': 2, 'name': '李四', 'active': False},
{'name': '王五'}, # 缺少id字段
{'id': 4, 'reg_date': '2021-07-20'}, # 缺少name字段
{'id': 5, 'name': '赵六', 'reg_date': 'invalid-date'} # 日期格式错误
]
# 执行处理函数
result = process_user_data(test_users)
这个示例展示了复杂场景下的调试技巧：
traceback 模块打印堆栈跟踪，精确定位错误位置这种调试方式特别适合数据处理、批量任务等容易出现部分失败的场景。
使用 print 进行调试时，容易导致调试代码散落在业务逻辑中，影响代码整洁度。以下是一些最佳实践：
使用调试函数集中管理：将所有调试打印逻辑封装到专门的调试函数中，便于统一控制和清理
使用条件编译或装饰器：通过装饰器或条件语句，在生产环境自动禁用调试输出
import os
from functools import wraps
# 检查是否为调试模式（可通过环境变量控制）
DEBUG_MODE = os.environ.get('DEBUG_MODE', 'False').lower() == 'true'
def debug_decorator(func):
"""调试装饰器，在函数调用前后打印信息（仅在调试模式下）"""
@wraps(func)
def wrapper(*args, **kwargs):
if DEBUG_MODE:
print(f"n{'-'*50}")
print(f"调用函数：{func.__name__}")
print(f"位置参数：{args}")
print(f"关键字参数：{kwargs}")
print(f"{'-'*50}")
# 执行原函数
result = func(*args, **kwargs)
if DEBUG_MODE:
print(f"n{'-'*50}")
print(f"函数 {func.__name__} 执行完成")
print(f"返回结果：{result}")
print(f"{'-'*50}n")
return result
return wrapper
@debug_decorator
def calculate_total(prices, tax_rate=0.1):
"""计算总价（含税费）"""
subtotal = sum(prices)
tax = subtotal * tax_rate
total = subtotal + tax
return round(total, 2)
# 使用示例
if __name__ == "__main__":
print("=== 调试模式下运行（DEBUG_MODE=True） ===")
os.environ['DEBUG_MODE'] = 'True'
total1 = calculate_total([10.5, 20.3, 15.8], tax_rate=0.08)
print(f"总价：{total1}")
print("n=== 生产模式下运行（DEBUG_MODE=False） ===")
os.environ['DEBUG_MODE'] = 'False'
total2 = calculate_total([10.5, 20.3, 15.8], tax_rate=0.08)
print(f"总价：{total2}")
3.** 使用日志模块替代 print**：Python 标准库的 logging 模块提供了更强大的日志控制能力，包括级别控制、输出目标、格式定制等，是生产环境中替代 print 调试的最佳选择
调试后及时清理：开发完成后，应删除或注释掉临时调试语句，只保留必要的日志输出
使用版本控制：在调试过程中，通过版本控制（如 Git）管理代码，便于追踪调试代码的添加和删除
print 函数作为 Python 中最基础的输出工具，其功能远不止于简单的文本打印。本文从三个维度深入探讨了 print 函数的进阶应用：
彩色输出：通过 ANSI 转义序列，我们可以在终端中实现文本颜色、背景色和样式的定制，显著提升信息的可读性。封装工具类后，彩色输出可以像普通 print 一样简单易用，特别适合日志系统和用户交互场景。
复杂数据格式化：面对列表、字典等复杂数据结构，pprint 模块提供了优雅的格式化打印能力，通过自动缩进、换行和排序，使数据结构清晰可读。结合彩色输出后，不同类型的数据元素可以用不同颜色标识，进一步提升阅读效率。
调试技巧：print 函数是简单高效的调试工具，通过打印变量值、执行步骤和上下文信息，可以快速定位问题。配合条件控制和级别管理，可以在不干扰正常输出的前提下，提供丰富的调试信息。
在 Python 3.13.6 中，这些功能得到了更好的支持和兼容性。掌握这些进阶技巧，能帮助开发者写出更易读、更易调试的代码，显著提升开发效率。
未来，随着终端技术的发展，print 函数可能会支持更多富文本功能（如表格、图像等）。但无论如何发展，理解输出函数的底层原理和灵活应用技巧，始终是每个 Python 开发者的必备技能。
