Python 2.7版使用輸入的功能作爲一個字符串和可變

Question

我想做到以下幾點：

print "CC =",CC 

但作爲一個函數，這樣我只需要編寫一次變量CC。我不能解決如何在一個函數中做到這一點，因爲它總是評估CC爲浮點數（它是）...有沒有辦法接受函數的輸入作爲字符串和浮點數？

我嘗試這樣做：

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

但當然只能打印的a的價值，而不是它的名稱。

Answer 1

如果我理解你正確，你想要這樣的東西？

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 2

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

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 3

也許一本字典是一個解決問題的更好的方法。假設你有要使用多個名稱 - 值對，你可以把它們放在一個dict：

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

然後，例如，你可以打印格式良好的這樣的所有名稱和值：

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

但是，由於它仍然不清楚爲什麼您正在嘗試這樣做，很難說這是否是正確的方法。

Answer 4

如果我的理解正確，您希望在當前範圍內打印變量名稱及其值？這通常不可能使用而不使用解釋器跟蹤函數或sys._getframe，通常只有在您知道自己在做什麼時才應該使用它。這樣做的原因是，打印功能已經從主叫範圍得到當地人沒有其他辦法：

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 5

使用一個全局變量來實現這一目標，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 

Answer 6

您可以使用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 7

我覺得這是你所需要的解決方案：

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匹配。