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

Question

I would like to do the following:

print "CC =",CC

but as a function so that i only have to write the variable CC once. I can't work out how to do this in a function as it always evaluates CC as a floating point number (which it is).... Is there a way to accept the input to a function as both a string and floating point number?

I tried this:

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

but of course it only prints the value of a , not its name.

Answer 1

You could use the inspect module (see also 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

Perhaps a dictionary is a better approach to the problem. Assuming you have several name-value pairs that you want to use, you can put them in a dict :

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

Then, for example, you could print all the names and values nicely formatted like this:

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

But since it is still unclear why you are trying to do this, it's hard to tell whether this is the right way.

Answer 3

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.

Answer 4

If I understand you correctly you want something like this?

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

Update:

I am aware that the example doesn't make a lot of sense, as it's basically the same as:

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

I merely wanted to point the OP to locals() as I didn't quite understand what he's trying to accomplish.

I guess this is more what he's looking for:

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


f(a=1, b=2)

Answer 5

Not exactly what you want, but easy to do:

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

If I understand you correctly you want a shorthand for printing a variable name and its value in the current scope? This is in general impossible without using the interpreters trace function or sys._getframe , which should in general only be used if you know what you're doing. The reason for this is that the print function has no other way of getting the locals from the calling scope:

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

What you CAN do without these is explicitly pass the locals to a function like this:

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

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

EDIT:

See the answer by catchemifyoutry for a solution using the inspect module (which internally uses sys._getframe). For completeness a solution using the trace function directly - useful if you're using python 2.0 and inspect isn't available ;)

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])

Save it in a module and use like this:

from modulenamehere import enableTrace, printv

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

Answer 7

used a global variable to achieve this, func.__globals__.keys() contains all the variables passed to func , so I filtered out the name startin with __ and stored them in a list. with every call to func() the func.__globals__.keys() gets updated with the new variable name,so compare the new varn with the older glo results in the new variable that was just added.

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[:]

output:

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