我已经读了如何获得一个函数名作为字符串?。
如何对变量做同样的事情呢?与函数相反，Python变量没有__name__属性。
换句话说，如果我有一个变量，比如:
foo = dict()
foo['bar'] = 2
我正在寻找一个函数/属性，例如retrieve_name()，以便从这个列表中创建一个DataFrame in Pandas，其中列名由实际字典的名称给出:
# List of dictionaries for my DataFrame
list_of_dicts = [n_jobs, users, queues, priorities]
columns = [retrieve_name(d) for d in list_of_dicts]
当前回答
我认为在Python中很难做到这一点，因为一个简单的事实是，你永远不会不知道你正在使用的变量的名称。所以，在他的例子中，你可以这样做:
而不是:
list_of_dicts = [n_jobs, users, queues, priorities]
dict_of_dicts = {"n_jobs" : n_jobs, "users" : users, "queues" : queues, "priorities" : priorities}
其他回答
Python中唯一具有规范名称的对象是模块、函数和类，当然，在定义了函数或类或导入了模块之后，不能保证这个规范名称在任何命名空间中都有任何意义。这些名称还可以在创建对象后修改，因此它们可能并不总是特别值得信赖。
如果不递归遍历命名对象的树，就不可能实现你想做的事情;名称是对对象的单向引用。普通或普通的Python对象不包含对其名称的引用。想象一下，如果每个整数、每个字典、每个列表、每个布尔值都需要维护一个表示引用它的名称的字符串列表!这将是实现的噩梦，对程序员没有什么好处。
这里有一种方法。我不建议在任何重要的事情上使用它，因为它会很脆。但这是可以做到的。
创建一个使用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的代码中的字符串。
这种魔法的明显缺点是，它对源代码的结构做出了假设。当然，如果它在解释器内部运行，它根本就不起作用。
你可以以kwargs的形式获取变量，并以字符串的形式返回:
var=2
def getVarName(**kwargs):
return list(kwargs.keys())[0]
print (getVarName(var = var))
注:变量名必须等于自身。
也许这很有用:
def Retriever(bar):
return (list(globals().keys()))[list(map(lambda x: id(x), list(globals().values()))).index(id(bar))]
该函数遍历全局作用域的值的ID列表(可以编辑命名空间)，根据其ID找到想要/需要的var或函数的索引，然后根据获得的索引从全局名称列表中返回名称。
如何对变量做同样的事情呢?与函数相反，Python变量没有__name__属性。
问题出现的原因是您对术语、语义或两者都感到困惑。
"variables" don't belong in the same category as "functions". A "variable" is not a thing that takes up space in memory while the code is running. It is just a name that exists in your source code - so that when you're writing the code, you can explain which thing you're talking about. Python uses names in the source code to refer to (i.e., give a name to) values. (In many languages, a variable is more like a name for a specific location in memory where the value will be stored. But Python's names actually name the thing in question.)
In Python, a function is a value. (In some languages, this is not the case; although there are bytes of memory used to represent the actual executable code, it isn't a discrete chunk of memory that your program logic gets to interact with directly.) In Python, every value is an object, meaning that you can assign names to it freely, pass it as an argument, return it from a function, etc. (In many languages, this is not the case.) Objects in Python have attributes, which are the things you access using the . syntax. Functions in Python have a __name__ attribute, which is assigned when the function is created. Specifically, when a def statement is executed (in most languages, creation of a function works quite differently), the name that appears after def is used as a value for the __name__ attribute, and also, independently, as a variable name that will get the function object assigned to it.
但大多数对象都没有这样的属性。
换句话说，如果我有一个变量，比如:
That's the thing: you don't "have" the variable in the sense that you're thinking of. You have the object that is named by that variable. Anything else depends on the information incidentally being stored in some other object - such as the locals() of the enclosing function. But it would be better to store the information yourself. Instead of relying on a variable name to carry information for you, explicitly build the mapping between the string name you want to use for the object, and the object itself.
