Python-通过回溯获取调用模块的路径，有问题吗？

Question

In python, I often find myself loading package resources through calls such as the following:

import os
fp = open(os.path.join(os.path.dirname(os.path.realpath(__file__)),
                       "resource.json"), "r")

I've been considering using a library function such as the following to eliminate this ugliness. The issue is that the function would live in a library, not the file that I want to get the directory of. I can get around this with the traceback package, such as with the following:

import os, traceback
def with_module_directory(filename):
    return os.path.join(os.path.dirname(traceback.extract_stack()[-2][0]),
                        filename)

Now if with_module_directory() lives in /home/user1/mylibs/utils.py , when a module in /home/user1/myscripts makes the call with_module_directory("resource.json") , the result will be "/home/user1/myscripts/resource.json" , as desired.

I'm worried however that doing this is in some way dangerous. Manually looking at the stack trace feels like a generally bad thing, like I'm breaking encapsulation. But I can't think of any concrete issues, so I pose the question: Can anyone think of a problem that could be created by doing this? Is it bad practice for any specific reason?

Note: I realize I could just force the user to make a call like with_module_path("resource.json", __file__) , but if there's no actual reason to avoid the simpler interface then I'd prefer to use it.

Answer 1

To find the location of a module, function, or class, use the inspect module:

import inspect
print(inspect.getsourcefile(some_module))

You can use this to find the location of the code units you are interested in. If you put this in a library, just wrap it in a function that takes an argument.

Actually you could do the same with __file__ , if necessary: Just pass it as the argument to a function that will do the rest.