我希望能够将变量的名称作为字符串获取，但我不知道Python是否具有那么多的内省功能。类似的东西：
>>> print(my_var.__name__)
'my_var'
我想这样做，因为我有一堆变量我想变成一个字典，如：
bar = True
foo = False
>>> my_dict = dict(bar=bar, foo=foo)
>>> print my_dict
{'foo': False, 'bar': True}
但我想要更自动的东西。
Python有locals()和vars()，所以我想有办法。
答案 0 :(得分：130)
正如unwind所说，这不是你在Python中所做的事情 - 变量实际上是对象的名称映射。
然而，这是尝试这样做的一种方法：
>>> a = 1
>>> for k, v in list(locals().iteritems()):
if v is a:
a_as_str = k
>>> a_as_str
a
>>> type(a_as_str)
'str'
答案 1 :(得分：61)
我想要这么做很多。这个hack与rlotun的建议非常相似，但它是一个单行，这对我很重要：
blah = 1
blah_name = [ k for k,v in locals().iteritems() if v is blah][0]
Python 3 +
blah = 1
blah_name = [ k for k,v in locals().items() if v is blah][0]
答案 2 :(得分：48)
你想这样做吗？
dict( (name,eval(name)) for name in ['some','list','of','vars'] )
示例
>>> some= 1
>>> list= 2
>>> of= 3
>>> vars= 4
>>> dict( (name,eval(name)) for name in ['some','list','of','vars'] )
{'list': 2, 'some': 1, 'vars': 4, 'of': 3}
答案 3 :(得分：17)
这是一个黑客。它不适用于所有Python实现分发（特别是那些没有traceback.extract_stack的分发。）
import traceback
def make_dict(*expr):
(filename,line_number,function_name,text)=traceback.extract_stack()[-2]
begin=text.find('make_dict(')+len('make_dict(')
end=text.find(')',begin)
text=[name.strip() for name in text[begin:end].split(',')]
return dict(zip(text,expr))
bar=True
foo=False
print(make_dict(bar,foo))
# {'foo': False, 'bar': True}
请注意，这个黑客很脆弱：
make_dict(bar,
foo)
（在2行上调用make_dict）将无效。
而不是尝试从值 foo和bar生成字典，
从字符串变量名称 'foo'和'bar'中生成字典会更加Pythonic：
dict([(name,locals()[name]) for name in ('foo','bar')])
答案 4 :(得分：14)
这在Python中是不可能的，它实际上没有“变量”。 Python有名称，同一个对象可以有多个名称。
答案 5 :(得分：10)
我认为我的问题将有助于说明为什么这个问题很有用，并且可以更深入地了解如何回答这个问题。我写了一个小函数来对代码中的各种变量进行快速内联检查。基本上，它列出了变量名称，数据类型，大小和其他属性，因此我可以快速发现我所犯的任何错误。代码很简单：
def details(val):
vn = val.__name__ # If such a thing existed
vs = str(val)
print("The Value of "+ str(vn) + " is " + vs)
print("The data type of " + vn + " is " + str(type(val)))
因此，如果您有一些复杂的字典/列表/元组情况，让解释器返回您指定的变量名称会非常有帮助。例如，这是一个奇怪的字典：
m = 'abracadabra'
mm=[]
for n in m:
mm.append(n)
mydic = {'first':(0,1,2,3,4,5,6),'second':mm,'third':np.arange(0.,10)}
details(mydic)
The Value of mydic is {'second': ['a', 'b', 'r', 'a', 'c', 'a', 'd', 'a', 'b', 'r', 'a'], 'third': array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9.]), 'first': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}
The data type of mydic is <type 'dict'>
details(mydic['first'])
The Value of mydic['first'] is (0, 1, 2, 3, 4, 5, 6)]
The data type of mydic['first'] is <type 'list'>
details(mydic.keys())
The Value of mydic.keys() is ['second', 'third', 'first']
The data type of mydic.keys() is <type 'tuple'>
details(mydic['second'][0])
The Value of mydic['second'][0] is a
The data type of mydic['second'][0] is <type 'str'>
我不确定我是否把它放在正确的位置，但我认为这可能会有所帮助。我希望如此。
答案 6 :(得分：8)
我根据这个问题的答案写了一个简洁实用的小功能。我把它放在这里以防它有用。
def what(obj, callingLocals=locals()):
"""
quick function to print name of input and value.
If not for the default-Valued callingLocals, the function would always
get the name as "obj", which is not what I want.
"""
for k, v in list(callingLocals.items()):
if v is obj:
name = k
print(name, "=", obj)
用法：
>> a = 4
>> what(a)
a = 4
>>|
答案 7 :(得分：6)
我发现如果你已经有一个特定的值列表，那就是@S描述的方式。 Lotts是最好的;但是，下面描述的方法很适合在整个代码中添加所有变量和类没有需要提供变量名称，尽管您可以根据需要指定它们。可以扩展代码以排除类。
import types
import math # mainly showing that you could import what you will before d
# Everything after this counts
d = dict(globals())
def kv_test(k,v):
return (k not in d and
k not in ['d','args'] and
type(v) is not types.FunctionType)
def magic_print(*args):
if len(args) == 0:
return {k:v for k,v in globals().iteritems() if kv_test(k,v)}
else:
return {k:v for k,v in magic_print().iteritems() if k in args}
if __name__ == '__main__':
foo = 1
bar = 2
baz = 3
print magic_print()
print magic_print('foo')
print magic_print('foo','bar')
输出：
{'baz': 3, 'foo': 1, 'bar': 2}
{'foo': 1}
{'foo': 1, 'bar': 2}
答案 8 :(得分：6)
在python 3中，这很容易
myVariable = 5
for v in locals():
if id(v) == id("myVariable"):
print(v, locals()[v])
这将打印：
myVariable 5
答案 9 :(得分：5)
这是我创建的用于读取变量名称的函数。它更通用，可用于不同的应用程序：
def get_variable_name(*variable):
'''gets string of variable name
inputs
variable (str)
returns
string
'''
if len(variable) != 1:
raise Exception('len of variables inputed must be 1')
try:
return [k for k, v in locals().items() if v is variable[0]][0]
except:
return [k for k, v in globals().items() if v is variable[0]][0]
在指定问题中使用它：
>>> foo = False
>>> bar = True
>>> my_dict = {get_variable_name(foo):foo,
get_variable_name(bar):bar}
>>> my_dict
{'bar': True, 'foo': False}
答案 10 :(得分：5)
Python3。使用inspect来捕获调用本地命名空间，然后使用此处提供的想法。如前所述，可以返回多个答案。
def varname(var):
import inspect
frame = inspect.currentframe()
var_id = id(var)
for name in frame.f_back.f_locals.keys():
try:
if id(eval(name)) == var_id:
return(name)
except:
pass
答案 11 :(得分：4)
在阅读帖子时，我看到了很多摩擦。这很容易给予 一个糟糕的答案，然后让别人给出正确的答案。无论如何，这是我找到的。
来自：[effbot.org]（http://effbot.org/zone/python-objects.htm#names）
名称有点不同 - 它们不是对象的真正属性，对象本身也不知道它的名称。
一个对象可以有任意数量的名称，或者根本没有名称。
名称存在于名称空间中（例如模块名称空间，实例名称空间，函数的本地名称空间）。
的
注意：它说对象本身不知道它叫什么，所以这就是线索。 Python对象不是自引用的。然后它说，名称存在于名称空间。我们在TCL / TK中有这个。所以也许我的答案会有所帮助（但它确实帮助了我）
jj = 123
print eval("'" + str(id(jj)) + "'")
print dir()
166707048 ['__builtins__', '__doc__', '__file__', '__name__', '__package__', 'jj']
所以列表末尾有'jj'。
将代码重写为：
jj = 123
print eval("'" + str(id(jj)) + "'")
for x in dir():
print id(eval(x))
161922920 ['__builtins__', '__doc__', '__file__', '__name__', '__package__', 'jj'] 3077447796 136515736 3077408320 3077656800 136515736 161922920
这个令人讨厌的代码id是变量/对象/无论你是什么迂腐 - 调用它的名字。
所以，就是这样。当我们直接查找时，'jj'的内存地址是相同的，就像我们在全局名称空间中查找字典一样。我相信你可以做一个功能来做到这一点。只需记住变量/ object / wypci所在的命名空间。
QED。
答案 12 :(得分：2)
我编写了程序包sorcery来稳健地进行这种魔术。您可以编写：
from sorcery import dict_of
my_dict = dict_of(foo, bar)
答案 13 :(得分：2)
我上传了pypi的解决方案。它是一个模块，用于定义C＃的nameof函数。
它遍历它所调用的帧的字节码指令，获取传递给它的变量/属性的名称。这些名称位于函数名称后的.argrepr LOAD条指令中。
答案 14 :(得分：2)
import re
import traceback
pattren = re.compile(r'[\W+\w+]*get_variable_name\((\w+)\)')
def get_variable_name(x):
return pattren.match( traceback.extract_stack(limit=2)[0][3]) .group(1)
a = 1
b = a
c = b
print get_variable_name(a)
print get_variable_name(b)
print get_variable_name(c)
答案 15 :(得分：1)
大多数对象没有 __ name __ 属性。 （类，函数和模块都可以;任何更多的内置类型都有？）
除了print(my_var.__name__)之外，您对print("my_var")还有什么期望？你能直接使用字符串吗？
你可以“切片”一个字典：
def dict_slice(D, keys, default=None):
return dict((k, D.get(k, default)) for k in keys)
print dict_slice(locals(), ["foo", "bar"])
# or use set literal syntax if you have a recent enough version:
print dict_slice(locals(), {"foo", "bar"})
可替换地：
throw = object() # sentinel
def dict_slice(D, keys, default=throw):
def get(k):
v = D.get(k, throw)
if v is not throw:
return v
if default is throw:
raise KeyError(k)
return default
return dict((k, get(k)) for k in keys)
答案 16 :(得分：1)
在python3上，此函数将获取堆栈中最外层的名称：
import inspect
def retrieve_name(var):
"""
Gets the name of var. Does it from the out most frame inner-wards.
:param var: variable to get name from.
:return: string
"""
for fi in reversed(inspect.stack()):
names = [var_name for var_name, var_val in fi.frame.f_locals.items() if var_val is var]
if len(names) > 0:
return names[0]
它在代码的任何地方都很有用。遍历反向堆栈寻找第一场比赛。
答案 17 :(得分：1)
你可以使用easydict
>>> from easydict import EasyDict as edict
>>> d = edict({'foo':3, 'bar':{'x':1, 'y':2}})
>>> d.foo
3
>>> d.bar.x
1
>>> d = edict(foo=3)
>>> d.foo
3
另一个例子：
>>> d = EasyDict(log=False)
>>> d.debug = True
>>> d.items()
[('debug', True), ('log', False)]
答案 18 :(得分：1)
我正在研究类似的问题。 @ S.Lott说：“如果你有变量列表，那么”发现“他们的名字是什么意思？”我的答案只是看它是否可以完成，如果由于某种原因你想要按类型将变量排序到列表中。所以无论如何，在我的研究中，我遇到了这个线程，我的解决方案有点扩展，基于@rlotun解决方案。另一件事，@ unutbu说，“这个想法有其优点，但请注意，如果两个变量名称引用相同的值（例如True），则可能会返回一个非预期的变量名称。”在这个练习中，所以我通过对每种可能性使用类似于此的列表理解来处理它：isClass = [i for i in isClass if i != 'item']。没有它，“item”会出现在每个列表中。
__metaclass__ = type
from types import *
class Class_1: pass
class Class_2: pass
list_1 = [1, 2, 3]
list_2 = ['dog', 'cat', 'bird']
tuple_1 = ('one', 'two', 'three')
tuple_2 = (1000, 2000, 3000)
dict_1 = {'one': 1, 'two': 2, 'three': 3}
dict_2 = {'dog': 'collie', 'cat': 'calico', 'bird': 'robin'}
x = 23
y = 29
pie = 3.14159
eee = 2.71828
house = 'single story'
cabin = 'cozy'
isClass = []; isList = []; isTuple = []; isDict = []; isInt = []; isFloat = []; isString = []; other = []
mixedDataTypes = [Class_1, list_1, tuple_1, dict_1, x, pie, house, Class_2, list_2, tuple_2, dict_2, y, eee, cabin]
print '\nMIXED_DATA_TYPES total count:', len(mixedDataTypes)
for item in mixedDataTypes:
try:
# if isinstance(item, ClassType): # use this for old class types (before 3.0)
if isinstance(item, type):
for k, v in list(locals().iteritems()):
if v is item:
mapping_as_str = k
isClass.append(mapping_as_str)
isClass = [i for i in isClass if i != 'item']
elif isinstance(item, ListType):
for k, v in list(locals().iteritems()):
if v is item:
mapping_as_str = k
isList.append(mapping_as_str)
isList = [i for i in isList if i != 'item']
elif isinstance(item, TupleType):
for k, v in list(locals().iteritems()):
if v is item:
mapping_as_str = k
isTuple.append(mapping_as_str)
isTuple = [i for i in isTuple if i != 'item']
elif isinstance(item, DictType):
for k, v in list(locals().iteritems()):
if v is item:
mapping_as_str = k
isDict.append(mapping_as_str)
isDict = [i for i in isDict if i != 'item']
elif isinstance(item, IntType):
for k, v in list(locals().iteritems()):
if v is item:
mapping_as_str = k
isInt.append(mapping_as_str)
isInt = [i for i in isInt if i != 'item']
elif isinstance(item, FloatType):
for k, v in list(locals().iteritems()):
if v is item:
mapping_as_str = k
isFloat.append(mapping_as_str)
isFloat = [i for i in isFloat if i != 'item']
elif isinstance(item, StringType):
for k, v in list(locals().iteritems()):
if v is item:
mapping_as_str = k
isString.append(mapping_as_str)
isString = [i for i in isString if i != 'item']
else:
for k, v in list(locals().iteritems()):
if v is item:
mapping_as_str = k
other.append(mapping_as_str)
other = [i for i in other if i != 'item']
except (TypeError, AttributeError), e:
print e
print '\n isClass:', len(isClass), isClass
print ' isList:', len(isList), isList
print ' isTuple:', len(isTuple), isTuple
print ' isDict:', len(isDict), isDict
print ' isInt:', len(isInt), isInt
print ' isFloat:', len(isFloat), isFloat
print 'isString:', len(isString), isString
print ' other:', len(other), other
# my output and the output I wanted
'''
MIXED_DATA_TYPES total count: 14
isClass: 2 ['Class_1', 'Class_2']
isList: 2 ['list_1', 'list_2']
isTuple: 2 ['tuple_1', 'tuple_2']
isDict: 2 ['dict_1', 'dict_2']
isInt: 2 ['x', 'y']
isFloat: 2 ['pie', 'eee']
isString: 2 ['house', 'cabin']
other: 0 []
'''
答案 19 :(得分：1)
也许我过度思考这个但是......
str_l = next((k for k,v in locals().items() if id(l) == id(v)))
>>> bar = True
>>> foo = False
>>> my_dict=dict(bar=bar, foo=foo)
>>> next((k for k,v in locals().items() if id(bar) == id(v)))
'bar'
>>> next((k for k,v in locals().items() if id(foo) == id(v)))
'foo'
>>> next((k for k,v in locals().items() if id(my_dict) == id(v)))
'my_dict'
答案 20 :(得分：1)
使用python 2.7和更新版本，还有字典理解，这使它更短。如果可能的话，我会使用getattr而不是eval（eval是邪恶的），就像在最佳答案中一样。自我可以是具有您所关注的上下文的任何对象。它可以是一个对象或locals = locals（）等。
{name: getattr(self, name) for name in ['some', 'vars', 'here]}
答案 21 :(得分：1)
好吧，我几天前遇到了 need ，不得不获取一个变量的名称指向对象本身。
为什么这么有必要？
简而言之，我正在为 Maya 构建一个插件。核心插件是使用C ++构建的，但GUI是通过Python绘制的（因为它不是处理器密集型的）。由于我还没有知道如何从插件中return多个值，除了默认的MStatus，因此要在Python中更新字典，我必须传递变量的名称，指向实现GUI并包含字典本身的对象到插件，然后使用MGlobal::executePythonCommand()从 Maya 的全局范围更新字典。
为此，我所做的就是：
import time
class foo(bar):
def __init__(self):
super(foo, self).__init__()
self.time = time.time() #almost guaranteed to be unique on a single computer
def name(self):
g = globals()
for x in g:
if isinstance(g[x], type(self)):
if g[x].time == self.time:
return x
#or you could:
#return filter(None,[x if g[x].time == self.time else None for x in g if isinstance(g[x], type(self))])
#and return all keys pointing to object itself
我知道它不是globals中的完美解决方案，许多键可能指向同一个对象，例如：
a = foo()
b = a
b.name()
>>>b
or
>>>a
并且该方法不是线程安全的。如果我错了，请纠正我。
至少这种方法通过获取全局范围中指向对象本身并将其传递给插件的任何变量的名称来解决我的问题。作为论据，它在内部使用。
我在int（原始整数类）上尝试了这个，但问题是这些原始类没有被绕过（如果错误，请更正使用的技术术语）。您可以重新实施int，然后执行int = foo，但a = 3永远不会是foo的对象，而是原始对象。为了解决这个问题，您必须a = foo(3)才能让a.name()工作。
答案 22 :(得分：0)
虽然这可能是一个糟糕的想法，但它与rlotun的回答是一致的，但它会更频繁地返回正确的结果。
import inspect
def getVarName(getvar):
frame = inspect.currentframe()
callerLocals = frame.f_back.f_locals
for k, v in list(callerLocals.items()):
if v is getvar():
callerLocals.pop(k)
try:
getvar()
callerLocals[k] = v
except NameError:
callerLocals[k] = v
del frame
return k
del frame
你这样称呼它：
bar = True
foo = False
bean = False
fooName = getVarName(lambda: foo)
print(fooName) # prints "foo"
答案 23 :(得分：0)
应该获取列表然后返回
def get_var_name(**kwargs):
"""get variable name
get_var_name(var = var)
Returns:
[str] -- var name
"""
return list(kwargs.keys())[0]
答案 24 :(得分：0)
它不会返回变量名，但是您可以轻松地从全局变量创建字典。
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}
答案 25 :(得分：0)
使用python-varname，您可以轻松做到这一点：
pip install python-varname
from varname import Wrapper
foo = Wrapper(True)
bar = Wrapper(False)
your_dict = {val.name: val.value for val in (foo, bar)}
print(your_dict)
# {'foo': True, 'bar': False}
免责声明：我是该python-varname库的作者。
答案 26 :(得分：-1)
>>> a = 1
>>> b = 1
>>> id(a)
34120408
>>> id(b)
34120408
>>> a is b
True
>>> id(a) == id(b)
True
这样就可以获得一个'a'或'b'的varname。