Orion K Blog
Python调试技巧：从print到高级调试工具的完全指南
Orion K Lv6
  2021-09-28 14:10:00  

Python调试技巧：从print到高级调试工具的完全指南

调试是每个开发者日常工作中不可避免的一部分。无论你的代码写得多么精心，总会有那么一些bug悄悄潜入。在这篇文章中，我将分享一系列Python调试技巧，从简单的print语句到高级调试工具，帮助你更高效地找出并修复代码中的问题。

基础调试技巧

1. 使用print语句

尽管简单，但print语句仍然是最直接的调试方法之一：

1
2
3
4
5
6
7
8
9
10
def calculate_total(items):
    total = 0
    for item in items:
        print(f"Processing item: {item}")  # 打印当前处理的项
        total += item
        print(f"Current total: {total}")  # 打印当前总和
    return total

result = calculate_total([1, 2, 3, 4, 5])
print(f"Final result: {result}")

优点：简单直接，不需要额外工具。
缺点：需要修改代码，可能产生大量输出，需要手动清理。

2. 使用断言

断言可以帮助你验证代码中的假设，当断言失败时会引发异常：

1
2
3
4
5
6
7
8
def divide(a, b):
    assert b != 0, "除数不能为零"
    return a / b

try:
    result = divide(10, 0)
except AssertionError as e:
    print(f"断言错误: {e}")

优点：可以在开发阶段捕获逻辑错误，代码更健壮。
缺点：在生产环境中可能被禁用（使用-O选项运行Python）。

3. 使用日志

相比print，日志提供了更多的灵活性和控制：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import logging

# 配置日志
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

def process_data(data):
    logging.debug(f"开始处理数据: {data}")
    
    if not data:
        logging.warning("收到空数据")
        return None
    
    try:
        result = data[0] / data[1]
        logging.info(f"处理成功，结果: {result}")
        return result
    except Exception as e:
        logging.error(f"处理数据时出错: {e}", exc_info=True)
        return None

process_data([10, 2])  # 正常情况
process_data([])       # 空数据
process_data([10, 0])  # 除零错误

优点：可以设置不同的日志级别，可以输出到文件，包含时间戳和上下文信息。
缺点：需要一些初始设置。

使用Python内置调试器pdb

Python的内置调试器pdb提供了交互式调试环境，允许你一步一步执行代码。

1. 基本用法

1
2
3
4
5
6
7
8
9
10
def complex_function(a, b):
    result = a * b
    # 在这里设置断点
    import pdb; pdb.set_trace()
    for i in range(result):
        if i % 3 == 0:
            result -= 1
    return result

complex_function(4, 5)

当执行到pdb.set_trace()时，程序会暂停，进入交互式调试模式。

2. 常用pdb命令

  • n（next）：执行当前行，并移动到下一行
  • s（step）：步入函数调用
  • c（continue）：继续执行直到下一个断点
  • q（quit）：退出调试器
  • p expression：打印表达式的值
  • l（list）：显示当前位置的代码
  • w（where）：打印当前位置的堆栈跟踪
  • b line_number：设置断点
  • h（help）：显示帮助信息

3. Python 3.7+中的breakpoint()函数

从Python 3.7开始，可以使用内置的breakpoint()函数代替import pdb; pdb.set_trace()：

1
2
3
4
5
6
7
def complex_function(a, b):
    result = a * b
    breakpoint()  # 在这里设置断点
    for i in range(result):
        if i % 3 == 0:
            result -= 1
    return result

优点：可以通过环境变量PYTHONBREAKPOINT控制调试行为，更灵活。

IDE集成调试

现代IDE提供了强大的图形化调试工具，使调试过程更加直观。

1. PyCharm调试

PyCharm提供了完整的调试功能：

  • 设置断点：点击代码行号旁边
  • 启动调试：点击”Debug”按钮
  • 调试控制：步入、步过、继续等
  • 变量查看：在调试窗口中查看变量值
  • 条件断点：设置只在特定条件下触发的断点

2. VS Code调试

VS Code通过Python扩展提供类似的调试功能：

  • 需要配置launch.json文件
  • 支持断点、变量查看、调用堆栈等
  • 支持远程调试

3. Jupyter Notebook调试

在Jupyter Notebook中，可以使用%debug魔术命令在异常发生后进入调试模式：

1
2
3
4
5
6
7
8
def problematic_function():
    a = [1, 2, 3]
    return a[10]  # 索引错误

try:
    problematic_function()
except:
    %debug  # 进入事后调试模式

高级调试技巧

1. 使用装饰器进行函数调试

自定义装饰器可以帮助跟踪函数调用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import functools
import time

def debug(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        args_repr = [repr(a) for a in args]
        kwargs_repr = [f"{k}={v!r}" for k, v in kwargs.items()]
        signature = ", ".join(args_repr + kwargs_repr)
        
        print(f"调用 {func.__name__}({signature})")
        start_time = time.time()
        
        try:
            result = func(*args, **kwargs)
            print(f"{func.__name__} 返回: {result!r}")
        except Exception as e:
            print(f"{func.__name__} 抛出异常: {e}")
            raise
        finally:
            end_time = time.time()
            print(f"{func.__name__} 执行时间: {end_time - start_time:.6f}秒")
        
        return result
    
    return wrapper

@debug
def factorial(n):
    if n < 0:
        raise ValueError("n必须是非负整数")
    if n == 0:
        return 1
    return n * factorial(n - 1)

factorial(5)

2. 使用上下文管理器计时

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import time
from contextlib import contextmanager

@contextmanager
def timer(name):
    start_time = time.time()
    try:
        yield
    finally:
        end_time = time.time()
        print(f"{name} 执行时间: {end_time - start_time:.6f}秒")

# 使用上下文管理器
with timer("排序操作"):
    sorted_list = sorted([5, 3, 8, 1, 2, 7, 4, 6] * 1000)

3. 使用tracemalloc跟踪内存分配

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import tracemalloc

# 启动跟踪
tracemalloc.start()

# 创建一些对象
my_list = [1] * (10 ** 6)
my_dict = {i: i * 2 for i in range(10 ** 5)}

# 获取当前内存快照
snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('lineno')

# 打印前10个内存块
print("[ 内存使用情况 ]")
for stat in top_stats[:10]:
    print(stat)

4. 使用cProfile进行性能分析

1
2
3
4
5
6
7
8
9
import cProfile

def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# 使用cProfile分析函数性能
cProfile.run('fibonacci(30)')

5. 使用第三方调试工具

a. ipdb - 增强版pdb

1
pip install ipdb
1
2
3
4
5
6
import ipdb

def complex_function():
    # ...
    ipdb.set_trace()
    # ...

ipdb提供了语法高亮和tab补全等功能。

b. pudb - 基于控制台的可视化调试器

1
pip install pudb
1
2
3
4
5
6
import pudb

def complex_function():
    # ...
    pudb.set_trace()
    # ...

pudb提供了类似IDE的界面，但在终端中运行。

c. remote-pdb - 远程调试

1
pip install remote-pdb
1
2
3
4
5
6
from remote_pdb import set_trace

def complex_function():
    # ...
    set_trace(host='0.0.0.0', port=4444)  # 监听所有接口的4444端口
    # ...

使用telnet连接到调试会话：telnet localhost 4444

调试常见问题的技巧

1. 调试导入错误

当遇到导入错误时，可以检查模块搜索路径：

1
2
import sys
print(sys.path)

2. 调试异常

使用try-except块捕获并分析异常：

1
2
3
4
5
6
7
8
9
try:
    # 可能引发异常的代码
    result = 10 / 0
except Exception as e:
    import traceback
    print(f"异常类型: {type(e).__name__}")
    print(f"异常信息: {e}")
    print("详细堆栈跟踪:")
    traceback.print_exc()

3. 调试多线程程序

多线程程序的调试可能很复杂，可以使用线程名称和日志来帮助跟踪：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import threading
import logging
import time

logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(threadName)s - %(message)s'
)

def worker(delay, count):
    for i in range(count):
        logging.debug(f"执行任务 {i}")
        time.sleep(delay)

# 创建并启动线程
threads = [
    threading.Thread(target=worker, name=f"Worker-{i}", args=(1, 3))
    for i in range(3)
]

for thread in threads:
    thread.start()

for thread in threads:
    thread.join()

4. 调试内存泄漏

使用objgraph库查找内存泄漏：

1
pip install objgraph
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import objgraph

# 在可能泄漏之前
objgraph.show_most_common_types()

# 创建一些对象
leaky_list = []
for i in range(1000):
    leaky_list.append([1, 2, 3, 4, 5] * 100)

# 在可能泄漏之后
objgraph.show_most_common_types()

# 查找特定类型的对象
objgraph.show_growth()

# 可视化对象引用
objgraph.show_backrefs(leaky_list, filename='backrefs.png')

调试最佳实践

1. 使用版本控制

在调试前确保代码已提交到版本控制系统，这样可以安全地进行修改和实验。

2. 隔离问题

尝试创建一个最小的、可重现问题的示例。这不仅有助于找出根本原因，还便于在需要时寻求帮助。

3. 二分查找法

当不确定问题出在哪里时，可以使用二分查找法：注释掉一半的代码，看问题是否仍然存在，然后逐步缩小范围。

4. 保持代码简洁

简洁的代码更容易调试。遵循KISS原则（Keep It Simple, Stupid）。

5. 编写测试

单元测试和集成测试可以帮助捕获bug，并防止回归。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import unittest

def add(a, b):
    return a + b

class TestAddFunction(unittest.TestCase):
    def test_add_positive_numbers(self):
        self.assertEqual(add(1, 2), 3)
    
    def test_add_negative_numbers(self):
        self.assertEqual(add(-1, -2), -3)
    
    def test_add_mixed_numbers(self):
        self.assertEqual(add(-1, 2), 1)

if __name__ == '__main__':
    unittest.main()

6. 使用断言和契约

在关键点使用断言和契约可以帮助捕获错误：

1
2
3
4
5
6
7
8
9
10
11
12
def process_user_data(user_data):
    # 前置条件
    assert 'name' in user_data, "用户数据必须包含名称"
    assert 'age' in user_data, "用户数据必须包含年龄"
    assert user_data['age'] >= 0, "年龄必须是非负数"
    
    # 处理数据
    result = do_something_with_data(user_data)
    
    # 后置条件
    assert result is not None, "处理结果不能为空"
    return result

7. 使用代码检查工具

静态代码分析工具可以在运行前发现潜在问题：

1
2
3
4
5
# 安装pylint
pip install pylint

# 运行pylint
pylint your_module.py

高级调试场景

1. 调试Django应用

Django提供了调试工具栏和详细的错误页面：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# settings.py
DEBUG = True  # 开发环境中启用调试模式

INSTALLED_APPS = [
    # ...
    'debug_toolbar',  # 添加调试工具栏
]

MIDDLEWARE = [
    # ...
    'debug_toolbar.middleware.DebugToolbarMiddleware',
]

INTERNAL_IPS = [
    '127.0.0.1',  # 允许调试工具栏显示
]

2. 调试Flask应用

Flask内置了调试模式：

1
2
3
4
5
6
7
8
9
10
11
from flask import Flask

app = Flask(__name__)
app.debug = True  # 启用调试模式

@app.route('/')
def index():
    return "Hello, World!"

if __name__ == '__main__':
    app.run(debug=True)  # 也可以在这里启用调试模式

3. 调试API请求

使用requests库的会话和调试钩子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import requests

# 创建一个会话
session = requests.Session()

# 定义调试钩子
def log_request(response, *args, **kwargs):
    print(f"请求URL: {response.request.url}")
    print(f"请求头: {response.request.headers}")
    print(f"请求体: {response.request.body}")
    print(f"响应状态: {response.status_code}")
    print(f"响应头: {response.headers}")
    print(f"响应体: {response.text[:100]}...")  # 只打印前100个字符

# 添加钩子
session.hooks['response'] = [log_request]

# 发送请求
response = session.get('https://api.github.com/users/octocat')

4. 调试并发代码

使用concurrent.futures模块的调试功能：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import concurrent.futures
import logging
import time

logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(threadName)s - %(message)s'
)

def task(n):
    logging.debug(f"开始任务 {n}")
    time.sleep(n)
    if n == 3:
        raise ValueError(f"任务 {n} 失败")
    logging.debug(f"完成任务 {n}")
    return n * n

# 使用线程池执行器
with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
    # 提交任务
    future_to_n = {executor.submit(task, n): n for n in range(1, 6)}
    
    # 处理结果
    for future in concurrent.futures.as_completed(future_to_n):
        n = future_to_n[future]
        try:
            result = future.result()
            logging.debug(f"任务 {n} 结果: {result}")
        except Exception as e:
            logging.error(f"任务 {n} 生成异常: {e}")

结论

调试是软件开发中不可避免的一部分，掌握各种调试技巧可以大大提高开发效率。从简单的print语句到高级的调试工具，每种方法都有其适用场景。

记住，最好的调试策略是预防bug的产生：编写清晰的代码、添加适当的注释、使用类型提示、编写测试用例，以及遵循良好的编程实践。

然而，当bug确实出现时，希望本文介绍的这些技巧能帮助你更快地找到并解决问题。调试可能是一个挑战，但也是提升编程技能的绝佳机会。

你有什么特别喜欢的Python调试技巧吗？欢迎在评论中分享！

  1. Python调试技巧：从print到高级调试工具的完全指南
    1. 基础调试技巧
      1. 1. 使用print语句
      2. 2. 使用断言
      3. 3. 使用日志
    2. 使用Python内置调试器pdb
      1. 1. 基本用法
      2. 2. 常用pdb命令
      3. 3. Python 3.7+中的breakpoint()函数
    3. IDE集成调试
      1. 1. PyCharm调试
      2. 2. VS Code调试
      3. 3. Jupyter Notebook调试
    4. 高级调试技巧
      1. 1. 使用装饰器进行函数调试
      2. 2. 使用上下文管理器计时
      3. 3. 使用tracemalloc跟踪内存分配
      4. 4. 使用cProfile进行性能分析
      5. 5. 使用第三方调试工具
        1. a. ipdb - 增强版pdb
        2. b. pudb - 基于控制台的可视化调试器
        3. c. remote-pdb - 远程调试
    5. 调试常见问题的技巧
      1. 1. 调试导入错误
      2. 2. 调试异常
      3. 3. 调试多线程程序
      4. 4. 调试内存泄漏
    6. 调试最佳实践
      1. 1. 使用版本控制
      2. 2. 隔离问题
      3. 3. 二分查找法
      4. 4. 保持代码简洁
      5. 5. 编写测试
      6. 6. 使用断言和契约
      7. 7. 使用代码检查工具
    7. 高级调试场景
      1. 1. 调试Django应用
      2. 2. 调试Flask应用
      3. 3. 调试API请求
      4. 4. 调试并发代码
    8. 结论
© 2025    Orion K
本站由 提供部署服务
  1. Python调试技巧：从print到高级调试工具的完全指南
    1. 基础调试技巧
      1. 1. 使用print语句
      2. 2. 使用断言
      3. 3. 使用日志
    2. 使用Python内置调试器pdb
      1. 1. 基本用法
      2. 2. 常用pdb命令
      3. 3. Python 3.7+中的breakpoint()函数
    3. IDE集成调试
      1. 1. PyCharm调试
      2. 2. VS Code调试
      3. 3. Jupyter Notebook调试
    4. 高级调试技巧
      1. 1. 使用装饰器进行函数调试
      2. 2. 使用上下文管理器计时
      3. 3. 使用tracemalloc跟踪内存分配
      4. 4. 使用cProfile进行性能分析
      5. 5. 使用第三方调试工具
        1. a. ipdb - 增强版pdb
        2. b. pudb - 基于控制台的可视化调试器
        3. c. remote-pdb - 远程调试
    5. 调试常见问题的技巧
      1. 1. 调试导入错误
      2. 2. 调试异常
      3. 3. 调试多线程程序
      4. 4. 调试内存泄漏
    6. 调试最佳实践
      1. 1. 使用版本控制
      2. 2. 隔离问题
      3. 3. 二分查找法
      4. 4. 保持代码简洁
      5. 5. 编写测试
      6. 6. 使用断言和契约
      7. 7. 使用代码检查工具
    7. 高级调试场景
      1. 1. 调试Django应用
      2. 2. 调试Flask应用
      3. 3. 调试API请求
      4. 4. 调试并发代码
    8. 结论