将变量名作为字符串获取

def Retriever(bar):
    return (list(globals().keys()))[list(map(lambda x: id(x), list(globals().values()))).index(id(bar))]

该函数遍历全局作用域中值的ID列表（可编辑命名空间），根据其ID查找所需变量或函数的索引，然后基于获取的索引从全局名称列表中返回名称。

var=2
def getVarName(**kwargs):
    return list(kwargs.keys())[0]

print (getVarName(var = var))

如果有两个变量具有相同的值，之前的一些情况可能会失败。因此，提醒一下是很方便的：

定义函数：

# Variable to string of variable name

def var_name(variable,i=0):

  results = []
  for name in globals():   
     if eval(name) == variable:
       results.append(name)

  if len(results) > 1:
    print('Warning:' )
    print('   var_name() has found',len(results), 'possible outcomes.')
    print('   Please choose the suitable parameter "i". Where "i" is the index')
    print('   that matches your choice from the list below.')
    print('  ',results) ; print('')

  return results[i]

使用：

var_1 = 10
var_name(var_1) # Output will be "var_1"

var_1 = 8
var_2 = 8
var_name(var_2)  # Output will be "var_1" too but Warning will appear

但是，大多数对象都没有这样的属性。

换句话说，如果我有一个变量，例如：

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

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

只要实例变量是类的属性，就完全可以获取其名称。

我从Brett Slatkin的《Effective Python》中得到了这个方法。希望能帮助到大家：

该类必须实现“描述符协议”的get、set和set_name方法。

当我运行它时，它起作用了：

class FieldThatKnowsItsName():
    def __init__(self):
        self.name = None
        self._value= None
        self.owner = None
 
    def __set_name__(self, owner, name):
        self.name = name
        self.owner = owner
        self.owner.fields[self.name] = self

    def __get__(self, instance, instance_type):
        return self

    def __set__(self, instance, value):
        self = value

class SuperTable:
    fields = {}
    field_1=FieldThatKnowsItsName()
    field_2=FieldThatKnowsItsName()

table = SuperTable()
print(table.field_1.name)
print(table.field_2.name)

然后，您可以根据需要添加方法或扩展数据类型。

作为奖励，set_name(self, owner, name) dunder 还会传递父实例，因此 Field 类实例可以向父级注册自己。

我从 Brett Slatkin 的《Effective Python》中学到了这个。花了一些时间才弄明白如何实现。

keys1 = set(globals().keys())
a = 1
b = 1 
c = 2
d = (a,b)
keys2 = set(globals().keys())
vals = [a,b,c,d]
new_keys = [ key for key in new_keys if globals()[key] in vals]
new_keys = keys2.difference(keys1)
new_keys = [ key for key in new_keys if globals()[key] in vals]
print(new_keys)
myg = globals()
for key in new_keys:
    myg[key] = (val,key) # now the variable points also to the key
for key in new_keys:
    myg[key] = (globals()[key],key)
# now the variable points also to the key
print(a,b,c,d)

一旦您获得了变量的名称，您可以再次修改全局变量以恢复变量的值。这可以使用上下文管理器完成。

请注意，您不能修改globals()中的所有变量，因为这可能会导致一些问题，这就是我使用在globals中定义的变量进行限制的原因。

此外，完整的解决方案不一定是线程安全的，并且必须在重新分配之前释放在上下文中定义的变量，以便“new_keys”至少包含新变量的名称。

from __future__ import annotations
import inspect
import pandas as pd


# 변수 이름 가져오기
def getVariableName(variable: str) -> (str | Exception):
    callers_local_vars = inspect.currentframe().f_back.f_locals.items()

    df = pd.DataFrame(callers_local_vars)
    df.columns = ['함수명', '값']

    try:
        return df[(df['값'] == variable)].iloc[0]['함수명']
    except Exception as e:
        return e


test = 'Hello World!'

if __name__ == '__main__':
    print(getVariableName(test))

如果您已经有一个数据框列表，正如评论中所述，那么将该列表转换为字符串列表就很容易了。 不要从变量列表转换为字符串，而是反过来，使用内置的exec函数和f-strings将字符串列表转换为变量（假设变量已经被赋值，即vel、vol和area是现有pandas数据框的变量名）：

如果：

dfstr_list = [
              'vel',
              'vol',
              'area'
             ]

这个程序通过遍历列表，使用每个数据帧写入 Excel，并定义工作表名称：

for dfstr in dfstr_list:
    if dfstr in globals():
        exec(f"{dfstr}.to_excel(writer,sheet_name=dfstr)")

当从变量的值中查找变量名称时，可能会有几个变量等于相同的值，例如var1 = 'hello'和var2 = 'hello'。

我的解决方案：

def find_var_name(val):

    dict_list = []
    global_dict = dict(globals())

    for k, v in global_dict.items():
        dict_list.append([k, v])
   
    return [item[0] for item in dict_list if item[1] == val]

var1 = 'hello'
var2 = 'hello'
find_var_name('hello')

输出

['var1', 'var2']