6

我想做以下事情：

print "CC =",CC

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

我试过这个：

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

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

4

7 回答 7

3

您可以使用检查模块（另请参阅此 SO 问题）：

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
于 2012-07-02T11:41:58.637 回答
1

I think this is your required solution:

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

for example if you declare a variable:

>>> c=55.6

then result of printme(c) will be

>>> 'c = 55.6'

Note: This solution is based on globally unique id matching.

于 2012-07-02T12:29:56.557 回答
1

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

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

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

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

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

于 2012-07-02T10:54:53.517 回答
0

使用全局变量来实现这一点，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
于 2012-07-02T11:23:19.493 回答
0

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

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)
于 2012-07-02T10:45:13.197 回答
0

如果我理解正确，您想要在当前范围内打印变量名称及其值的简写？如果不使用解释器跟踪函数或 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'

编辑：

有关使用检查模块（内部使用 sys._getframe）的解决方案，请参阅 catchemifyoutry 的答案。为了完整起见，直接使用跟踪功能的解决方案 - 如果您使用 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")
于 2012-07-02T11:01:15.677 回答
0

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

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
于 2012-07-02T10:53:56.467 回答