在Python中，def和class关键字将特定的名称绑定到它们定义的对象(函数或类)。类似地，模块通过在文件系统中调用某个特定的名称来命名。在这三种情况下，都有一种明显的方法可以将“规范”名称分配给有问题的对象。

然而，对于其他类型的对象，这样的规范名称可能根本不存在。例如，考虑列表中的元素。列表中的元素不是单独命名的，在程序中引用它们的唯一方法完全可能是在包含它们的列表上使用列表索引。如果将这样一个对象列表传递到函数中，则不可能为值分配有意义的标识符。

Python不会将赋值对象左边的名称保存到赋值对象中，因为:

这需要在多个冲突的对象中找出哪个名称是“规范的”， 对于那些从未赋值给显式变量名的对象来说，这是没有意义的， 这样效率会非常低， 实际上没有其他现存的语言能做到这一点。

例如，使用lambda定义的函数将始终具有"name" <lambda>，而不是特定的函数名。

最好的方法是简单地要求调用者传入一个(可选的)名称列表。如果输入“…”，“…”'太麻烦了，你可以接受一个包含逗号分隔的名字列表的字符串(像namedtuple那样)。

>>> locals()['foo']
{}
>>> globals()['foo']
{}

如果你想写你自己的函数，你可以这样做，你可以检查一个局部变量定义，然后检查全局变量。如果没有找到，可以比较id()，看看变量是否指向内存中的相同位置。

如果你的变量在一个类中，你可以使用className.dict.keys()或vars(self)来查看你的变量是否已经被定义。

>>> def varname(v, scope=None):
        d = globals() if not scope else vars(scope); return [k for k in d if d[k] == v]
...
>>> d1 = {'a': 'ape'}; d2 = {'b': 'bear'}; d3 = {'c': 'cat'}
>>> ld = [d1, d2, d3]
>>> [varname(d) for d in ld]
[['d1'], ['d2'], ['d3']]
>>> d5 = d3
>>> [varname(d) for d in ld]
[['d1'], ['d2'], ['d3', 'd5']]
>>> def varname(v, scope=None):
        d = globals() if not scope else vars(scope); return [k for k in d if d[k] is v]
...
>>> [varname(d) for d in ld]
[['d1'], ['d2'], ['d3', 'd5']]

正如您在这里看到和注意到的，可以有多个具有相同值甚至地址的变量，因此使用包装器将名称与数据保存在一起是最好的。

这里有一种方法。我不建议在任何重要的事情上使用它，因为它会很脆。但这是可以做到的。

创建一个使用inspect模块查找调用它的源代码的函数。然后可以解析源代码，以识别想要检索的变量名。例如，这里有一个名为autodict的函数，它接受一个变量列表，并返回一个将变量名映射到变量值的字典。例如:

x = 'foo'
y = 'bar'
d = autodict(x, y)
print d

将:

{'x': 'foo', 'y': 'bar'}

检查源代码本身比搜索locals()或globals()更好，因为后一种方法不会告诉您哪些变量是您想要的。

无论如何，代码如下:

def autodict(*args):
    get_rid_of = ['autodict(', ',', ')', '\n']
    calling_code = inspect.getouterframes(inspect.currentframe())[1][4][0]
    calling_code = calling_code[calling_code.index('autodict'):]
    for garbage in get_rid_of:
        calling_code = calling_code.replace(garbage, '')
    var_names, var_values = calling_code.split(), args
    dyn_dict = {var_name: var_value for var_name, var_value in
                zip(var_names, var_values)}
    return dyn_dict

该动作发生在inspect的行中。Getouterframes，它返回调用autodict的代码中的字符串。

这种魔法的明显缺点是，它对源代码的结构做出了假设。当然，如果它在解释器内部运行，它根本就不起作用。

您可以尝试以下方法来检索您定义的函数的名称(但不适用于内置函数):

import re
def retrieve_name(func):
    return re.match("<function\s+(\w+)\s+at.*", str(func)).group(1)

def foo(x):
    return x**2

print(retrieve_name(foo))
# foo

即使变量值不指向名称，您也可以访问每个赋值变量及其值的列表，所以我很惊讶，只有一个人建议在那里循环查找您的var名称。

有人在回答中提到，你可能需要遍历堆栈并检查每个人的局部变量和全局变量来找到foo，但如果foo被赋值在你调用retrieve_name函数的作用域内，你可以使用inspect的当前帧来获取所有这些局部变量。

我的解释可能有点太啰嗦了(也许我应该用“foo”更少的单词)，但下面是它在代码中的样子(注意，如果有多个变量赋给相同的值，你会得到两个变量名):

import inspect

x, y, z = 1, 2, 3

def retrieve_name(var):
    callers_local_vars = inspect.currentframe().f_back.f_locals.items()
    return [var_name for var_name, var_val in callers_local_vars if var_val is var]

print(retrieve_name(y))

如果你从另一个函数调用这个函数，就像这样:

def foo(bar):
    return retrieve_name(bar)

foo(baz)

如果你想要baz而不是bar，你只需要再往后退一步。这可以通过在caller_local_vars初始化中添加额外的.f_back来实现。

请看一个例子:ideone