Отримання назви змінної у вигляді рядка

Цей потік обговорює, як отримати ім'я функції як рядка в Python: Як отримати ім'я функції у вигляді рядка?

Як я можу зробити те ж саме для змінної? На відміну від функцій, змінні Python не мають __name__атрибута.

Іншими словами, якщо у мене є така змінна, як:

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

Я шукаю функцію / атрибут, наприклад retrieve_name(), щоб створити DataFrame у Pandas з цього списку , де назви стовпців задаються іменами фактичних словників:

# List of dictionaries for my DataFrame
list_of_dicts = [n_jobs, users, queues, priorities]
columns = [retrieve_name(d) for d in list_of_dicts] 

Використовуючи python-varnameпакет, ви можете легко отримати ім’я змінних

https://github.com/pwwang/python-varname

У вашому випадку ви можете:

from varname import Wrapper

foo = Wrapper(dict())

# foo.name == 'foo'
# foo.value == {}
foo.value['bar'] = 2

Або ви також можете спробувати отримати ім’я змінної безпосередньо:

from varname import nameof

foo = dict()

fooname = nameof(foo)
# fooname == 'foo'

Я автор цього пакету. Будь ласка, повідомте мене, якщо у вас є якісь запитання або ви можете подати проблеми на github.

Єдині об'єкти в Python, які мають канонічні назви, - це модулі, функції та класи, і, звичайно, немає гарантії, що це канонічне ім'я має якесь значення в будь-якому просторі імен після того, як визначено функцію чи клас або імпортується модуль. Ці імена також можна змінювати після створення об'єктів, щоб вони не завжди були особливо надійними.

Те, що ви хочете зробити, неможливо без рекурсивного прогулянки по дереву названих об'єктів ; ім'я - це одностороннє посилання на об'єкт. Звичайний об’єкт Python або сорт саду не містить посилань на його назви. Уявіть, якби кожному цілому числу, кожному диктату, кожному списку, кожному булевому знаменню потрібно було підтримувати список рядків, що представляли імена, які посилалися на нього! Це було б кошмаром на реалізацію, не маючи користі для програміста.

Навіть якщо значення змінних не вказують на ім’я, у вас є доступ до списку кожної призначеної змінної та її значення, тому я вражений тим, що лише одна людина запропонувала прокрутити туди, щоб шукати ваше ім’я var.

Хтось згадав у цій відповіді, що вам, можливо, доведеться пройти стек і перевірити місцевих жителів і глобальних користувачів, щоб знайти foo, але якщо fooвін призначений у тій області, де ви викликаєте цю retrieve_nameфункцію, ви можете скористатись inspects, current frameщоб отримати всі ці локальні змінні .

Моє пояснення може бути занадто багатослівним (можливо, я мав би використати "foo" менше слів), але ось як би це виглядало в коді ( зауважте, що якщо в одній і тій же величині присвоєно більше однієї змінної, ви отримати обидва ці імена змінних ):

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)

Якщо ви викликаєте цю функцію з іншої функції, щось на зразок:

def foo(bar):
    return retrieve_name(bar)

foo(baz)

І ви хочете bazзамість цього bar, вам просто потрібно буде повернутися до сфери роботи далі. Це можна зробити, додавши додатковий .f_backпри caller_local_varsініціалізації.

Дивіться приклад тут: ideone

З Python 3.8 можна просто використовувати функцію налагодження f-string:

>>> foo = dict()
>>> f'{foo=}'.split('=')[0]
'foo' 

На python3 ця функція отримає найбільшу зовнішню назву в стеку:

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]

Це корисно в будь-якому місці коду. Переміщує перевернутий стек, шукаючи перший матч.

Я не вірю, що це можливо. Розглянемо наступний приклад:

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

Значення aта bвказівка ​​на той самий об’єкт, але об'єкт не може знати, які змінні вказують на нього.

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

Він використовується так:

name(variable=variable)

Ось один підхід. Я б не рекомендував цього нічого важливого, оскільки він буде досить крихким. Але це можна зробити.

Створіть функцію, яка використовує inspectмодуль для пошуку вихідного коду, який його викликав. Тоді ви можете проаналізувати вихідний код, щоб виявити імена змінних, які ви хочете отримати. Наприклад, ось функція, яка називається autodict, приймає список змінних і повертає словникові відображення імен змінних до їх значень. Наприклад:

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

Дав би:

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

Перевірка самого вихідного коду краще, ніж пошук через locals()або globals()тому, що останній підхід не підкаже, який із змінних ви шукаєте.

У будь-якому випадку, ось код:

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

Дія відбувається в рядку з inspect.getouterframes, який повертає рядок у коді, який викликавautodict .

Очевидним недоліком цього виду магії є те, що він робить припущення щодо структури вихідного коду. І звичайно, це взагалі не буде працювати, якщо він запускається всередині перекладача.

Я написав пакет чаклунства, щоб зробити цю магію надійно. Ви можете написати:

from sorcery import dict_of

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

і передайте це конструктору фрейму даних. Це еквівалентно:

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

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

Якщо ви хотіли написати власну функцію, це могло б бути зроблено таким чином, щоб ви могли перевірити змінну, визначену в локальних, а потім перевірити глобальну. Якщо нічого не знайдено, ви можете порівняти на id (), щоб побачити, чи змінна вказує на те саме місце в пам'яті.

Якщо ваша змінна знаходиться в класі, ви можете використовувати className. dict .keys () або vars (self), щоб побачити, чи була визначена ваша змінна.

У Python, defіclass ключові слова прив'язують конкретне ім'я до об'єкта, який вони визначають (функція або клас). Аналогічно, модулі присвоюють ім’я завдяки тому, що називається чимось конкретним у файловій системі. У всіх трьох випадках існує очевидний спосіб присвоїти "канонічне" ім'я відповідному об'єкту.

Однак для інших видів об’єктів така канонічна назва може просто не існувати . Наприклад, розглянемо елементи списку. Елементи у списку не називаються індивідуально, і цілком можливо, що єдиний спосіб посилатися на них у програмі - це використовувати індекси списку, що містять список. Якщо такий перелік об'єктів передано у вашу функцію, ви не зможете призначити значущі ідентифікатори значенням.

Python не зберігає ім'я в лівій частині завдання в призначеному об'єкті, оскільки:

1. Потрібно було б з’ясувати, яке ім’я було "канонічним" серед кількох конфліктуючих об'єктів,
2. Це не має сенсу для об'єктів, які ніколи не присвоюються явній імені змінної,
3. Це було б вкрай неефективно,
4. Буквально жодна інша існуюча мова цього не робить.

Так, наприклад, функції, визначені за допомогою lambda, завжди матимуть "ім'я" <lambda>, а не конкретне ім'я функції.

Найкращим підходом було б просто попросити абонента передати (необов'язково) список імен. Якщо введення '...','...'символу занадто громіздке, ви можете прийняти, наприклад, одну рядок, що містить список імен, розділених комами (як namedtupleце робиться).

>> my_var = 5
>> my_var_name = [ k for k,v in locals().items() if v == my_var][0]
>> my_var_name 
'my_var'

locals () - Повернення словника, що містить локальні змінні поточного діапазону. ітерацією через цей словник ми можемо перевірити ключ, який має значення, яке дорівнює визначеній змінній, тільки вилучення ключа дасть нам текст змінної у рядковому форматі.

від (після трохи змін) https://www.tutorialspoint.com/How-to-get-a-variable-name-as-a-string-in-Python

Я думаю, що це так важко зробити в Python через простий факт, що ти ніколи не дізнаєшся назву змінної, яку ти використовуєш. Отже, у його прикладі ви могли:

Замість:

list_of_dicts = [n_jobs, users, queues, priorities]

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

лише інший спосіб зробити це на основі вмісту вхідної змінної:

(він повертає ім'я першої змінної, яка відповідає вхідній змінній, інакше None. Можна змінити її, щоб отримати всі імена змінних, які мають той самий вміст, що і вхідна змінна)

def retrieve_name(x, Vars=vars()):
    for k in Vars:
        if type(x) == type(Vars[k]):
            if x is Vars[k]:
                return k
    return None

Ця функція буде друкувати ім'я змінної зі своїм значенням:

import inspect

def print_this(var):
    callers_local_vars = inspect.currentframe().f_back.f_locals.items()
    print(str([k for k, v in callers_local_vars if v is var][0])+': '+str(var))

***Input & Function call:***
my_var = 10

print_this(my_var)

***Output**:*
my_var: 10

У мене є метод, і хоча він не найефективніший ... він працює! (і це не передбачає будь-яких фантазійних модулів).

В основному це порівнює ідентифікатор змінного для глобал () ідентифікатори змінних , а потім повертає ім'я сірникових.

def getVariableName(variable, globalVariables=globals().copy()):
    """ Get Variable Name as String by comparing its ID to globals() Variables' IDs

        args:
            variable(var): Variable to find name for (Obviously this variable has to exist)

        kwargs:
            globalVariables(dict): Copy of the globals() dict (Adding to Kwargs allows this function to work properly when imported from another .py)
    """
    for globalVariable in globalVariables:
        if id(variable) == id(globalVariables[globalVariable]): # If our Variable's ID matches this Global Variable's ID...
            return globalVariable # Return its name from the Globals() dict

Якщо мета - допомогти вам відслідковувати свої змінні, ви можете написати просту функцію, яка мітить змінну і повертає її значення та тип. Наприклад, припустимо, що i_f = 3.01, і ви округляєте його до цілого числа під назвою i_n, щоб використовувати його в коді, а потім знадобиться рядок i_s, який перейде до звіту.

def whatis(string, x):
    print(string+' value=',repr(x),type(x))
    return string+' value='+repr(x)+repr(type(x))
i_f=3.01
i_n=int(i_f)
i_s=str(i_n)
i_l=[i_f, i_n, i_s]
i_u=(i_f, i_n, i_s)

## make report that identifies all types
report='\n'+20*'#'+'\nThis is the report:\n'
report+= whatis('i_f ',i_f)+'\n'
report+=whatis('i_n ',i_n)+'\n'
report+=whatis('i_s ',i_s)+'\n'
report+=whatis('i_l ',i_l)+'\n'
report+=whatis('i_u ',i_u)+'\n'
print(report)

Це виводить у вікно під час кожного виклику з метою налагодження, а також дає рядок для письмового звіту. Єдиним недоліком є ​​те, що вам потрібно вводити змінну двічі кожен раз при виклику функції.

Я новачок в Python і знайшов цей дуже корисний спосіб зареєструвати свої зусилля під час програмування та спробувати впоратися з усіма об’єктами в Python. Один недолік полягає в тому, що whatis () виходить з ладу, якщо він викликає функцію, описану поза процедурою, де вона використовується. Наприклад, int (i_f) був дійсним викликом функції лише тому, що функція int відома Python. Ви можете викликати whatis (), використовуючи int (i_f ** 2), але якщо з якоїсь дивної причини ви вирішите визначити функцію під назвою int_squared, її потрібно оголосити всередині процедури, де використовується whatis ().

Можливо, це може бути корисним:

def Retriever(bar):
    return (list(globals().keys()))[list(map(lambda x: id(x), list(globals().values()))).index(id(bar))]

Функція проходить список ідентифікаторів значень із загальної області (простір імен може бути відредагований), знаходить індекс потрібного / необхідного var або функції на основі свого ідентифікатора, а потім повертає ім'я зі списку глобальних імен на основі на придбаний індекс.

Наступний метод не поверне ім'я змінної, але за допомогою цього методу ви можете легко створити кадр даних, якщо змінна доступна в глобальному масштабі.

class CustomDict(dict):
    def __add__(self, other):
        return CustomDict({**self, **other})

class GlobalBase(type):
    def __getattr__(cls, key):
        return CustomDict({key: globals()[key]})

    def __getitem__(cls, keys):
        return CustomDict({key: globals()[key] for key in keys})

class G(metaclass=GlobalBase):
    pass

x, y, z = 0, 1, 2

print('method 1:', G['x', 'y', 'z']) # Outcome: method 1: {'x': 0, 'y': 1, 'z': 2}
print('method 2:', G.x + G.y + G.z) # Outcome: method 2: {'x': 0, 'y': 1, 'z': 2}

A = [0, 1]
B = [1, 2]
pd.DataFrame(G.A + G.B) # It will return a data frame with A and B columns

Для констант можна використовувати enum, який підтримує отримання його імені.

Я намагаюся отримати ім'я від місцевих жителів, які оглядають, але це не може обробити var like [1], b.val. Після цього у мене з’явилася нова ідея --- отримати назву var із коду, і я спробую це успішно! код, як показано нижче:

#direct get from called function code
def retrieve_name_ex(var):
    stacks = inspect.stack()
    try:
        func = stacks[0].function
        code = stacks[1].code_context[0]
        s = code.index(func)
        s = code.index("(", s + len(func)) + 1
        e = code.index(")", s)
        return code[s:e].strip()
    except:
        return ""

Ви можете спробувати наступне, щоб отримати назву визначеної вами функції (не працює для вбудованих функцій):

import re
def retrieve_name(func):
    return re.match("<function\s+(\w+)\s+at.*", str(func)).group(1)

def foo(x):
    return x**2

print(retrieve_name(foo))
# foo