我知道 sys.exc_info文档说在处理回溯对象时要小心，但我仍然不确定某些情况下的安全性或不安全性。此外，文档说“警告:不要这样做!”，紧接着是“注意:实际上，没问题”，这让我更加困惑。

在任何情况下，文档和“Why is there a need to explicitly delete the sys.exc_info() traceback in Python?”(Alex Martelli 的回答)似乎都暗示其唯一引用分配给它们的回溯值的局部变量会导致问题。

这留给我几个问题:

1. 在这种情况下，“局部变量”到底是什么意思？我正在为术语而苦苦挣扎，但是:这是否意味着仅在函数中创建的变量，或者也由函数参数创建的变量？范围内的其他变量如何，例如全局变量或自身变量？
2. 闭包如何影响回溯的潜在循环引用？一般的想法是:闭包可以引用其封闭函数可以引用的所有内容，因此引用闭包的回溯最终可能会引用很多。我正在努力想出一个更具体的例子，但是一些组合:一个内部函数，返回 sys.exc_info() 的代码，在某处范围内具有昂贵的短暂对象。

请随时告诉我我的结论或假设哪里错了，因为在我写这篇文章时，我已经多次说服自己相信和不相信我自己的陈述:)。

虽然我想要我的具体示例的答案，但我也希望获得关于如何在更深奥的情况下安全处理回溯的一般建议、知识或 war 故事(例如，你必须运行一个循环并想要要累积任何引发的异常，您必须生成一个新线程并需要报告其引发的任何异常，您必须创建闭包和回调并且必须返回引发的异常等)。

示例 1:执行错误处理的内部函数

def DoWebRequest():
  thread, error_queue = CreateThread(ErrorRaisingFunc)
  thread.start()
  thread.join()
  if not error_queue.empty():
    # Purposefully not calling error_queue.get() for illustrative purposes
    print 'error!'

def CreateThread(func):
  error_queue = Queue.Queue()
  def Handled():
    try:
      func()
    except Exception:
      error_queue.put(sys.exc_info())
  thread = threading.Thread(target=Handled)
  return thread, error_queue

Handled() 闭包是否会导致引用 error_queue 的任何引发异常并导致循环引用，因为 error_queue 也包含回溯？从 error_queue 中删除回溯(即调用 .get())是否足以消除循环引用？

示例 2:exc_info 范围内的长期对象，或返回 exc_info

long_lived_cache = {}

def Alpha(key):
  expensive_object = long_lived_cache.get(key)
  if not expensive_object:
    expensive_object = ComputeExpensiveObject()
    long_lived_cache[key] = expensive_object

  exc_info = AlphaSub(expensive_object)
  if exc_info:
    print 'error!', exc_info

def AlphaSub(expensive_object):
  try:
    ErrorRaisingFunc(expensive_object)
    return None
  except Exception:
    return sys.exc_info()

AlphaSub() 引发的异常是否有对 expensive_object 的引用，并且，因为 expensive_object 被缓存，回溯永远不会消失？如果是这样，如何打破这样的循环？

或者，exc_info 包含Alpha 堆栈帧，Alpha 堆栈帧包含对exc_info 的引用，导致循环引用。如果是这样，如何打破这样的循环？

最佳答案

What, exactly, does "local variable" mean in this context? I'm struggling for terminology, but: does this mean only variables created in the function, or also variable created by the function parameters? What about other variables in scope, e.g, globals or self?

“局部变量”都是在函数内部创建的名称绑定(bind)。这包括任何函数参数和分配的任何变量。例如。在以下内容中:

def func(fruwappah, qitzy=None):
    if fruwappah:
        fruit_cake = 'plain'
    else:
        fruit_cake = qitzy
    frosting = 'orange'

变量 fruwappah、qitzy、fruit_cake 和 frosting 都是本地变量。哦，因为 self 在函数头中(如果它在，只是不在我的示例中；)，它也是本地的。

How do closures affect the potential circular references of the traceback? The general thought being: a closure can reference everything its enclosing function can, so a traceback with a reference to a closure can end up referencing quite a bit. I'm struggling to come up with a more concrete example, but some combination of: an inner function, code that returns sys.exc_info(), with expensive-short-lived-objects in scope somewhere.

作为您链接到状态的答案:回溯引用在异常发生时 处于事件状态的每个 函数(及其变量)。换句话说，是否涉及闭包是无关紧要的——分配给一个闭包(非本地)，或者就此而言，一个全局变量将创建一个循环引用。

有两种基本方法可以解决这个问题:

1. 定义一个将在异常出现后调用的函数——它不会在回溯中有堆栈帧，所以当它结束它的所有变量——包括回溯——会消失；或
2. 确保 del traceback_object 完成后。

说了这么多，我还需要在我自己的代码中使用回溯对象——Exception 及其各种属性到目前为止已经足够了。

关于python - 处理来自 sys.exc_info() 的回溯对象时的适当注意和安全，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/7375492/