下面的方法将不会返回变量的名称，但如果变量在全局作用域可用，则使用此方法可以轻松创建数据帧。

class CustomDict(dict):
    def __add__(self, other):
        return CustomDict({**self, **other})

class GlobalBase(type):
    def __getattr__(cls, key):
        return CustomDict({key: globals()[key]})

    def __getitem__(cls, keys):
        return CustomDict({key: globals()[key] for key in keys})

class G(metaclass=GlobalBase):
    pass

x, y, z = 0, 1, 2

print('method 1:', G['x', 'y', 'z']) # Outcome: method 1: {'x': 0, 'y': 1, 'z': 2}
print('method 2:', G.x + G.y + G.z) # Outcome: method 2: {'x': 0, 'y': 1, 'z': 2}

A = [0, 1]
B = [1, 2]
pd.DataFrame(G.A + G.B) # It will return a data frame with A and B columns

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

在Python 3.8中，可以简单地使用f-string调试特性:

>>> foo = dict()
>>> f'{foo=}'.split('=')[0]
'foo' 

这种方法的一个缺点是，为了打印'foo'，你必须自己添加f'{foo=}'。换句话说，你已经知道变量的名字了。换句话说，上面的代码片段与刚才完全相同

>>> 'foo'

iDilip的答案压缩版:

import inspect
def varname(x):
  return [k for k,v in inspect.currentframe().f_back.f_locals.items() if v is x][0]

hi = 123
print(varname(hi))

>>> 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']]

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

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

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

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

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

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

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