Как вывести имя переменной в python
3 способа преобразовать строку на имя переменной в Python
Мы будем преобразовывать строку Python в имя переменной с несколькими способами, как функция exec (), функции local () и функции глобалов ().
Вступление
Мы узнали о многих темах в Python. Но, вы когда-нибудь используете входную строку в качестве имени переменной в вашей программе. В этом руководстве мы будем сосредоточиться на этой теме, только для преобразования строки Python на имя переменной. Другими словами, мы будем создавать динамические имена переменных и присваивая их значение. Существуют несколько способов преобразования строки на имя переменной. Мы обсудим все из них в этой статье.
Мы преобразуем строку в именем переменной с несколькими способами, как функция Exec (), функции Local () и функции глобалов ().
Несколько способов с примерами для преобразования строки Python в именем переменной
Затем мы обсудим, как мы можем преобразовать строку в название переменной с примерами, подробно описанными.
1. Использование метода EXEC () в Python для преобразования строки Python в именем переменной
Методы EXEC () помогают нам динамически выполнять программу Python.
В этом примере у нас будет переменная, названная нами и входной строкой. Затем мы будем применять EXEC () Способ с некоторыми модификаторами и попытка преобразовать строку в имя переменной. Давайте подробно посмотрим с помощью примера, объясненной ниже:
2. Использование функции Locals () для преобразования строки Python в именем переменной
Функция Locals () в Python используется для возврата словаря текущего локальной таблицы символов. Локальная таблица символов доступна с помощью функции local (). Эта функция работает так же, как функция глобал (). Единственная разница между ними является функцией местных жителей (). Доступ к локальной таблице символов и глобал () Доступ к таблице глобальных символов, и оба возвращают словарь.
В этом примере мы будем принимать ввод как строку. Затем мы будем применять местные жители в качестве словаря, приведя к нему некоторое значение. Наконец, мы распечатаем входную строку и преобразуйте строку в именем переменной.
3. Использование функции Globals () для преобразования строки Python в именем переменной
Функция Globals () используется для возврата словаря текущего таблицы символов. Глобальная таблица символов используется для хранения всей информации, связанной с глобальным объемом программы, Доступ к функции глобалей ().
В этом примере мы будем принимать ввод как строку. Затем мы будем применять глобал как словарь, поместив его значение. Наконец, мы распечатаем входную строку и преобразуйте строку в именем переменной.
Плюсы и минусы создания глобальных переменных в Python
Господин
Должны прочитать
Заключение
В этом руководстве мы узнали о концепции преобразования строки на имя переменной. Мы обсудили все пути, через которые мы можем преобразовать строку в именем переменной. Все способы подробно объяснены с помощью примеров. Вы можете использовать любой из методов, которые вы находите подходящие для вас и вашей программы.
Однако, если у вас есть какие-либо сомнения или вопросы, дайте мне знать в разделе «Комментарий» ниже. Я постараюсь помочь вам как можно скорее.
Переменные в Python
Переменные — важная часть любого языка программирования. Они позволяют хранить, использовать и передавать данные.
Переменные позволяют не только удобно манипулировать данными, но и разделять их на типы, с которыми можно работать по определённым правилам. В Python они подчиняются концепциям, используемым в других языках программирования, однако они также имеют особенности, например, тип явно не объявляется.
Создание и присвоение значений
Создание переменной в Python 3 отличается от других языков программирования. Её не нужно заранее объявлять, указывать её тип, она создается в момент присваивания значения.
Чтобы создать переменную, используется символ равенства «=». Слева от которого пишут наименование, а справа — значение нужного типа. Пример:
Динамическая типизация
Такое создание переменных возможно благодаря динамической типизации.
Множественное присваивание и обмен значениями
Python позволяет программисту присвоить одно и то же значение нескольким переменным:
Кроме того, в отличие от других языков программирования Python позволяет обменять значения двух переменных —
Такая операция возможна, потому что Python используется кортеж, в который помещает значения, чтобы можно было поменять их местами.
Имена
В именах переменных в Python 3 можно использовать только буквы, цифры и символы подчеркивания. Цифры можно использовать в любой части имени, кроме начала.
И если синтаксис накладывает на программиста мало ограничений, то IT сообщество требует «хороших» имён для переменных:
Для создания хороших имён используются следующие методы:
Зарезервированные имена (ключевые слова)
Вывод в консоль
Чтобы вывести переменную на экран, используют функцию print(). С её помощью можно вывести значение одной или нескольких переменных в форматированном выводе. Есть несколько вариантов синтаксиса вывода:
Пустая переменная
None используется в случаях, когда значение не определено, не существует. И хотя он не эквивалентен какому-либо значению типа bool, строке или числу, он также является объектом.
При необходимости, можно проверить содержимое переменной следующим образом:
Может использоваться, например, когда мы в переменной храним указатель на открытый файл. И когда мы этот файл закрываем, то присваиваем указателю значение None. В дальнейшем можно проверять будет перед записью или чтением данных, является ли переменная пустой.
Области видимости
В Python есть глобальная и локальная область видимости. Объявление переменных в разных областях видимости помогает избежать пересечения имён, открывает программисту новые уровни взаимодействий между ними и делает код более безопасным, делая невозможным несанкционированный доступ к механизмам работы функций.
Глобальная область видимости — это тело исполняемого скрипта. К любой переменной, объявленной в ней, можно получить доступ из любой части программы, даже из другого модуля.
Чтобы получить доступ к глобальной переменной из функции, необходимо использовать ключевое слово global, оно показывает интерпретатору, что нужно использовать находящуюся в глобальной области видимости. Кроме того, если функция не находит в своём теле нужную переменную, она автоматически ищет её в глобальной области видимости скрипта и использует.
Локальная область видимости недоступна для редактирования из вне, любая переменная, объявленная внутри функции будет находиться в локальной области видимости, это позволяет использовать одно и то же имя много раз в одной программе, защитить функцию от ненужных изменений и упростить написание кода.
Удаление
Заключение
Python даёт программисту все необходимое для работы с переменными, он предоставляет и такие инструменты, которых нет в других языках программирования, например, обмен значений.
Python делает работу с переменными очень простой, он позволяет не объявлять их типы, присваивать уже существующей значение другого типа и поддерживает работу с областями видимости.
Использование переменных в Python 3
Переменные – очень важная составляющая программы; по сути, это символ (или набор символов), которому присвоено значение и который можно использовать вместо этого значения при написании программы.
Данное руководство ознакомит вас с основами работы с переменными в Python 3.
Что такое переменная?
С технической точки зрения переменная присваивает значению символическое имя или идентификатор. Имя переменной используется для того, чтобы сослаться на сохраненное значение в компьютерной программе.
Переменную можно представить как метку или ярлык с именем, который привязан к значению.
К примеру, у вас есть целое число 103204934813. Вы можете сохранить его в переменной, и тогда вам не придётся постоянно вводить повторно длинное число. Сохраните число в переменной my_int:
По сути, my_int – это ярлык, привязанный к значению 103204934813.
Фраза my_int = 103204934813 – это операция присваивания, которая состоит из следующих частей:
Таким образом, присваивая значению имя, вы инициализируете, или создаёте переменную. После этого можно использовать переменную вместо значения. В Python, в отличие от некоторых других языков программирования, переменные не нужно явно декларировать. То есть, объявив, что my_int равно 103204934813, вы можете просто использовать my_int вместо числа. Попробуйте запустить:
С помощью переменных можно быстро выполнить вычисления. Попробуйте отнять 813 из my_int:
В качестве значения переменной можно использовать результат математического уравнения. Попробуйте сложить два числа и сохранить значение их суммы в переменной x:
Как видите, это очень похоже на простейшее школьное уравнение; здесь, как и в алгебре, буквы и другие символы используются для представления чисел и величин в формулах и уравнениях. Синтаксис Python подразумевает, что имя переменной находится слева, а значение – справа.
Выведите значение x:
Python выводит 221, потому что именно это число получается в результате сложения 76 и 145.
В виде переменной можно представить любой тип данных, не только числа.
my_string = ‘Hello, World!’
my_flt = 45.06
my_bool = 5 > 9 #логический оператор оценивает выражение как истинное или ложное
my_list = [‘item_1’, ‘item_2’, ‘item_3’, ‘item_4’] my_tuple = (‘one’, ‘two’, ‘three’)
my_dict =
Попробуйте запросить одну из этих переменных. На экране появится значение этой переменной:
my_list = [‘item_1’, ‘item_2’, ‘item_3’, ‘item_4’] print(my_list)
[‘item_1’, ‘item_2’, ‘item_3’, ‘item_4’]
Переменная выделяет небольшую область памяти, которая принимает заданное значение.
Правила задания имен переменных
Существует ряд правил, которых следует придерживаться при наименовании переменных.
Для примера рассмотрим правильные и неправильные имена переменных:
Правильно
Неправильно
Выбирая имя для переменной, следует также учитывать регистр: my_int, MY_INT, My_Int и mY_iNt – не одна, а четыре разные переменные.
Примечание: Избегайте похожих имён переменных в рамках одной программы.
Кроме того, имя переменной должно отвечать условиям соглашения. При именовании переменной принято начинать имя со строчной буквы и использовать подчеркивание при разделении слов. Переменная, чье имя начинается с большой буквы или написано в верблюжьем регистре, будет считаться недействительным.
Правильно
Неправильно
Но самое главное правило – это быть последовательным. Если уж вы начали использовать в программе переменные, написанные в верблюжьем стиле, продолжайте следовать этому принципу до конца.
Читайте также: PEP 8 – официальный мануал по кодированию в Python
Переназначение переменной
Значение переменной (что видно из самого понятия) можно изменять.
Возможность переназначения переменной очень важна: это позволяет программе добавлять пользовательские значения в существующие переменные, вернуть переменной прежнее значение и т.п.
Попробуйте задать в переменной x число, а затем переназначить её и задать строку:
x = 76
print(x)
x = «8host»
print(x)
76
8host
Если бы программа была написана так:
x = 76
x = «8host»
print(x)
в результате на экране появилось бы только второе присвоенное значение, так как это последнее назначение:
Множественное присваивание переменной
Python позволяет присваивать одно значение нескольким переменным одновременно. Таким образом, вы можете инициализировать несколько переменных, а позже переназначить их.
Например, можно задать переменным x, y и z значение 0.
x = y = z = 0
print(x)
print(y)
print(z)
0
0
0
Теперь все три переменные имеют одинаковое значение и принадлежат к одной области памяти.
Python также позволяет присваивать несколько значений нескольким переменным в рамках одной строки. Например:
j, k, l = «8host», 1.05, 16
print(j)
print(k)
print(l)
8host
1.05
16
Как видите, переменной j было присвоено значение 8host, переменной k 1.05, l – 16.
Эта функция позволяет сократить код, и при этом сохранить его читабельность.
Глобальные и локальные переменные
При использовании переменной в программе важно иметь в виду её область видимости.
Область видимости переменной – это контекст, в котором она доступна в коде данной программы. Не все переменные доступны из всех частей программы: некоторые переменные являются глобальными, а некоторые – локальными.
Глобальные переменные объявлены вне функции, но доступны внутри функции. Локальные переменные объявлены внутри функции.
Рассмотрите пример таких переменных:
#Создайте глобальную переменную
glb_var = «global»
#Определите функцию
def var_function():
lcl_var = «local» #Создайте локальную переменную внутри функции
print(lcl_var)
#Вызовите функцию
var_function()
#Выведите глобальную переменную
print(glb_var)
local
global
Поскольку переменная glb_var является глобальной, мы можем сослаться на неё внутри функции var_function(). Отредактируйте предложенный выше код, чтобы сделать это:
glb_var = «global»
def var_function():
lcl_var = «local»
print(lcl_var)
print(glb_var) #Выводит glb_var внутри функции
var_function()
print(glb_var)
local
global
global
Теперь переменная glb_var выводится дважды: внутри и вне функции.
Попробуйте вызвать локальную переменную вне функции:
glb_var = «global»
def var_function():
lcl_var = «local»
print(lcl_var)
print(lcl_var)
NameError: name ‘lcl_var’ is not defined
Как видите, вы не можете вызвать локальную переменную вне функции, так как она существует только внутри функции.
Рассмотрим ещё один пример. Задайте глобальной и локальной переменной одно и то же имя:
num1 = 5 #Глобальная переменная
def my_function():
num1 = 10 #Локальная переменная с таким же именем, num1
num2 = 7 #Локальная переменная
print(num1) #Выведет локальную переменную num1
print(num2) #Выведет локальную переменную num2
#Вызывает my_function()
my_function()
#Выводит глобальную переменную num1
print(num1)
10
7
5
Поскольку локальная переменная num1 присвоена внутри функции, при вызове num1 появляется 10. При выводе глобальной переменной num1 (после вызова функции my_function()) появляется значение 5.
Оператор global позволяет определять глобальные переменные Python внутри функции:
def new_blog():
global blog = «8host» #Присваивает глобальную переменную
#Выводит глобальную переменную blog
print(blog)
Несмотря на то, что переменная blog была присвоена локально внутри функции new_blog(), она доступна вне функции благодаря оператору global. Потому при вызове print(blog) Python не выдаёт ошибку: переменная существует и вне, и внутри функции.
Примечание: Определение глобальных переменных внутри функции не очень часто используется, поскольку усложняет код.
Также следует помнить о том, что если вы ссылаетесь на переменную внутри функции, не присваивая ей значения, такая переменная будет глобальной. Для того чтобы создать локальную переменную, необходимо присвоить ей значение в теле функции.
Работая с переменными, важно определить, какие из них больше подходят этой программе: глобальные или локальные. Обычно лучше использовать локальные переменные; но если одна переменная используется в нескольких функциях, вы можете инициализировать глобальную переменную. Если вы работаете с переменной только в пределах одной функции или одного класса, лучше использовать её локально.
Получение имени переменной в виде строки
Этот поток обсуждает, как получить имя функции в виде строки в Python: Как получить имя функции в виде строки?
Как я могу сделать то же самое для переменной? В отличие от функций переменные Python не имеют __name__ атрибута.
Другими словами, если у меня есть переменная, такая как:
Используя python-varname пакет, вы можете легко получить имя переменных
В вашем случае вы можете сделать:
Или вы можете также попытаться получить имя переменной напрямую:
Я автор этого пакета. Пожалуйста, дайте мне знать, если у вас есть какие-либо вопросы, или вы можете отправить вопросы на GitHub.
Единственными объектами в Python, которые имеют канонические имена, являются модули, функции и классы, и, конечно, нет никакой гарантии, что это каноническое имя будет иметь какое-либо значение в любом пространстве имен после определения функции или класса или импорта модуля. Эти имена также могут быть изменены после создания объектов, поэтому они не всегда могут быть особенно заслуживающими доверия.
То, что вы хотите сделать, невозможно без рекурсивного обхода дерева именованных объектов ; имя является односторонней ссылкой на объект. Обычный или разнообразный объект Python не содержит ссылок на его имена. Представьте, что каждому целому числу, каждому дикту, каждому списку, каждому логическому значению требуется поддерживать список строк, которые представляют имена, ссылающиеся на него! Это был бы кошмар реализации, с небольшой пользой для программиста.
Даже если значения переменных не указывают обратно на имя, у вас есть доступ к списку каждой назначенной переменной и ее значению, поэтому я удивлен, что только один человек предложил перебрать там поиск вашего имени переменной.
Мое объяснение может быть немного слишком многословным (возможно, мне следовало бы использовать меньше слов «foo»), но вот как это будет выглядеть в коде ( обратите внимание, что если более одной переменной присвоено одно и то же значение, вы будете получить оба из этих имен переменных ):
Если вы вызываете эту функцию из другой функции, что-то вроде:
Смотрите пример здесь: ideone
В Python 3.8 можно просто использовать функцию отладки f-строки:
На python3 эта функция получит самое внешнее имя в стеке:
Это полезно в любом месте кода. Пройдет обратный стек в поисках первого совпадения.
Я не верю, что это возможно. Рассмотрим следующий пример:
Вот один из подходов. Я не рекомендовал бы это для чего-то важного, потому что это будет довольно хрупким. Но это может быть сделано.
Создайте функцию, которая использует inspect модуль для поиска исходного кода, который его вызвал. Затем вы можете проанализировать исходный код, чтобы определить имена переменных, которые вы хотите получить. Например, вот вызываемая функция, autodict которая принимает список переменных и возвращает имена переменных словаря, отображающие их значения. Например:
Проверка самого исходного кода лучше, чем поиск с помощью locals() или, globals() поскольку последний подход не говорит вам, какие из переменных вам нужны.
В любом случае, вот код:
Очевидным недостатком этого вида магии является то, что она делает предположения о том, как структурирован исходный код. И, конечно, он не будет работать вообще, если он запускается внутри интерпретатора.
Я написал пакет волшебства, чтобы творить магию такого рода. Ты можешь написать:
и передать это конструктору dataframe. Это эквивалентно:
Если вы хотите написать свою собственную функцию, это можно сделать так, чтобы вы могли проверить переменную, определенную в локальных, а затем проверить глобальные переменные. Если ничего не найдено, вы можете сравнить id (), чтобы увидеть, указывает ли переменная на то же место в памяти.
Python не сохраняет имя в левой части назначения в назначенном объекте, потому что:
Наилучшим подходом было бы просто попросить звонящего передать (необязательный) список имен. Если ввод ‘. ‘,’. ‘ слишком громоздок, вы можете принять, например, одну строку, содержащую список имен через запятую (как, например, namedtuple делает).
Как работают переменные в Python
Переменная — это именованная область памяти. После того как вы дали имя области, появляется возможность обращаться к данным, что в ней хранятся.
Каждый элемент данных в Python является объектом определенного типа или класса. Когда, в процессе выполнения программного кода, появляется новое значение, интерпретатор выделяет для него область памяти — то есть создаёт объект определенного типа (число, строка и т.д.). После этого Python записывает в свой внутренний список адрес этого объекта.
Но как теперь получить доступ к созданному объекту? 🤷♀️
Для этого и существуют переменные — они дают возможность удобно работать с объектами используя имена вместо адресов.
Простыми словами переменная в Python — это просто имя, прикрепленное к определенному объекту
a = 123 print(a) > 123 print(type(a)) print(id(a)) 1827204944
🍏 🍊 Приведем простую аналогию: Представьте, что у вас есть много непрозрачных бутылок, а сами вы занимаетесь производством фруктовых соков. Однажды вы выжали фрукты и в один сосуд налили апельсиновый сок, а во второй — яблочный. После этого ёмкости были запечатаны. Резонный вопрос: как теперь выяснить содержимое отдельно взятой бутылки?
Ответ: предварительно их подписать. Сделав это, вы будете точно знать, что находится в бутылках, а значит, сможете производить с ними дальнейшие операции: назначать цену, сортировать, отправлять на продажу и так далее.
Итак, ваш фреш-бизнес разросся, и для хранения соков пришлось арендовать склад, где каждая бутылка находится строго на своём месте. Теперь у вас есть ещё и специальные карточки: на каждой из них записаны наименование продукта и адрес этого продукта на складе. Когда требуется достать конкретную ёмкость с соком, вы смотрите на карточку, читаете номер ячейки, а затем идёте к обозначенному месту на складе и берёте оттуда нужную бутылку.
Переменные, объекты и ссылки
Для понимания работы переменных, необходимо разобрать, что происходит, когда вы создаете новую переменную и присваиваете ей значение?
В данном примере происходит следующее:
Важно : переменная в Python не хранит значение напрямую — она хранит лишь ссылку на объект
Теперь посмотрим что произойдет, если одной переменой присвоить другую переменную:
b = a print(id(a)) > 1827204576 print(id(b)) > 1827204576
Предположим, что в какой-то момент вы захотели поменять значение переменной b :
b = 500 print(id(a)) > 1827204576 print(id(b)) > 56754272
В данном примере Python создал новый объект типа int, и теперь переменная b ссылается на новый объект.
Рассмотрим еще один пример:
b = «tree» print(id(b)) > 54134048
b = «tree», переменная b теперь ссылается на новый объект строкового типа
На объект типа int со значением 500 больше никто не ссылается. Следовательно, он больше не доступен и будет удален сборщиком мусора (тем самым освободим немного памяти).
Идентификатор объекта (Object Identity)
Идентификатор объекта — это адрес объекта в памяти.
a = b = 1 print(id(a)) > 1593636784 print(id(b)) > 1593636784 print(id(1)) > 1593636784
Видно, что объект здесь всего один. А a и b — по-разному названные переменные, которые на него ссылаются. Проверить равенство идентификаторов можно с помощью оператора is :
Работа с переменными
Именование переменных
В языке Python имя переменной должно состоять только из цифр, букв и знаков подчеркивания. И не должно начинаться с цифры.
Это жёсткий внутренний закон языка, помимо которого есть свод более мягких, но не менее важных правил, и они говорят нам:
Список зарезервированных слов
В каждом языке есть зарезервированные слова. Такие слова имеют специальное значение, и поэтому запрещены для использования в качестве имён переменных. Вот список зарезервированных слов для Python:
False, class, finally, is, return, None, continue, for, lambda, try, True, def, from, nonlocal, whileand, del, global, not, with, as, elif, if, or, yield, assert, else, import, pass, break, except, in, raise.
Как объявить переменную
В Питоне не требуется специального объявления переменных. В момент присваивания значения, объявление происходит автоматически. А присваивание выглядит так:
Импорт переменной в Python
Чтобы импортировать переменную из другого файла, используем в начале текущего файла следующую конструкцию:
# файл main.py space_ship = ‘Millenium Falcon’ # файл second.py from main import space_ship print(space_ship) > Millenium Falcon
Проверка существования переменной
Чтобы выяснить, есть ли в программе переменная (например cat ), ищем вхождения строки с её названием в словарях, возвращаемых функциями locals() (локальная видимость) и globals() (глобальная видимость):
if «cat» in locals(): # … if «cat» in globals(): # …
Удаление переменной
Переменная удаляется, если передать её в качестве аргумента во встроенную функцию del() :
please_dont = ‘alive’ del(please_dont) print(please_dont) > Traceback (most recent call last): print(please_dont) NameError: name ‘please_dont’ is not defined
Что означает звездочка перед переменной?
Символ * перед именем переменной может означать несколько вещей.
status = [‘open’, ‘close’] print(status) > [‘open’, ‘close’] print(*status) > open close
def summer(*terms): sum = 0 for term in terms: sum = sum + term return sum print(summer(2)) > 2 print(summer(3, 3)) > 6 print(summer(4, 43, 1)) > 48
def setCreator(some_list): return <*some_list[1:]>weapons = [‘bow’, ‘pike’, ‘sword’, ‘dagger’] print(setCreator(weapons)) > <'dagger', 'pike', 'sword'>print(type(setCreator(weapons))) >
Область видимости: локальные и глобальные переменные
Сначала терминология. Область видимости или пространство имен — это место в программном коде, где переменной было присвоено значение.
Существуют три разные области видимости:
2 Нелокальная. Если внутри функции определена другая функция, то переменная внутри внешнего def будет нелокальной для def внутреннего. То есть сделать вот так не получится:
Поэтому для корректной работы нужно использовать ключевое слово nonlocal :
num = 42 def globalExample(n): res = n + num return res print(globalExample(1)) > 43
Статические переменные
Статическая переменная сохраняет свое значение между вызовами функций.
Звучит очень похоже на определение глобальной переменной, однако в том-то и дело, что статическая переменная может быть и локальной.
Самих по себе статических переменных в Питоне нет