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 f(a):
    print('{0}: = {1}'.format(locals().keys()[0], a))

<强>更新

我知道这个例子没有多大意义，因为它基本上与以下内容相同：

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

我只是想把OP指向本地人（），因为我不太明白他想要完成什么。

我想这更像是他在寻找的东西：

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


f(a=1, b=2)

Answer 5

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

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 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的所有变量，所以我用__过滤掉了名称startin并将它们存储在列表中。每次调用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

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

7 个答案: