我如何打印被调用的函数

69

在调试Python脚本时，我真的很想知道整个程序的整个调用堆栈。理想的情况是，如果有一个用于python的命令行标志，它将导致Python在调用它们时打印所有函数名（我检查了man Python2.7，但是没有找到这种类型的东西）。

由于此脚本中函数的数量众多，因此，我尽量不要在每个函数和/或类的开头添加打印语句。

一个中间的解决方案是使用PyDev的调试器，放置几个断点并检查程序中给定点的调用堆栈，因此我暂时将使用这种方法。

如果存在这样的方法，我仍然希望查看程序整个生命周期内调用的所有函数的完整列表。

python  callstack 
— 詹姆士
source
2
探查器告诉您所有称为docs.python.org/library/profile.html的函数，但不完全是您所要求的功能-这样就足够了吗？
— mmmmmm

Answers:

107

您可以使用跟踪函数来执行此操作（Spacedman的道具可以改进此函数的原始版本以跟踪返回并使用一些不错的缩进）：

def tracefunc(frame, event, arg, indent=[0]):
      if event == "call":
          indent[0] += 2
          print("-" * indent[0] + "> call function", frame.f_code.co_name)
      elif event == "return":
          print("<" + "-" * indent[0], "exit function", frame.f_code.co_name)
          indent[0] -= 2
      return tracefunc

import sys
sys.setprofile(tracefunc)

main()   # or whatever kicks off your script

请注意，函数的代码对象通常与关联的函数具有相同的名称，但并非总是如此，因为可以动态创建函数。不幸的是，Python没有跟踪堆栈上的函数对象（我有时幻想着为此提交一个补丁）。不过，在大多数情况下，这当然“足够好”。

如果这成为问题，则可以从源代码中提取“真实的”函数名（Python会跟踪文件名和行号），或者让垃圾回收器找出哪个函数对象引用了代码对象。可能有一个以上的函数共享代码对象，但是它们的任何名称可能都足够好。

回到四年之后，我应该提到在Python 2.6及更高版本中，使用sys.setprofile()而不是可以获得更好的性能sys.settrace()。可以使用相同的跟踪功能。只是仅当函数进入或退出时才调用profile函数，因此函数内部的内容将全速执行。

— 金德尔
source
当然，越多越好:-)
— kindall
5
这太棒了。我最终添加os.path.basename(frame.f_code.co_filename)到此跟踪函数中，以打印包含所调用函数的文件。
— 詹姆斯
1
有没有什么快速的方法可以使它变得更简单，只打印对我在代码中定义的函数的调用，而不是对Python内部所有函数的打印？至少在Python 3.4中（不尝试2.7），日志中充满了对的调用notify，__getattr__等等……
— Dirk
1
你可以检查一下frame.f_code.co_filename。这应该是包含该功能的文件的完整路径。检查路径是否包含Python后跟lib，如果可能的话，不要打印任何内容……
— kindall
1
@Dirk：似乎您可以简单地frame.f_code.co_filename用来检查该函数是否在您的一个（或多个）源文件中，而忽略它，而不是检查它是否在Python内部。
— martineau
15

另一个要注意的好工具是跟踪模块。有3个显示函数名称的选项。

范例foo.py：

def foo():
   bar()

def bar():
   print("in bar!")

foo()
  1. 使用-l/--listfuncs到列表funtions：
$ python -m trace --listfuncs foo.py
in bar!

functions called:
filename: /System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/trace.py, modulename: trace, funcname: _unsettrace
filename: foo.py, modulename: foo, funcname: <module>
filename: foo.py, modulename: foo, funcname: bar
filename: foo.py, modulename: foo, funcname: foo
  1. 使用-t/--trace到表行，因为他们被执行。
$python -m trace --trace foo.py
 --- modulename: foo, funcname: <module>
foo.py(1): def foo():
foo.py(4): def bar():
foo.py(7): foo()
 --- modulename: foo, funcname: foo
foo.py(2):    bar()
 --- modulename: foo, funcname: bar
foo.py(5):    print("in bar!")
in bar!
  1. 使用-T/--trackcalls到列表什么叫什么
$ python -m trace --trackcalls foo.py
in bar!

calling relationships:

*** /usr/lib/python3.8/trace.py ***
  --> foo.py
    trace.Trace.runctx -> foo.<module>

*** foo.py ***
    foo.<module> -> foo.foo
    foo.foo -> foo.bar
— 大卫·沃尔沃
source
1
trace有用，但是我找不到如何产生OP请求的输出：-l只显示每个函数一次，-t显示每一行。
— 西罗Santilli郝海东冠状病六四事件法轮功
7

有一些选择。如果一个调试器是不够的，你可以设置一个跟踪功能使用sys.settrace()。本质上，该函数将在执行的每一行Python代码上调用，但是很容易识别函数调用-请参阅链接的文档。

您可能也对该trace模块感兴趣，尽管它并不能完全满足您的要求。请务必查看该--trackcalls选项。

— 斯文·马纳赫（Sven Marnach）
source
是的，sys.settrace()与@kindall上面建议的trace函数一起使用时，就像一个魅力。:)该trace模块看起来也非常有用……我会在以后的调试项目中牢记这一点。
— 詹姆斯
5 
import traceback
def foo():
    traceback.print_stack()
def bar():
    foo()
def car():
    bar():

car()
File "<string>", line 1, in <module>
File "C:\Python27\lib\idlelib\run.py", line 97, in main
  ret = method(*args, **kwargs)
File "C:\Python27\lib\idlelib\run.py", line 298, in runcode
    exec code in self.locals
File "<pyshell#494>", line 1, in <module>
File "<pyshell#493>", line 2, in car
File "<pyshell#490>", line 2, in bar
File "<pyshell#486>", line 2, in foo

追溯

— 阿比吉特
source
1
这只是OP使用调试器和断点所做的操作的一种较不方便且较不灵活的方式。
— Sven Marnach
4

我接受了kindall的回答并以此为基础。

import sys


WHITE_LIST = ['trade']      # Look for these words in the file path.
EXCLUSIONS = ['<']          # Ignore <listcomp>, etc. in the function name.


def tracefunc(frame, event, arg):

    if event == "call":
        tracefunc.stack_level += 1

        unique_id = frame.f_code.co_filename+str(frame.f_lineno)
        if unique_id in tracefunc.memorized:
            return

        # Part of filename MUST be in white list.
        if any(x in frame.f_code.co_filename for x in WHITE_LIST) \
            and \
          not any(x in frame.f_code.co_name for x in EXCLUSIONS):

            if 'self' in frame.f_locals:
                class_name = frame.f_locals['self'].__class__.__name__
                func_name = class_name + '.' + frame.f_code.co_name
            else:
                func_name = frame.f_code.co_name

            func_name = '{name:->{indent}s}()'.format(
                    indent=tracefunc.stack_level*2, name=func_name)
            txt = '{: <40} # {}, {}'.format(
                    func_name, frame.f_code.co_filename, frame.f_lineno)
            print(txt)

            tracefunc.memorized.add(unique_id)

    elif event == "return":
        tracefunc.stack_level -= 1


tracefunc.memorized = set()
tracefunc.stack_level = 0


sys.setprofile(traceit.tracefunc)

样本输出：

API.getFills()                           # C:\Python37-32\lib\site-packages\helpers\trade\tws3.py, 331
API._get_req_id()                        # C:\Python37-32\lib\site-packages\helpers\trade\tws3.py, 1053
API._wait_till_done()                    # C:\Python37-32\lib\site-packages\helpers\trade\tws3.py, 1026
---API.execDetails()                     # C:\Python37-32\lib\site-packages\helpers\trade\tws3.py, 1187
-------Fill.__init__()                   # C:\Python37-32\lib\site-packages\helpers\trade\mdb.py, 256
--------Price.__init__()                 # C:\Python37-32\lib\site-packages\helpers\trade\mdb.py, 237
-deserialize_order_ref()                 # C:\Python37-32\lib\site-packages\helpers\trade\mdb.py, 644
--------------------Port()               # C:\Python37-32\lib\site-packages\helpers\trade\mdb.py, 647
API.commissionReport()                   # C:\Python37-32\lib\site-packages\helpers\trade\tws3.py, 1118

特征：

  • 忽略Python语言内部功能。
  • 忽略重复的函数调用（可选）。
  • 使用sys.setprofile（）而不是sys.settrace（）来提高速度。
— 柴姆
source
在每次打印函数之前，我都会得到15行破折号
— jimscafe
什么是追踪？它没有定义也不是一个模块
— 控制论
4

该hunter工具可以做到这一点，甚至更多。例如，给定：

test.py：

def foo(x):
    print(f'foo({x})')

def bar(x):
    foo(x)

bar()

输出如下：

$ PYTHONHUNTER='module="__main__"' python test.py
                                 test.py:1     call      => <module>()
                                 test.py:1     line         def foo(x):
                                 test.py:4     line         def bar(x):
                                 test.py:7     line         bar('abc')
                                 test.py:4     call         => bar(x='abc')
                                 test.py:5     line            foo(x)
                                 test.py:1     call            => foo(x='abc')
                                 test.py:2     line               print(f'foo({x})')
foo(abc)
                                 test.py:2     return          <= foo: None
                                 test.py:5     return       <= bar: None
                                 test.py:7     return    <= <module>: None

它还提供了一种非常灵活的查询语法，该语法允许指定模块，文件/行号，函数等，这很有帮助，因为默认输出（包括标准库函数调用）可能很大。

— 克里斯·亨特
source
2

您可以使用settrace，如下所示：跟踪python代码。使用页面末尾附近的版本。我将该页面的代码粘贴到我的代码中，以确切查看我的代码运行时执行了哪些行。您还可以进行筛选，以便仅查看所调用函数的名称。

— 耶根
source
1

您还可以将修饰符用于要跟踪的特定功能（及其参数）：

import sys
from functools import wraps

class TraceCalls(object):
    """ Use as a decorator on functions that should be traced. Several
        functions can be decorated - they will all be indented according
        to their call depth.
    """
    def __init__(self, stream=sys.stdout, indent_step=2, show_ret=False):
        self.stream = stream
        self.indent_step = indent_step
        self.show_ret = show_ret

        # This is a class attribute since we want to share the indentation
        # level between different traced functions, in case they call
        # each other.
        TraceCalls.cur_indent = 0

    def __call__(self, fn):
        @wraps(fn)
        def wrapper(*args, **kwargs):
            indent = ' ' * TraceCalls.cur_indent
            argstr = ', '.join(
                [repr(a) for a in args] +
                ["%s=%s" % (a, repr(b)) for a, b in kwargs.items()])
            self.stream.write('%s%s(%s)\n' % (indent, fn.__name__, argstr))

            TraceCalls.cur_indent += self.indent_step
            ret = fn(*args, **kwargs)
            TraceCalls.cur_indent -= self.indent_step

            if self.show_ret:
                self.stream.write('%s--> %s\n' % (indent, ret))
            return ret
        return wrapper

只需导入此文件，然后在要跟踪的函数/方法之前添加一个@TraceCalls（）。

— 文森特·费内特
source
我喜欢您的回答，但认为可以通过使用带有可选参数配方的创建装饰器来改进它，这将使它使用的更加“传统”：即@TraceCalls代替@TraceCalls()。同样，出于相同的原因，我建议将类名全部小写（即使从技术上讲，它不会遵循PEP 8指南），以允许将其用作@tracecalls。
— martineau
1

改变kindall的答案，只返回包中的被调用函数。

def tracefunc(frame, event, arg, indent=[0]):
    package_name = __name__.split('.')[0]

    if event == "call" and (package_name in str(frame)):
        indent[0] += 2
        print("-" * indent[0] + "> call function", frame.f_code.co_name)
    return tracefunc

import sys
sys.settrace(tracefunc)

例如，在名为的程序包中Dog，这仅应向您显示该Dog程序包中定义的被调用的函数。

— 对象名称显示
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.