Python调试与日志——print调试

一、什么是print调试？

print调试 是最简单、最直接的调试方法。通过在代码中插入 print() 语句，输出变量的值、程序执行的位置等信息，来观察程序的运行状态和定位问题。

defcalculate_average(numbers):
print(f"输入数据: {numbers}")  # 查看输入
    total = sum(numbers)
print(f"总和: {total}")        # 查看中间结果
    count = len(numbers)
print(f"数量: {count}")        # 查看数量
    average = total / count
print(f"平均值: {average}")    # 查看输出
return average

calculate_average([10, 20, 30, 40])

二、为什么使用print调试？

2.1 优点

• • 简单直接：无需学习复杂工具，上手即用
• • 快速验证：几秒钟就能添加和查看输出
• • 适用性强：任何环境都能使用，不需要IDE支持
• • 灵活控制：可以输出任意格式的信息

2.2 缺点

• • 侵入性强：需要修改源代码
• • 容易遗漏：调试完后可能忘记删除
• • 干扰输出：大量print会混乱正常输出
• • 性能影响：大量print会降低程序性能

三、print调试的基本用法

3.1 查看变量值

defdivide(a, b):
print(f"[DEBUG] a={a}, b={b}")  # 查看参数
    result = a / b
print(f"[DEBUG] result={result}")  # 查看结果
return result

divide(10, 2)

3.2 追踪程序执行路径

defprocess_data(data):
print(">>> 进入 process_data")

ifnot data:
print(">>> 数据为空，提前返回")
return []

print(">>> 开始处理数据")
    result = [x * 2for x in data]

print(">>> 处理完成，返回结果")
return result

process_data([1, 2, 3])
process_data([])

3.3 检查循环执行过程

deffind_max(numbers):
    max_val = numbers[0]

for i, num inenumerate(numbers):
print(f"循环 {i}: 当前值={num}, 当前最大值={max_val}")

if num > max_val:
print(f"  -> 发现新的最大值: {num}")
            max_val = num

print(f"最终最大值: {max_val}")
return max_val

find_max([3, 5, 2, 8, 1])

四、提高print调试效率的技巧

4.1 使用格式化输出

# 使用 f-string（推荐）
name = "张三"
age = 25
print(f"用户: {name}, 年龄: {age}")

# 使用 format
print("用户: {}, 年龄: {}".format(name, age))

# 使用 % 格式化
print("用户: %s, 年龄: %d" % (name, age))

4.2 添加调试标记

# 使用特殊前缀便于区分和搜索
print("[DEBUG] 变量值: x=10")
print("[INFO] 程序启动")
print("[WARN] 注意：数据可能不完整")
print("[ERROR] 计算失败")

# 使用分隔线
print("=" * 50)
print("关键位置")
print("-" * 50)

4.3 打印变量名和值

defdebug_var(var, name=None):
"""打印变量名和值"""
if name isNone:
# 尝试获取变量名（简单方法）
import inspect
        frame = inspect.currentframe().f_back
for var_name, var_value in frame.f_locals.items():
if var_value is var:
                name = var_name
break
print(f"{name}: {var}")

x = 100
y = [1, 2, 3]
debug_var(x, "x")  # x: 100
debug_var(y, "y")  # y: [1, 2, 3]

4.4 使用条件调试

DEBUG = True# 全局调试开关

defdebug_print(*args, **kwargs):
if DEBUG:
print(*args, **kwargs)

debug_print("这条消息只在DEBUG模式下显示")

五、高级print调试技巧

5.1 打印调用栈

import traceback

defdebug_call_stack():
"""打印当前调用栈"""
print("调用栈:")
for line in traceback.format_stack():
print(line.strip())

deffunc_a():
    func_b()

deffunc_b():
    func_c()

deffunc_c():
    debug_call_stack()

func_a()

5.2 计时装饰器

import time
from functools import wraps

deftimer(func):
    @wraps(func)
defwrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
print(f"[TIMER] {func.__name__} 耗时: {end - start:.4f}秒")
return result
return wrapper

@timer
defslow_function():
    time.sleep(1)
return"完成"

slow_function()

5.3 函数调用追踪

deftrace(func):
"""追踪函数调用"""
    @wraps(func)
defwrapper(*args, **kwargs):
print(f"调用 {func.__name__}({args}, {kwargs})")
        result = func(*args, **kwargs)
print(f"{func.__name__} 返回 {result}")
return result
return wrapper

@trace
defadd(a, b):
return a + b

@trace
defmultiply(a, b):
return a * b

multiply(add(2, 3), 4)

5.4 使用内置的 __debug__

# 使用 -O 选项运行时，__debug__ 为 False
if__debug__:
print("调试模式")

# 在调试模式下运行: python script.py
# 在优化模式下运行: python -O script.py

六、实战案例

6.1 二叉树遍历调试

classTreeNode:
def__init__(self, val):
self.val = val
self.left = None
self.right = None

definorder_traversal(root, depth=0):
"""中序遍历（带缩进显示递归深度）"""
    indent = "  " * depth
print(f"{indent}进入节点: {root.val if root elseNone}")

if root isNone:
print(f"{indent}返回 None")
return []

print(f"{indent}遍历左子树")
    left = inorder_traversal(root.left, depth + 1)

print(f"{indent}访问节点值: {root.val}")
    current = [root.val]

print(f"{indent}遍历右子树")
    right = inorder_traversal(root.right, depth + 1)

    result = left + current + right
print(f"{indent}返回: {result}")
return result

# 构建树
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)

result = inorder_traversal(root)
print(f"\n最终结果: {result}")

6.2 递归函数调试

deffibonacci(n, depth=0):
    indent = "  " * depth
print(f"{indent}fibonacci({n}) 被调用")

if n <= 1:
print(f"{indent}基础情况，返回 {n}")
return n

print(f"{indent}计算 fibonacci({n-1})")
    a = fibonacci(n - 1, depth + 1)

print(f"{indent}计算 fibonacci({n-2})")
    b = fibonacci(n - 2, depth + 1)

    result = a + b
print(f"{indent}fibonacci({n}) 返回 {result}")
return result

fibonacci(5)

6.3 数据流追踪

classPipeline:
def__init__(self):
self.steps = []

defadd_step(self, name, func):
self.steps.append((name, func))
returnself

defprocess(self, data):
print(f"初始数据: {data}")

for name, func inself.steps:
print(f"执行步骤: {name}")
            data = func(data)
print(f"  结果: {data}")

print(f"最终结果: {data}")
return data

pipeline = Pipeline()
pipeline.add_step("去除空格", lambda s: s.strip())
pipeline.add_step("转小写", lambda s: s.lower())
pipeline.add_step("替换", lambda s: s.replace("python", "Python"))
pipeline.process("  Hello PYTHON World  ")

6.4 网络请求调试

import requests
import json

defdebug_request(url, method='GET', **kwargs):
"""调试HTTP请求"""
print("=" * 50)
print(f"发送 {method} 请求: {url}")

if'headers'in kwargs:
print(f"Headers: {json.dumps(kwargs['headers'], indent=2)}")

if'json'in kwargs:
print(f"JSON Body: {json.dumps(kwargs['json'], indent=2, ensure_ascii=False)}")
elif'data'in kwargs:
print(f"Data: {kwargs['data']}")

print("-" * 50)

    response = requests.request(method, url, **kwargs)

print(f"响应状态码: {response.status_code}")
print(f"响应耗时: {response.elapsed.total_seconds():.3f}秒")

try:
print(f"响应内容: {json.dumps(response.json(), indent=2, ensure_ascii=False)}")
except:
print(f"响应内容: {response.text[:200]}...")

print("=" * 50)
return response

# 使用
# response = debug_request('https://api.github.com/users/octocat')

6.5 算法调试（冒泡排序可视化）

defbubble_sort(arr):
    n = len(arr)
print(f"初始数组: {arr}")

for i inrange(n - 1):
print(f"\n第 {i + 1} 轮:")
        swapped = False

for j inrange(n - 1 - i):
print(f"  比较 {arr[j]} 和 {arr[j + 1]}", end=" ")

if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
print(f"-> 交换 -> {arr}")
                swapped = True
else:
print(f"-> 不交换 -> {arr}")

ifnot swapped:
print("  本轮没有交换，提前结束")
break

print(f"\n排序结果: {arr}")
return arr

bubble_sort([5, 3, 8, 4, 2])

七、print调试的局限性

7.1 异步代码难以调试

import asyncio

asyncdefasync_task():
print("开始异步任务")  # 输出顺序可能与预期不同
await asyncio.sleep(1)
print("异步任务完成")

asyncdefmain():
    tasks = [async_task() for _ inrange(3)]
await asyncio.gather(*tasks)

# asyncio.run(main())

7.2 多线程输出混乱

import threading
import time

defworker(name):
for i inrange(3):
print(f"线程 {name}: 第{i}次")  # 输出可能交错
        time.sleep(0.1)

threads = []
for i inrange(3):
    t = threading.Thread(target=worker, args=(i,))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

八、改进print调试的方法

8.1 使用logging模块

import logging

logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)

defdivide(a, b):
    logger.debug(f"调用 divide({a}, {b})")
    result = a / b
    logger.debug(f"结果: {result}")
return result

8.2 使用断言

defcalculate_average(numbers):
assertlen(numbers) > 0, "列表不能为空"
    total = sum(numbers)
    average = total / len(numbers)
assert0 <= average <= 100, f"平均值超出范围: {average}"
return average

8.3 使用IDE调试器

• • 设置断点（Breakpoints）
• • 单步执行（Step Over/Into/Out）
• • 监视变量（Watch）
• • 条件断点

九、总结

核心要点：

• • print调试 是最简单直接的调试方法，适合快速验证和简单问题。
• • 使用格式化输出、调试标记、条件调试可以提高效率。
• • 对于递归、算法、数据流等场景，print调试能清晰展示执行过程。
• • print调试有局限性：侵入性强、异步/多线程输出混乱、可能遗留调试代码。
• • 生产环境应使用 logging 模块，而不是 print。
• • 复杂问题应结合IDE调试器、单元测试等专业工具。

最佳实践：

1. 1. 使用统一的调试标记（如 [DEBUG]），便于搜索和删除
2. 2. 使用 DEBUG 开关控制调试输出
3. 3. 调试完成后及时清理调试代码
4. 4. 对于复杂项目，使用 logging 替代 print

掌握print调试技巧，可以帮助你快速定位问题，是每个程序员的必备技能。但对于正式项目，建议使用更专业的调试和日志工具。