Convertir le nom de la variable en chaîne ?

Question

J'aimerais convertir un nom de variable python en son équivalent en chaîne de caractères, comme indiqué. Comment faire ?

var = {}
print ???  # Would like to see 'var'
something_else = 3
print ???  # Would print 'something_else'

Answer 1

Techniquement, l'information est à votre disposition, mais comme d'autres l'ont demandé, comment l'utiliser de manière sensée ?

>>> x = 52
>>> globals()
{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', 
'x': 52, '__doc__': None, '__package__': None}

Cela montre que le nom de la variable est présent sous forme de chaîne dans le dictionnaire globals().

>>> globals().keys()[2]
'x'

Dans ce cas, il s'agit de la troisième clé, mais il n'y a pas de moyen fiable de savoir où un nom de variable donné aboutira

>>> for k in globals().keys():
...   if not k.startswith("_"):
...     print k
...
x
>>>

Vous pourriez filtrer les variables du système de cette manière, mais vous obtiendrez toujours tous vos propres éléments. Le simple fait d'exécuter le code ci-dessus a créé une autre variable "k" qui a modifié la position de "x" dans le dict.

Mais peut-être s'agit-il d'un début utile pour vous. Si vous nous dites à quoi vous destinez cette capacité, nous pourrons peut-être vous fournir des informations plus utiles.

Answer 2

Vous devez en quelque sorte faire référence à la variable dont vous voulez imprimer le nom. Cela ressemblerait donc à

print varname(something_else)

Cette fonction n'existe pas, mais si elle existait, elle serait en quelque sorte inutile. Il faut taper something_else Il suffit donc de taper des guillemets à gauche et à droite pour imprimer le nom sous forme de chaîne de caractères :

print "something_else"

Answer 3

Quels sont vos objectifs ? Il n'y a absolument aucune raison de faire ce que vous décrivez, et il existe probablement une bien meilleure solution au problème que vous essayez de résoudre.

L'alternative la plus évidente à ce que vous demandez est un dictionnaire. Par exemple :

>>> my_data = {'var': 'something'}
>>> my_data['something_else'] = 'something'
>>> print my_data.keys()
['var', 'something_else']
>>> print my_data['var']
something

J'ai implémenté le résultat que vous souhaitiez. N'utilisez pas ce code, s'il vous plaît !

#!/usr/bin/env python2.6
class NewLocals:
    """Please don't ever use this code.."""
    def __init__(self, initial_locals):
        self.prev_locals = list(initial_locals.keys())

    def show_new(self, new_locals):
        output = ", ".join(list(set(new_locals) - set(self.prev_locals)))
        self.prev_locals = list(new_locals.keys())
        return output
# Set up
eww = None
eww = NewLocals(locals())

# "Working" requested code

var = {}

print eww.show_new(locals())  # Outputs: var

something_else = 3
print eww.show_new(locals()) # Outputs: something_else

# Further testing

another_variable = 4
and_a_final_one = 5

print eww.show_new(locals()) # Outputs: another_variable, and_a_final_one

Answer 4

Est-ce que Django ne fait pas cela lors de la génération des noms de champs ?

http://docs.djangoproject.com/en/dev//topics/db/models/#verbose-field-names

Cela me semble raisonnable.

Answer 5

Je pense que c'est une bonne solution et je suppose que c'est la meilleure que l'on puisse obtenir. Mais voyez-vous un moyen de gérer les résultats ambigus que votre fonction peut renvoyer ? En tant que L'opérateur "is" se comporte de manière inattendue avec les entiers montre que les entiers faibles et les chaînes de même valeur sont mis en cache par Python, de sorte que votre fonction variablename peut produire des résultats ambigus avec une forte probabilité. Dans mon cas, j'aimerais créer un décorateur, qui ajoute une nouvelle variable à une classe par le nom de variable que je lui passe :

def inject(klass, dependency):
klass.__dict__["__"+variablename(dependency)]=dependency

Mais si votre méthode renvoie des résultats ambigus, comment puis-je connaître le nom de la variable que j'ai ajoutée ?

var any_var="myvarcontent"
var myvar="myvarcontent"
@inject(myvar)
class myclasss():
    def myclass_method(self):
        print self.__myvar    #I can not be sure, that this variable will be set...

Si je vérifie également la liste locale, je pourrai peut-être au moins supprimer la variable "dépendance" de la liste, mais le résultat ne sera pas fiable.