python - separar - Obtener el nombre de una variable como una cadena

string en python

Question

Este hilo discute cómo obtener el nombre de una función como una cadena en Python: ¿Cómo obtener un nombre de función como una cadena en Python?

¿Cómo puedo hacer lo mismo con una variable? (tenga en cuenta que las variables de Python no tienen el atributo __name__ , al menos en Python 2.7.x )

En otras palabras, si tengo una variable como:

foo = dict()
foo[''bar''] = 2

Estoy buscando una función / atributo, por ejemplo, retrieve_name :

retrieve_name(foo) 

que devuelve la cadena ''foo''

Actualizar:

Dado que la gente pregunta por qué quiero hacer esto, aquí hay un ejemplo. Me gustaría crear un DataFrame en pandas a partir de esta lista , donde los nombres de las columnas están dados por los nombres de los diccionarios reales:

# List of dictionaries for my DataFrame
list_of_dicts = [n_jobs, users, queues, priorities]

Answer 1

Aquí hay un enfoque. No recomendaría esto para nada importante, porque será bastante frágil. Pero puede hacerse.

Cree una función que use el módulo de inspect para encontrar el código fuente que lo llamó. Luego puede analizar el código fuente para identificar los nombres de variables que desea recuperar. Por ejemplo, aquí hay una función llamada autodict que toma una lista de variables y devuelve los nombres de las variables de mapeo del diccionario a sus valores. P.ej:

x = ''foo''
y = ''bar''
d = autodict(x, y)
print d

Daría:

{''x'': ''foo'', ''y'': ''bar''}

Inspeccionar el código fuente en sí es mejor que buscar a través de los locals() o globals() porque este último enfoque no te dice cuáles de las variables son las que deseas.

En cualquier caso, aquí está el código:

def autodict(*args):
    get_rid_of = [''autodict('', '','', '')'', ''/n'']
    calling_code = inspect.getouterframes(inspect.currentframe())[1][4][0]
    calling_code = calling_code[calling_code.index(''autodict''):]
    for garbage in get_rid_of:
        calling_code = calling_code.replace(garbage, '''')
    var_names, var_values = calling_code.split(), args
    dyn_dict = {var_name: var_value for var_name, var_value in
                zip(var_names, var_values)}
    return dyn_dict

La acción ocurre en la línea con inspect.getouterframes , que devuelve la cadena dentro del código que llamó autodict .

La desventaja obvia de este tipo de magia es que hace suposiciones sobre cómo se estructura el código fuente. Y, por supuesto, no funcionará si se ejecuta dentro del intérprete.

Answer 2

Creo que es muy difícil hacer esto en Python por el simple hecho de que nunca sabrás el nombre de la variable que estás usando. Entonces, en su ejemplo, podrías hacer:

En lugar de:

list_of_dicts = [n_jobs, users, queues, priorities]

dict_of_dicts = {"n_jobs" : n_jobs, "users" : users, "queues" : queues, "priorities" : priorities}

Answer 3

En Python, las palabras clave def y class enlazarán un nombre específico al objeto que definen (función o clase). Del mismo modo, los módulos reciben un nombre en virtud de que se les llama algo específico en el sistema de archivos. En los tres casos, hay una manera obvia de asignar un nombre "canónico" al objeto en cuestión.

Sin embargo, para otros tipos de objetos, tal nombre canónico simplemente no existe . Por ejemplo, considere los elementos de una lista. Los elementos en la lista no se nombran individualmente, y es completamente posible que la única manera de referirse a ellos en un programa sea mediante el uso de índices de lista en la lista que contiene. Si dicha lista de objetos pasó a su función, posiblemente no podría asignar identificadores significativos a los valores.

Python no guarda el nombre en el lado izquierdo de una asignación en el objeto asignado porque:

1. Requeriría averiguar qué nombre era "canónico" entre múltiples objetos conflictivos,
2. No tendría sentido para los objetos que nunca están asignados a un nombre de variable explícito,
3. Sería extremadamente ineficiente,
4. Literalmente, no existe otro lenguaje en existencia que lo haga.

Entonces, por ejemplo, las funciones definidas usando lambda siempre tendrán el "nombre" <lambda> , en lugar de un nombre de función específico.

El mejor enfoque sería simplemente pedirle a la persona que llama que pase una lista (opcional) de nombres. Si escribir ''...'',''...'' es demasiado engorroso, podría aceptar, por ejemplo, una sola cadena que contenga una lista de nombres separados por comas (como namedtuple ).

Answer 4

En python3, esta función obtendrá el nombre más externo en la pila:

import inspect


def retrieve_name(var):
        """
        Gets the name of var. Does it from the out most frame inner-wards.
        :param var: variable to get name from.
        :return: string
        """
        for fi in reversed(inspect.stack()):
            names = [var_name for var_name, var_val in fi.frame.f_locals.items() if var_val is var]
            if len(names) > 0:
                return names[0]

Es útil en cualquier parte del código. Atraviesa la pila invertida buscando la primera coincidencia.

Answer 5

Escribí el paquete de sorcery para hacer este tipo de magia de forma robusta. Puedes escribir:

from sorcery import dict_of

columns = dict_of(n_jobs, users, queues, priorities)

y pasar eso al constructor del marco de datos. Es equivalente a:

columns = dict(n_jobs=n_jobs, users=users, queues=queues, priorities=priorities)

Answer 6

Incluso si los valores de las variables no apuntan al nombre, tiene acceso a la lista de cada variable asignada y su valor, por lo que me sorprende que solo una persona sugiriera ir por allí buscando su nombre var.

Alguien mencionó en esa respuesta que quizás tendrías que pasar la pila y verificar los locales y globales para encontrar a foo , pero si foo está asignado en el alcance al que estás llamando esta función de nombre de retrieve_name , puedes usar el current frame inspect para obtener usted todas esas variables locales. Mi explicación puede ser un poco demasiado prolija (quizás debería haber usado un "foo" menos palabras), pero así es como se vería en el código ( Tenga en cuenta que si hay más de una variable asignada al mismo valor, lo hará obtener ambos nombres de variables ):

import inspect

x,y,z = 1,2,3

def retrieve_name(var):
    callers_local_vars = inspect.currentframe().f_back.f_locals.items()
    return [var_name for var_name, var_val in callers_local_vars if var_val is var]

print retrieve_name(y)

Answer 7

Los únicos objetos en Python que tienen nombres canónicos son módulos, funciones y clases, y por supuesto no hay garantía de que este nombre canónico tenga algún significado en cualquier espacio de nombre después de que la función o clase haya sido definida o el módulo importado. Estos nombres también se pueden modificar después de que se crean los objetos, por lo que no siempre son particularmente confiables.

Lo que desea hacer no es posible sin recorrer recursivamente el árbol de los objetos nombrados ; un nombre es una referencia de un solo sentido a un objeto. Un objeto Python común o de jardín no contiene referencias a sus nombres. ¡Imagínese si cada entero, cada dict, cada lista, cada booleano necesitara mantener una lista de cadenas que representaran los nombres que se referían a ella! Sería una pesadilla de implementación, con poco beneficio para el programador.

Answer 8

No creo que esto sea posible. Considere el siguiente ejemplo:

>>> a = []
>>> b = a
>>> id(a)
140031712435664
>>> id(b)
140031712435664

El punto b del mismo objeto. No (el objeto) no sabe qué variables lo señalan.

Answer 9

Para constantes, puede usar una enumeración, que admite recuperar su nombre.

Answer 10

>>> locals()[''foo'']
{}
>>> globals()[''foo'']
{}

si quisiera escribir su propia función, podría hacerlo de manera tal que pueda verificar una variable definida en los locales y luego verificar los valores globales. Si no encuentra nada, puede comparar en id () para ver si la variable apunta al mismo lugar en la memoria.

Si su variable está en una clase, podría usar className. dict .keys () o vars (self) para ver si su variable ha sido definida.

Answer 11

def name(**variables):
    return [x for x in variables]

Se usa así:

name(variable=variable)