是否有可能获取传递给函数的变量的原始变量名？例如：
foobar = "foo"
def func(var):
print var.origname
所以：
func(foobar)
返回：
>>foobar
编辑：
我只是想创建一个像这样的函数：
def log(soup):
f = open(varname+'.html', 'w')
print >>f, soup.prettify()
f.close()
...并且让函数从传递给它的变量名生成文件名。
如果不可能的话，我想我只能每次将变量和变量名作为字符串传递。
编辑：为了明确，我不建议完全使用这种方式，它会出现问题，一团糟，不会对你有任何帮助，但是可以用于娱乐或教育目的。
你可以使用inspect模块进行hack，我不建议这样做，但你可以这么做...
import inspect
def foo(a, f, b):
frame = inspect.currentframe()
frame = inspect.getouterframes(frame)[1]
string = inspect.getframeinfo(frame[0]).code_context[0].strip()
args = string[string.find('(') + 1:-1].split(',')
names = []
for i in args:
if i.find('=') != -1:
names.append(i.split('=')[1].strip())
else:
names.append(i)
print names
def main():
e = 1
c = 2
foo(e, 1000, b = c)
main()
输出：
['e', '1000', 'c']
d = pack(a,b,c) 这样的代码，它等同于 d = dict(); d['a'] = a; d['b'] = b; d['c'] = c - 因为这是我经常使用的结构，而且我很懒... - Zero补充Michael Mrozek的回答，您可以通过以下方式提取精确的参数而非整个代码：
import re
import traceback
def func(var):
stack = traceback.extract_stack()
filename, lineno, function_name, code = stack[-2]
vars_name = re.compile(r'\((.*?)\).*$').search(code).groups()[0]
print vars_name
return
foobar = "foo"
func(foobar)
# PRINTS: foobar
看起来Ivo在inspect方面比我更有优势，但这里有另外一种实现:
import inspect
def varName(var):
lcls = inspect.stack()[2][0].f_locals
for name in lcls:
if id(var) == id(lcls[name]):
return name
return None
def foo(x=None):
lcl='not me'
return varName(x)
def bar():
lcl = 'hi'
return foo(lcl)
bar()
# 'lcl'
当然，它可以被欺骗：
def baz():
lcl = 'hi'
x='hi'
return foo(lcl)
baz()
# 'x'
教训：不要这样做。
f(obj.attr) 这样的东西。 - Vedran Šego如果你知道调用代码的样子，另一种尝试的方法是使用traceback：
def func(var):
stack = traceback.extract_stack()
filename, lineno, function_name, code = stack[-2]
code将包含用于调用func的代码行（在您的示例中，它将是字符串func(foobar)）。您可以解析该字符串以提取参数。
你无法这样做。它在传递给函数之前就被计算了。你能做的只有将其作为字符串传递。
locals()和globals()字典，查找与该值匹配的变量，但这样做实在不太优雅。更好的方法是手动传递: log('myvar', myvar)。 - Max Shawabkehdict。另请参见：https://dev59.com/s3M_5IYBdhLWcg3wcSx_ - Karl Knechtel@Ivo Wetzel的回答适用于一行代码中进行函数调用的情况，例如
e = 1 + 7
c = 3
foo(e, 100, b=c)
如果函数调用不在一行中，例如：
e = 1 + 7
c = 3
foo(e,
1000,
b = c)
下面的代码可以工作：
import inspect, ast
def foo(a, f, b):
frame = inspect.currentframe()
frame = inspect.getouterframes(frame)[1]
string = inspect.findsource(frame[0])[0]
nodes = ast.parse(''.join(string))
i_expr = -1
for (i, node) in enumerate(nodes.body):
if hasattr(node, 'value') and isinstance(node.value, ast.Call)
and hasattr(node.value.func, 'id') and node.value.func.id == 'foo' # Here goes name of the function:
i_expr = i
break
i_expr_next = min(i_expr + 1, len(nodes.body)-1)
lineno_start = nodes.body[i_expr].lineno
lineno_end = nodes.body[i_expr_next].lineno if i_expr_next != i_expr else len(string)
str_func_call = ''.join([i.strip() for i in string[lineno_start - 1: lineno_end]])
params = str_func_call[str_func_call.find('(') + 1:-1].split(',')
print(params)
您将获得：
[u'e', u'1000', u'b = c']
from varname import nameof
s = 'Hey!'
print (nameof(s))
输出：
s
下面是该包的介绍：
argname()。 - Panwen Wang为了方便后人，这里是我写的一些与此任务相关的代码。总体而言，我认为Python缺少一个模块，以便为每个人提供漂亮且可靠的调用者环境检查。类似于R语言中rlang eval框架提供的功能。
import re, inspect, ast
#Convoluted frame stack walk and source scrape to get what the calling statement to a function looked like.
#Specifically return the name of the variable passed as parameter found at position pos in the parameter list.
def _caller_param_name(pos):
#The parameter name to return
param = None
#Get the frame object for this function call
thisframe = inspect.currentframe()
try:
#Get the parent calling frames details
frames = inspect.getouterframes(thisframe)
#Function this function was just called from that we wish to find the calling parameter name for
function = frames[1][3]
#Get all the details of where the calling statement was
frame,filename,line_number,function_name,source,source_index = frames[2]
#Read in the source file in the parent calling frame upto where the call was made
with open(filename) as source_file:
head=[source_file.next() for x in xrange(line_number)]
source_file.close()
#Build all lines of the calling statement, this deals with when a function is called with parameters listed on each line
lines = []
#Compile a regex for matching the start of the function being called
regex = re.compile(r'\.?\s*%s\s*\(' % (function))
#Work backwards from the parent calling frame line number until we see the start of the calling statement (usually the same line!!!)
for line in reversed(head):
lines.append(line.strip())
if re.search(regex, line):
break
#Put the lines we have groked back into sourcefile order rather than reverse order
lines.reverse()
#Join all the lines that were part of the calling statement
call = "".join(lines)
#Grab the parameter list from the calling statement for the function we were called from
match = re.search('\.?\s*%s\s*\((.*)\)' % (function), call)
paramlist = match.group(1)
#If the function was called with no parameters raise an exception
if paramlist == "":
raise LookupError("Function called with no parameters.")
#Use the Python abstract syntax tree parser to create a parsed form of the function parameter list 'Name' nodes are variable names
parameter = ast.parse(paramlist).body[0].value
#If there were multiple parameters get the positional requested
if type(parameter).__name__ == 'Tuple':
#If we asked for a parameter outside of what was passed complain
if pos >= len(parameter.elts):
raise LookupError("The function call did not have a parameter at postion %s" % pos)
parameter = parameter.elts[pos]
#If there was only a single parameter and another was requested raise an exception
elif pos != 0:
raise LookupError("There was only a single calling parameter found. Parameter indices start at 0.")
#If the parameter was the name of a variable we can use it otherwise pass back None
if type(parameter).__name__ == 'Name':
param = parameter.id
finally:
#Remove the frame reference to prevent cyclic references screwing the garbage collector
del thisframe
#Return the parameter name we found
return param
get_text_with_indentation，并假设恰好有一个函数参数），但它对不同的测试用例效果很好。它不需要解析源代码本身，因此应该比之前的解决方案更健壮和更简单。#!/usr/bin/env python3
import inspect
from executing import Source
def func(var):
callFrame = inspect.currentframe().f_back
callNode = Source.executing(callFrame).node
source = Source.for_frame(callFrame)
expression = source.asttokens().get_text(callNode.args[0])
print(expression, '=', var)
i = 1
f = 2.0
dct = {'key': 'value'}
obj = type('', (), {'value': 42})
func(i)
func(f)
func(s)
func(dct['key'])
func(obj.value)
输出：
i = 1
f = 2.0
s = string
dct['key'] = value
obj.value = 42
f_back。def get_name_of_argument():
callFrame = inspect.currentframe().f_back.f_back
callNode = Source.executing(callFrame).node
source = Source.for_frame(callFrame)
return source.asttokens().get_text(callNode.args[0])
def func(var):
print(get_name_of_argument(), '=', var)