Python 2.7 utilizando la entrada a una función como una cadena y variables

Question

me gustaría hacer lo siguiente:

print "CC =",CC 

sino como una función de manera que sólo tengo para escribir la variable CC vez. No puedo averiguar cómo hacer esto en una función, ya que siempre evalúa CC como un número de punto flotante (que es) .... ¿Hay alguna manera de aceptar la entrada a una función como cadena y punto flotante? ¿número?

yo probamos este:

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

pero por supuesto que sólo imprime el valor de a, no su nombre.

Answer 1

Si te entiendo correctamente, ¿quieres algo como esto?

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

Actualización:

Soy consciente de que el ejemplo no tiene mucho sentido, ya que es básicamente el mismo que:

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

Simplemente quería señalar la OP a los lugareños() ya que no entendí muy bien lo que él está tratando de lograr.

supongo que esto es más de lo que está buscando:

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


f(a=1, b=2) 

Answer 2

No es exactamente lo que quiere, pero fácil de hacer:

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

un diccionario Tal vez es una mejor aproximación al problema. Asumiendo que tiene varios pares de nombre y valor que desea utilizar, puede ponerlos en una dict:

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

Entonces, por ejemplo, podría imprimir todos los nombres y valores con un formato agradable como esto:

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

Pero como todavía no está claro por qué está tratando de hacer esto, es difícil decir si es la manera correcta.

Answer 4

Si lo entiendo correctamente, ¿quiere una abreviatura para imprimir un nombre de variable y su valor en el alcance actual? En general, esto es imposible sin utilizar la función de rastreo de intérpretes o sys._getframe, que en general solo debe utilizarse si sabe lo que está haciendo. La razón de esto es que la función de impresión no tiene otra manera de conseguir los locales del ámbito de llamar:

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

lo que puede hacer sin que éstos se pasan de forma explícita a los locales a una función como esta:

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

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

EDIT:

ver la respuesta por catchemifyoutry de una solución mediante el módulo de inspección (que utiliza internamente sys._getframe).Para completar una solución utilizando la función de rastreo directamente - útil si estás usando Python 2.0 e inspeccionar no está disponible;)

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

guardarlo en un módulo y utilizar así:

from modulenamehere import enableTrace, printv 

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

Answer 5

se utiliza una variable global para lograr esto, func.__globals__.keys() contiene todas las variables pasadas al func, así que filtran el nombre startin con __ y los almacena en una lista. con cada llamada a func() el func.__globals__.keys() se actualiza con el nuevo nombre de variable, así que compare el nuevo varn con el anterior resultados en la nueva variable que se acaba de agregar.

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

de salida:

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

podría utilizar el módulo de inspect (véase también 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

Creo que esta es la solución requerida:

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 

por ejemplo, si se declara una variable:

>>> c=55.6 

continuación, resultado de PrintMe (c) habrá

>>> 'c = 55.6' 

Nota: Esta solución se basa en la coincidencia de ID único a nivel mundial.