Как я получаю строковое представление переменной в Python?

Стивенха дает отличный ответ на этот вопрос. Но, если вы действительно хотите покопаться в словарях пространств имен, вы можете получить все имена для данного значения в определенной области / пространстве имен следующим образом:

def foo1():
    x = 5
    y = 4
    z = x
    print names_of1(x, locals())

def names_of1(var, callers_namespace):
    return [name for (name, value) in callers_namespace.iteritems() if var is value]

foo1() # prints ['x', 'z']

Если вы работаете с Python, который имеет фрейм стека поддержка (большинство из них, CPython делает), необязательно, чтобы вы передавали locals dict в функцию names_of ; функция может получить этот словарь из самого фрейма вызывающей стороны:

def foo2():
    xx = object()
    yy = object()
    zz = xx
    print names_of2(xx)

def names_of2(var):
    import inspect
    callers_namespace = inspect.currentframe().f_back.f_locals
    return [name for (name, value) in callers_namespace.iteritems() if var is value]

foo2() # ['xx', 'zz']

Если вы работаете с типом значения, которому вы можете присвоить атрибут name, вы можете дать ему имя, а затем использовать его:

class SomeClass(object):
    pass

obj = SomeClass()
obj.name = 'obj'


class NamedInt(int):
    __slots__ = ['name']

x = NamedInt(321)
x.name = 'x'

Наконец, если вы работаете с атрибутами класса и хотите, чтобы они знали свои имена (дескрипторы - очевидный вариант использования), вы можете проделывать интересные трюки с программированием метаклассов, как это делается в определениях таблиц в декларативном стиле Django ORM и SQLAlchemy:

class AutonamingType(type):
    def __init__(cls, name, bases, attrs):
        for (attrname, attrvalue) in attrs.iteritems():
            if getattr(attrvalue, '__autoname__', False):
                attrvalue.name = attrname
        super(AutonamingType,cls).__init__(name, bases, attrs)

class NamedDescriptor(object):
    __autoname__ = True
    name = None
    def __get__(self, instance, instance_type):
        return self.name

class Foo(object):
    __metaclass__ = AutonamingType

    bar = NamedDescriptor()
    baaz = NamedDescriptor()

lilfoo = Foo()
print lilfoo.bar   # prints 'bar'
print lilfoo.baaz  # prints 'baaz'

Есть три способа получить "строковое" представление объекта в Python: 1: str ()

>>> foo={"a":"z","b":"y"}
>>> str(foo)
"{'a': 'z', 'b': 'y'}"

2: repr ()

>>> foo={"a":"z","b":"y"}
>>> repr(foo)
"{'a': 'z', 'b': 'y'}"

3: интерполяция строк:

>>> foo={"a":"z","b":"y"}
>>> "%s" % (foo,)
"{'a': 'z', 'b': 'y'}"

В этом случае все три метода генерировали один и тот же вывод, разница в том, что str () вызывает dict .__ str __ ( ) , а repr () вызывает dict .__ repr __ () . str () используется для интерполяции строк, в то время как repr () используется Python внутренне для каждого объекта в списке или dict, когда вы печатаете список или dict.

Как Тендаи Мавуше упоминает выше, строка, созданная repr, не обязательно для чтения человеком.

Кроме того, реализация по умолчанию .__ str __ () заключается в вызове .__ repr __ () , поэтому, если класс не имеет собственных переопределений для .__ str __ () , используется значение, возвращенное из .__ repr __ () .

Я считаю, что общая форма того, что вы хотите, - это repr () или метод объекта __ repr __ () .

в отношении объекта. to __ repr __ () :

Вызывается встроенной функцией repr () и преобразованием строк (обратное кавычки) для вычисления «официального» строковое представление объекта.

См. документацию здесь: объект. repr (self)