一、traceback 是什么？

traceback 是 Python 标准库，用来获取当前代码的调用栈信息。

1. 它能回答三个关键问题：

1. 代码是从哪里一路走到这里的？
2. 每一层在哪个文件、哪一行？
3. 当前在什么线程 / 上下文？

二、什么时候用 traceback？

典型工程场景

场景	推荐程度
代码抛异常	1
方法被“莫名其妙”调用	3
框架自动行为	3
多线程 debug	3
finally / cleanup 行为	3
monkey patch 验证	2

只要你疑惑：“这东西到底是谁调的？” 直接 traceback

三、traceback 最常用的 4 个 API（重点）

1. traceback.format_stack()

查“是谁调用我”最推荐

作用：

• 获取当前调用栈
• 不依赖异常
• 返回 字符串列表

# demo_format_stack.py
import traceback

def kill_adb():
    stack = traceback.format_stack()
    print("".join(stack))

def cleanup():
    kill_adb()

def run_case():
    cleanup()

run_case()

输出预览（简化）

  File "demo_format_stack.py", line 16, in <module>
    run_case()
  File "demo_format_stack.py", line 13, in run_case
    cleanup()
  File "demo_format_stack.py", line 10, in cleanup
    kill_adb()
  File "demo_format_stack.py", line 6, in kill_adb
    stack = traceback.format_stack()

怎么看（重点）
从上往下看 = 调用顺序

run_case()
 ↓
cleanup()
 ↓
kill_adb()   ← 当前函数

最后一行：当前所在位置
倒数第二行：谁直接调用了我（cleanup）
倒数第三行：再上一层调用者（run_case）

2. traceback.print_stack()

快速看栈，不关心返回值

# demo_print_stack.py
import traceback

def foo():
    bar()

def bar():
    traceback.print_stack()

foo()

输出预览

  File "demo_print_stack.py", line 10, in <module>
    foo()
  File "demo_print_stack.py", line 6, in foo
    bar()
  File "demo_print_stack.py", line 9, in bar
    traceback.print_stack()

实际输出可能更长，这里是最关键的部分

怎么看（重点）

1. 从上往下看 = 调用顺序

   foo()
    ↓
   bar()
    ↓
   print_stack()   ← 当前
   

2. 只看最后 2～3 行就够

   File "demo_print_stack.py", line 6, in foo     ← 谁调用了 bar
   File "demo_print_stack.py", line 9, in bar     ← 当前函数
   

3. 什么时候用它？
   临时 debug
   本地跑一下看调用路径
   不适合线上（不能控制格式）

3. traceback.format_exc()

异常发生时，用它

# demo_format_exc.py
import traceback

def div():
    return 1 / 0

def run():
    div()

try:
    run()
except Exception:
    print("---- 捕获到异常 ----")
    print(traceback.format_exc())

输出预览

---- 捕获到异常 ----
Traceback (most recent call last):
  File "demo_format_exc.py", line 11, in <module>
    run()
  File "demo_format_exc.py", line 8, in run
    div()
  File "demo_format_exc.py", line 5, in div
    return 1 / 0
ZeroDivisionError: division by zero

输出内容拆解

1. 异常调用栈（从上往下）

   run()
    ↓
   div()
    ↓
   1 / 0   ← 出错位置
   

2. 真正的异常点在哪？
   倒数第二个 File

   File "demo_format_exc.py", line 5, in div
       return 1 / 0
   

3. 异常类型 & 信息（最后一行）

   ZeroDivisionError: division by zero
   

   异常类型：ZeroDivisionError
   异常信息：division by zero

怎么看（重点）
记住这 3 步

1. 先看最后一行 → 什么异常
2. 再看倒数第二个 File → 出错代码
3. 再往上看 → 谁一路调用到这里

正确的工程用法（强烈推荐）
不推荐（信息丢失）

except Exception as e:
    logger.error(e)

推荐（完整上下文）

except Exception:
    import traceback
    logger.error("发生异常：\n%s", traceback.format_exc()

4. traceback.extract_stack()

结构化调用栈（进阶）

作用:

1. 获取当前调用栈
2. 返回的是 结构化对象（而不是字符串）
3. 方便程序分析 / 二次处理

示例代码

# demo_extract_stack.py
import traceback

def c():
    stack = traceback.extract_stack()
    for frame in stack:
        print(frame.filename, frame.lineno, frame.name)

def b():
    c()

def a():
    b()

a()

输出预览（示意）

demo_extract_stack.py 17 <module>
demo_extract_stack.py 14 a
demo_extract_stack.py 11 b
demo_extract_stack.py 6 c

怎么看（重点）
每一行 = 一层调用栈

文件名  行号  函数名
对应关系：

text
a()
 ↓
b()
 ↓
c()   ← 当前函数

最后一行永远是当前函数
倒数第二行是直接调用者

四、工程中最常用的“模板写法”（建议收藏）

模板 1：定位“谁调用了我”

def debug_who_call_me(tag=""):
    import traceback
    return f"\n[{tag}] 调用栈：\n{''.join(traceback.format_stack())}"
def kill_adb():
    pass

使用：

logger.info(debug_who_call_me("kill_adb"))

模板 2：只在 debug 时打印（不污染日志）

import os
import traceback

def print_debug_stack_if_needed():
    """
    如果环境变量 DEBUG_STACK=1，则打印调用栈
    """
    if os.getenv("DEBUG_STACK") == "1":
        print(f"调用栈:\n{''.join(traceback.format_stack())}")

模板 3：多线程定位神器

import threading
import traceback

logger.info(
    "线程=%s\n调用栈:\n%s",
    threading.current_thread().name,
    "".join(traceback.format_stack())
)

五、如何“正确阅读” traceback（重点）

1. 记住这条规则（非常重要）

traceback 是：
从“入口” → 一路调用 → 到“当前位置”

2. 实战读法

threading.run
 └─ CaseRunner.__main_test_thread
    └─ TestCaseBase.__call_cleanup
       └─ kill_adb   ← 当前

从上往下是调用顺序
越靠近底部，越接近当前函数

六、traceback 使用注意事项（踩坑总结）

1. 不要常驻生产日志

栈信息非常长
影响性能 & 日志体积
用 debug / 临时开关

2. 注意双下划线方法

__call_cleanup

在栈里你看到的是真实名字，
但 override（方法重写） 时要注意 name mangling

name mangling 是 Python 在“类创建时”，
自动把以 __ 开头、且不以 __ 结尾的属性名，
改写成 _类名__属性名 的机制。

比如你在栈里看到：

TestCaseBase.__call_cleanup

你可能会以为：

class MyCase(TestCaseBase):
    def __call_cleanup(self):

就能 override（方法重写） 它 ，但这是错的 。

原始代码

class TestCaseBase:
    def __call_cleanup(self):
        print("base cleanup")

Python 在“类创建时”偷偷做了这件事：

# 实际等价于（概念示意）
class TestCaseBase:
    def _TestCaseBase__call_cleanup(self):
        print("base cleanup")

方法名被改成了：_TestCaseBase__call_cleanup
这就是 name mangling

为什么这样设计
为了 防止子类“不小心”覆盖父类的内部方法

本意是“保护内部实现”
但对 override（方法重写） 来说非常坑

七、总结

traceback 是 定位调用关系的利器
format_stack() 是查“谁调用我”的首选
多线程 / 框架 / finally 场景，断点不可靠
调用栈 = 事实