Python 2.7 将函数的输入用作字符串和变量

Question

我想做以下事情：

print "CC =",CC

但是作为一个函数，我只需要编写一次变量 CC。我无法弄清楚如何在函数中执行此操作，因为它总是将 CC 评估为浮点数（它是）......有没有办法接受函数的输入作为字符串和浮点号码？

我试过了：

def printme(a): 
    b='%s' % a
    print b
    return b

当然它只打印a 的值，而不是它的名字。

Answer 1

您可以使用inspect 模块（另请参阅this SO question）：

def printme(x):
    import inspect
    f = inspect.currentframe()
    val = f.f_back.f_locals[x]
    print x, '=', val


CC = 234.234    
printme('CC') # <- write variable name only once
# prints: CC = 234.234

Answer 2

也许字典是解决问题的更好方法。假设您有几个要使用的名称-值对，您可以将它们放在 dict 中：

params = {"CC": 1.2345, "ID": "Yo!", "foo": "bar"}

然后，例如，您可以打印所有格式正确的名称和值，如下所示：

for key in params:
    print "{0} = {1}".format(key, params[key])

但是由于目前还不清楚为什么你要这样做，所以很难判断这是否是正确的方法。

Answer 3

我认为这是您需要的解决方案：

def printme(x): 
    keys_list = [key for key, value in globals().iteritems() if value == x]
    print keys_list
    for key in keys_list:
        if id(globals()[key]) == id(x):
            result = "%s = %s" %(key, x)
            print result
            break

    return result

例如，如果你声明一个变量：

>>> c=55.6

那么 printme(c) 的结果将是

>>> 'c = 55.6'

注意：此解决方案基于全局唯一 id 匹配。

Answer 4

不完全是你想要的，但很容易做到：

def printme(**kwargs):
    for key, value in kwargs.items():
        print '%s=%s' % (key, value)
    return value

In [13]: printme(CC=1.23, DD=2.22)
CC=1.23
DD=2.22
Out[13]: 1.23

Answer 5

如果我理解正确的话，你想要这样的东西吗？

def f(a):
    print('{0}: = {1}'.format(locals().keys()[0], a))

更新：

我知道这个例子没有多大意义，因为它基本上是一样的：

def f(a):
    print('a: {0}'.format(a))

我只是想将 OP 指向 locals()，因为我不太明白他想要完成什么。

我想这就是他想要的更多：

def f(**kwargs):
    for k in kwargs.keys():
        print('{0}: {1}'.format(k, kwargs[k]))


f(a=1, b=2)

Answer 6

如果我理解正确，您想要在当前范围内打印变量名称及其值的简写吗？ 如果不使用解释器跟踪函数或 sys._getframe，这通常是不可能的，通常只有在您知道自己在做什么的情况下才应该使用它。原因是 print 函数没有其他方法可以从调用范围内获取本地变量：

def a():
    x = 1
    magic_print("x") #will not work without accessing the current frame

没有这些你可以做的就是明确地将局部变量传递给这样的函数：

def printNameAndValue(varname, values):
    print("%s=%s" % (varname, values[varname]))

def a():
    x = 1
    printNameAndValue("x", locals())  #prints 'x=1'

编辑：

查看catchemifyoutry 的答案以获取使用inspect 模块（内部使用sys._getframe）的解决方案。为了完整起见，直接使用跟踪功能的解决方案 - 如果您使用 python 2.0 并且检查不可用，则很有用；）

from sys import settrace

__v = {} #global dictionary that holds the variables

def __trace(frame, event, arg):
    """ a trace function saving the locals on every function call """
    global __v 
    if not event == "call":
        return __trace
    __v.update(frame.f_back.f_locals)

def enableTrace(f):
    """ a wrapper decorator setting and removing the trace """
    def _f(*a, **kwa):
        settrace(__trace)
        try:
            f(*a, **kwa)
        finally:
            settrace(None)
    return _f

def printv(vname):
    """ the function doing the printing """
    global __v 
    print "%s=%s" % (vname, __v[vname])

将其保存在模块中并像这样使用：

from modulenamehere import enableTrace, printv

@enableTrace
def somefunction():
    x = 1
    [...]
    printv("x")

Answer 7

使用了一个全局变量来实现这一点，func.__globals__.keys() 包含传递给func 的所有变量，所以我过滤掉了以__ 开头的名称并将它们存储在一个列表中。 每次调用 func() 时，func.__globals__.keys() 都会使用新的变量名称进行更新，因此将新的 varn 与旧的 glo 进行比较会得到刚刚添加的新变量。

glo=[]
def func(x):  
  global glo 
  varn=[x for x in func.__globals__.keys() if not x.startswith('__') and x!=func.__name__]
  new=list(set(varn)^set(glo))
  print("{0}={1}".format(new[0],x))
  glo=varn[:]

输出：

>>> a=10
>>> func(a)
a=10
>>> b=20
>>> func(20)
b=20
>>> foo='cat'
>>> func(foo)
foo=cat
>>> bar=1000
>>> func(bar)
bar=1000