函数inspect.stack()返回一个帧记录列表，从调用者开始，向外移动，您可以使用它来获取所需的信息：

from inspect import getframeinfo, stack

def debuginfo(message):
    caller = getframeinfo(stack()[1][0])
    print("%s:%d - %s" % (caller.filename, caller.lineno, message)) # python3 syntax print

def grr(arg):
    debuginfo(arg)      # <-- stack()[1][0] for this line

grr("aargh")            # <-- stack()[2][0] for this line

输出：

example.py:8 - aargh

如果您将跟踪代码放在另一个函数中，并从主代码调用它，那么您需要确保从祖父级（而不是父级或跟踪函数本身）获取堆栈信息
下面是一个3级深度系统的例子，以进一步阐明我的意思。我的main函数调用了一个跟踪函数，这个跟踪函数又调用了另一个函数来完成这项工作。

######################################

import sys, os, inspect, time
time_start = 0.0                    # initial start time

def trace_libary_init():
    global time_start

    time_start = time.time()      # when the program started

def trace_library_do(relative_frame, msg=""):
    global time_start

    time_now = time.time()

        # relative_frame is 0 for current function (this one), 
        # 1 for direct parent, or 2 for grand parent.. 

    total_stack         = inspect.stack()                   # total complete stack
    total_depth         = len(total_stack)                  # length of total stack
    frameinfo           = total_stack[relative_frame][0]    # info on rel frame
    relative_depth      = total_depth - relative_frame      # length of stack there

        # Information on function at the relative frame number

    func_name           = frameinfo.f_code.co_name
    filename            = os.path.basename(frameinfo.f_code.co_filename)
    line_number         = frameinfo.f_lineno                # of the call
    func_firstlineno    = frameinfo.f_code.co_firstlineno

    fileline            = "%s:%d" % (filename, line_number)
    time_diff           = time_now - time_start

    print("%13.6f %-20s %-24s %s" % (time_diff, fileline, func_name, msg))

################################

def trace_do(msg=""):
    trace_library_do(1, "trace within interface function")
    trace_library_do(2, msg)
    # any common tracing stuff you might want to do...

################################

def main(argc, argv):
    rc=0
    trace_libary_init()
    for i in range(3):
        trace_do("this is at step %i" %i)
        time.sleep((i+1) * 0.1)         # in 1/10's of a second
    return rc

rc=main(sys.argv.__len__(), sys.argv)
sys.exit(rc)

这将打印如下内容：

$ python test.py 
    0.000005 test.py:39           trace_do         trace within interface func
    0.001231 test.py:49           main             this is at step 0
    0.101541 test.py:39           trace_do         trace within interface func
    0.101900 test.py:49           main             this is at step 1
    0.302469 test.py:39           trace_do         trace within interface func
    0.302828 test.py:49           main             this is at step 2

顶部的trace_library_do（）函数是一个例子，您可以将其放入库中，然后从其他跟踪函数调用它。相对深度值控制打印python堆栈中的哪个条目。
我展示了在该函数中提取其他一些有趣的值，如函数开始的行号、总堆栈深度和文件的完整路径。我没有展示它，但函数中的全局和局部变量也可以在inspect中使用，以及对所有其他函数的完整堆栈跟踪。我上面展示的信息已经足够用来进行分层调用/返回时间跟踪了。实际上，从这里开始创建自己的源代码级调试器的主要部分并没有那么远--而且大多数都只是坐在那里等待使用。
我确信有人会反对我使用内部字段和检查结构返回的数据，因为很可能有访问函数为您做同样的事情。但我是通过在python调试器中单步调试这种类型的代码来发现它们的，它们至少在这里可以工作。我运行的是python 2.7.12，如果你运行的是不同的版本，你的结果可能会很糟糕。
在任何情况下，我强烈建议您将inspect代码导入到自己的一些python代码中，并查看它可以为您提供什么-特别是如果您可以在一个好的python调试器中单步执行代码。你将学到很多关于python如何工作的知识，并看到这门语言的好处，以及幕后发生了什么使之成为可能。
使用时间戳进行完整的源代码级跟踪是增强对代码正在做什么的理解的一种很好的方法，特别是在动态真实的环境中。这种类型的跟踪代码的优点在于，一旦编写好，您不需要调试器支持就可以看到它。

使用字符串插值并显示调用方的函数名来更新已接受的答案。

import inspect
def debuginfo(message):
    caller = inspect.getframeinfo(inspect.stack()[1][0])
    print(f"{caller.filename}:{caller.function}:{caller.lineno} - {message}")

traceprint包现在可以为您做到这一点：

import traceprint

def func():
    print(f'Hello from func')

func()

#   File "/traceprint/examples/example.py", line 6, in <module>
#   File "/traceprint/examples/example.py", line 4, in func
# Hello from func

PyCharm将自动使文件链接可点击/可跟踪。
通过pip install traceprint安装。

只要把你发布的代码放到一个函数中：

from inspect import currentframe, getframeinfo

def my_custom_debuginfo(message):
    print getframeinfo(currentframe()).filename + ':' + str(getframeinfo(currentframe()).lineno) + ' - ', message

然后按你想要的方式使用它：

# ... some code here ...
my_custom_debuginfo('what I actually want to print out here')
# ... more code ...

我建议你把这个函数放在一个单独的模块中，这样你就可以在每次需要的时候重用它。

发现这个问题有点相关的问题，但我想更多的细节re：执行（我不想安装整个调用图包）。
如果需要更详细的信息，可以使用标准库模块traceback检索完整的回溯，并使用traceback.extract_stack()存储堆栈对象（元组列表），或者使用traceback.print_stack()打印它。这个比较适合我的需要，希望对别人有帮助！

您可以使用logging模块中内置的python findCaller findCaller函数，并将stacklevel argument 设置为2。
E.x.：

import logging

def get_caller_info():
    file_name, line_no, func_name, stack_info = logging.root.findCaller(stacklevel=2)
    print(f"{dict(file_name=file_name,line_no=line_no,func_name=func_name,stack_info=stack_info,)}")

if __name__ == "__main__":
    get_caller_info()

将输出
'file_name'：'C：\code\test_caller_info. py'，'line_no'：9，'func_name'：''，'stack_info'：无}