I love being able to modify the arguments the get sent to a function, using settrace, like :

我喜欢能够修改发送给函数的参数，使用settrace，比如：

import sys

def trace_func(frame,event,arg):
    value = frame.f_locals["a"]
    if value % 2 == 0:
        value += 1
        frame.f_locals["a"] = value

def f(a):
    print a

if __name__ == "__main__":
    sys.settrace(trace_func)
    for i in range(0,5):
        f(i)

And this will print:

这将打印出来：

1
1
3
3
5

What other cool stuff can you do using settrace?

使用settrace还可以做什么其他很酷的事情？

优秀答案推荐

I would strongly recommend against abusing settrace. I'm assuming you understand this stuff, but others coming along later may not. There are a few reasons:

我强烈建议不要滥用settrace。我假设你理解这些东西，但其他后来出现的人可能不会。原因有几个：

1. Settrace is a very blunt tool. The OP's example is a simple one, but there's practically no way to extend it for use in a real system.




2. It's mysterious. Anyone coming to look at your code would be completely stumped why it was doing what it was doing.




3. It's slow. Invoking a Python function for every line of Python executed is going to slow down your program by many multiples.




4. It's usually unnecessary. The original example here could have been accomplished in a few other ways (modify the function, wrap the function in a decorator, call it via another function, etc), any of which would have been better than settrace.




5. It's hard to get right. In the original example, if you had not called f directly, but instead called g which called f, your trace function wouldn't have done its job, because you returned None from the trace function, so it's only invoked once and then forgotten.




6. It will keep other tools from working. This program will not be debuggable (because debuggers use settrace), it will not be traceable, it will not be possible to measure its code coverage, etc. Part of this is due to lack of foresight on the part of the Python implementors: they gave us settrace but no gettrace, so it's difficult to have two trace functions that work together.

Trace functions make for cool hacks. It's fun to be able to abuse it, but please don't use it for real stuff. If I sound hectoring, I apologize, but this has been done in real code, and it's a pain. For example, DecoratorTools uses a trace function to perform the magic feat of making this syntax work in Python 2.3:

跟踪函数有助于进行很酷的黑客攻击。能够滥用它是很有趣的，但请不要把它用于真正的东西。如果我听起来很威吓，我很抱歉，但这是用真正的代码完成的，这是一种痛苦。例如，DecoratorTools使用跟踪函数来执行在Python2.3中使用此语法的神奇壮举：

# Method decorator example
from peak.util.decorators import decorate

class Demo1(object):
    decorate(classmethod)   # equivalent to @classmethod
    def example(cls):
        print "hello from", cls

A neat hack, but unfortunately, it meant that any code that used DecoratorTools wouldn't work with coverage.py (or debuggers, I guess). Not a good tradeoff if you ask me. I changed coverage.py to provide a mode that lets it work with DecoratorTools, but I wish I hadn't had to.

这是一个巧妙的破解，但不幸的是，这意味着任何使用DecoratorTool的代码都不能与overage.py(我猜是调试器)一起工作。如果你问我，这可不是一个好的权衡。我更改了overage.py以提供一种模式，使其可以与DecoratorTool一起工作，但我希望我不必这样做。

Even code in the standard library sometimes gets this stuff wrong. Pyexpat decided to be different than every other extension module, and invoke the trace function as if it were Python code. Too bad they did a bad job of it.

即使是标准库中的代码有时也会出错。Pyexpat决定与其他所有扩展模块不同，并像调用Python代码一样调用跟踪函数。太糟糕了，他们做得不好。

</rant>

I made a module called pycallgraph which generates call graphs using sys.settrace().

我制作了一个名为pyallgraph的模块，它使用sys.settrace()生成调用图。

Of course, code coverage is accomplished with the trace function. One cool thing we haven't had before is branch coverage measurement, and that's coming along nicely, about to be released in an alpha version of coverage.py.

当然，代码覆盖是通过跟踪函数完成的。我们以前没有过的一件很酷的事情是分支覆盖率测量，它进展得很好，即将在Coverage.py的Alpha版本中发布。

So for example, consider this function:

因此，例如，请考虑以下函数：

def foo(x):
    if x:
        y = 10
    return y

if you test it with this call:

如果你用这个调用测试它：

assert foo(1) == 10

then statement coverage will tell you that all the lines of the function were executed. But of course, there's a simple problem in that function: calling it with 0 raises a UnboundLocalError.

然后，语句覆盖率将告诉您函数的所有行都已执行。但当然，该函数中有一个简单的问题：用0调用它会引发UnundLocalError。

Branch measurement would tell you that there's a branch in the code that isn't fully exercised, because only one leg of the branch is ever taken.

分支测量将告诉您，代码中有一个分支没有完全执行，因为只有一个分支被占用。

For example, get the memory consumption of Python code line-by-line: http://pypi.python.org/pypi/memory_profiler

例如，逐行获取PYTHON代码的内存消耗：http://pypi.python.org/pypi/memory_profiler

One latest project that uses settrace heavily is PySnooper

PySnooper是最新的一个大量使用settrace的项目

It helps new programmers to trace/log/monitor their program output. Cheers!

它帮助新程序员跟踪/记录/监控他们的程序输出。干杯!

I don't have an exhaustively comprehensive answer but one thing I did with it, with the help of another user on SO, was create a program that generates the trace tables of other Python programs.

我没有一个详尽而全面的答案，但在SO上的另一个用户的帮助下，我用它做了一件事，就是创建了一个程序来生成其他Python程序的跟踪表。

The python debugger Pdb uses sys.settrace to analyse lines to debug.

Python调试器PDB使用sys.settrace来分析要调试的行。

Here's an c optimization/extension for pdb that also uses sys.settrace

下面是同样使用sys.settrace的pdb的c优化/扩展

https://bitbucket.org/jagguli/cpdb

Https://bitbucket.org/jagguli/cpdb

A really cool project using settrace adds the defer statement from go to the language in a cool way. It allows code like this:

一个使用settrace的很酷的项目以一种很酷的方式将go中的defer语句添加到语言中。它允许这样的代码：

def foo():
  print(", world!") in defer
  print("Hello", end="")
  # do something that might fail...
  assert 1 + 1 == 3

This will output:

这将输出：

$ python foo.py
Hello, World!
Traceback (most recent call last):
  File "foo.py", line 7, in <module>
    assert 1 + 1 == 3
AssertionError

https://github.com/yasyf/python-defer

Https://github.com/yasyf/python-defer