Comment puis-je obtenir le nom d'un objet en Python?

Ce n'est pas vraiment possible, car il pourrait y avoir plusieurs variables qui ont la même valeur ou de valeur ne peut avoir aucune variable ou une valeur peut avoir la même valeur qu'une variable que par hasard.

Si vous voulez vraiment le faire, vous pouvez utiliser

def variable_for_value(value):
    for n,v in globals().items():
        if v == value:
            return n
    return None

Cependant, il serait mieux si vous itérer sur les noms en premier lieu:

my_list = ["x", "y", "z"] # x, y, z have been previously defined

for name in my_list:
    print "handling variable ", name
    bla = globals()[name]
    # do something to bla

Ce one-liner œuvres, pour tous les types d'objets, aussi longtemps qu'ils sont en globals() dict, qu'elles doivent être:

def name_of_global_obj(xx):
    return [objname for objname, oid in globals().items()
            if id(oid)==id(xx)][0]

ou, de manière équivalente:

def name_of_global_obj(xx):
    for objname, oid in globals().items():
        if oid is xx:
            return objname

Comme d'autres l'ont mentionné, c'est vraiment une question délicate. Des Solutions de ce ne sont pas de "one size fits all", pas même à distance. La difficulté (ou de facilité) va vraiment dépendre de votre situation.

Je suis venu à ce problème à plusieurs reprises, mais plus récemment, lors de la création d'une fonction de débogage. Je voulais la fonction de prendre certains objets inconnus comme arguments et d'imprimer leurs déclaré des noms et des matières. Obtenir le contenu est facile bien sûr, mais la déclaration de nom est une autre histoire.

Ce qui suit est une partie de ce que je suis venu avec.

Retourner le nom de la fonction

Déterminer le nom d'une fonction est vraiment facile, car il a la __nom__ attribut contenant la fonction déclarée de nom.

name_of_function = lambda x : x.__name__

def name_of_function(arg):
    try:
        return arg.__name__
    except AttributeError:
        pass`

Un exemple, si vous créez la fonction def test_function(): pass, puis copy_function = test_function, puis name_of_function(copy_function), il sera de retour test_function.

De retour correspondante premier nom de l'objet

1. Vérifier si l'objet a un __nom__ attribut et le retourner si donc (les fonctions déclarées uniquement). Notez que vous pouvez supprimer ce test que le nom sera toujours dans globals().

2. Comparer la valeur de arg avec les valeurs d'éléments dans globals() et de retourner le nom du premier match. Notez que je suis en filtrant les noms commençant par '_'.

Le résultat sera composé du nom du premier objet correspondant, autrement Aucun.

def name_of_object(arg):
    # check __name__ attribute (functions)
    try:
        return arg.__name__
    except AttributeError:
        pass

    for name, value in globals().items():
        if value is arg and not name.startswith('_'):
            return name

Retour de tous les noms d'objet

• Comparer la valeur de arg avec les valeurs d'éléments dans globals() et de stocker des noms dans une liste. Notez que je suis en filtrant les noms commençant par '_'.

Le résultat sera constitué d'une liste (pour des correspondances multiples), une chaîne de caractères (un seul match), sinon Aucun. Bien sûr, vous devez ajuster ce comportement en tant que de besoin.

def names_of_object(arg):
    results = [n for n, v in globals().items() if v is arg and not n.startswith('_')]
    return results[0] if len(results) is 1 else results if results else None

Et la raison pour laquelle je veux avoir le nom de la fonction est parce que je veux créer fun_dict sans écrire les noms des fonctions deux fois, puisque cela semble être une bonne façon de créer des bugs.

À cette fin, vous avez une magnifique getattr fonction, qui vous permet d'obtenir un objet par un nom connu. Donc, vous pourriez le faire par exemple:

funcs.py:

def func1(): pass
def func2(): pass

main.py:

import funcs
option = command_line_option()
getattr(funcs, option)()

Les noms de variables peuvent être trouvés dans la globals() et les habitants() dicts. Mais ils ne vous donnera pas ce que vous cherchez ci-dessus. "bla" contenant la valeur de chaque élément de my_list, pas la variable.

Je suis tombé sur cette page tout en me demandant la même question.

Comme d'autres l'ont noté, il est assez simple à saisir simplement la __name__ attribut à partir d'une fonction afin de déterminer le nom de la fonction. Elle est légèrement plus compliqué avec des objets qui n'ont pas une façon saine de déterminer __name__, c'est à dire de la base/les objets primitifs comme basestring cas, ints, aspire, etc.

Longue histoire courte, vous pourriez probablement utiliser les inspecter module pour faire une supposition éclairée au sujet de laquelle il s'agit, mais vous devez probablement savoir ce cadre, vous travaillez au sein d'/traverse le bas de la pile à trouver la bonne. Mais je déteste imaginer la façon dont beaucoup de plaisir ce serait d'essayer de traiter avec eval/exec ed code.

% python2 whats_my_name_again.py
needle => ''b''
['a', 'b']
[]
needle => '<function foo at 0x289d08ec>'
['c']
['foo']
needle => '<function bar at 0x289d0bfc>'
['f', 'bar']
[]
needle => '<__main__.a_class instance at 0x289d3aac>'
['e', 'd']
[]
needle => '<function bar at 0x289d0bfc>'
['f', 'bar']
[]
%

whats_my_name_again.py:

#!/usr/bin/env python

import inspect

class a_class:
    def __init__(self):
        pass

def foo():
    def bar():
        pass

    a = 'b'
    b = 'b'
    c = foo
    d = a_class()
    e = d
    f = bar

    #print('globals', inspect.stack()[0][0].f_globals)
    #print('locals', inspect.stack()[0][0].f_locals)

    assert(inspect.stack()[0][0].f_globals == globals())
    assert(inspect.stack()[0][0].f_locals == locals())

    in_a_haystack = lambda: value == needle and key != 'needle'

    for needle in (a, foo, bar, d, f, ):
        print("needle => '%r'" % (needle, ))
        print([key for key, value in locals().iteritems() if in_a_haystack()])
        print([key for key, value in globals().iteritems() if in_a_haystack()])


foo()

Voici ma réponse, je suis également en utilisant globals().les éléments()

    def get_name_of_obj(obj, except_word = ""):

        for name, item in globals().items():
            if item == obj and name != except_word:
                return name

J'ai ajouté except_word parce que je veux filtrer quelques mot utilisé dans la boucle for.
Si vous n'avez pas l'ajouter, le mot-clé dans la boucle for peut confondre cette fonction, parfois le mot clé comme "each_item" dans le cas suivant peut afficher dans le résultat de la fonction, dépend de ce que vous avez fait de votre boucle.

par exemple.

    for each_item in [objA, objB, objC]:
        get_name_of_obj(obj, "each_item")

par exemple.

    >>> objA = [1, 2, 3]
    >>> objB = ('a', {'b':'thi is B'}, 'c')
    >>> for each_item in [objA, objB]:
    ...     get_name_of_obj(each_item)
    ...
    'objA'
    'objB'
    >>>
    >>>
    >>> for each_item in [objA, objB]:
    ...     get_name_of_obj(each_item)
    ...
    'objA'
    'objB'
    >>>
    >>>
    >>> objC = [{'a1':'a2'}]
    >>>
    >>> for item in [objA, objB, objC]:
    ...     get_name_of_obj(item)
    ...
    'objA'
    'item'  <<<<<<<<<< --------- this is no good
    'item'
    >>> for item in [objA, objB]:
    ...     get_name_of_obj(item)
    ...
    'objA'
    'item'     <<<<<<<<--------this is no good
    >>>
    >>> for item in [objA, objB, objC]:
    ...     get_name_of_obj(item, "item")
    ...
    'objA'
    'objB'  <<<<<<<<<<--------- now it's ok
    'objC'
    >>>

Espère que cela peut vous aider.