в чем разница между globals locals и vars
globals, locals, vars, dir – инспектируем переменные
Программист на Python может узнать, какие именно переменные определенны в данный момент в интерпретаторе. Переменные можно разделить на локальные и глобальные. Глобальные определены на верхнем уровне кода снаружи функций и классов (грубо говоря без отступов слева). Локальные переменные наоборот определены внутри своих зон видимости, ограниченных классами и функциями.
Функция globals() выдает словарь глобальных переменных (ключ – имя переменной). Функция locals() возвращает словарь только локальных переменных. Пример:
Еще важно знать, что в список переменных входят не только простые переменные, которые вы определяете через знак присваивания, но и функции, классы и импортированные модули!
Через словари из locals() и globals() переменные можно не только читать, но и создавать, перезаписывать и удалять:
В глобальном контексте все три функции возвращают одно и тоже – глобальные переменные. Проверьте:
Без параметров dir() возвращает список имен переменных. В глобальном контексте – глобальных переменных, в локальном – список имен локальных переменных.
Все рассмотренные выше функции являются встроенными и не требуют импортов.
В отличие он некоторых других языков в Python блоки типа for, if, while, with не создают областей видимости (scope) для переменных, то есть переменная внутри и снаружи блока будет одна и та же:
Частая ошибка – затирание внешней переменной в цикле for:
Зоны видимости отделяются только функциями, классами и модулями. Здесь все переменные x – разные:
Самая широкая зона видимости называется builtin. В нее попадают все имена, известные интерпретатору в данный момент, включая вещи импортированные из других модулей.
Казалось бы мы затерли pi, но мы затерли его лишь в глобальной области видимости. Повторно импортируя pi, мы получаем старую переменную с тем же адресом, иными словами мы достаем ее из builtin области в global.
Специально для канала @pyway. Подписывайтесь на мой канал в Телеграм @pyway 👈
В чем разница между globals(), locals() и vars()?
1 ответ
Каждый из них возвращает словарь:
Если locals() вызывается вне функции, он возвращает фактический словарь, который является текущим пространством имен. Дальнейшие изменения в пространстве имен отражаются в словаре, а изменения в словаре отражаются в пространстве имен:
Обратите внимание, что __dict__ функции-это пространство имен атрибутов, а не локальные переменные. Для функции __dict__ не имеет смысла хранить локальные переменные, поскольку рекурсия и многопоточность означают, что одновременно может быть несколько вызовов функции, каждый из которых имеет свои собственные локальные переменные:
Похожие вопросы:
предположим, что этот код : >>> iterator=filter(lambda x: x % 3 == 0, [2, 18, 9, 22, 17, 24, 8, 12, 27]) >>> x=int() >>> locals() <'__package__': None, '__spec__': None.
Для метода sqldf пакета pandasql существует session/environment переменных, может быть locals() или globals(), может ли кто-нибудь дать мне знать, для чего он нужен? И любая ссылка на документ.
Я немного повозился с локальными и глобальными пространствами имен и обнаружил немного странное поведение. Если я это сделаю. len(globals().keys()) len(locals().keys()) Я получаю два разных.
В следующей обернутой функции: def info(self): a = 4 def _inner(): b = 5 print (‘LOCALS’,locals()) print (‘GLOBALS’, globals()) _inner() Он печатает следующее в python3.6 : LOCALS <'b': 5>GLOBALS.
Пространства имен и области видимости в Python
Данная статья посвящена теме пространств имен в Python. Это структуры, которые используются для организации символических имен, присваиваемых объектам в программе.
В Python понятие объекта является ключевым. Они везде! Фактически все, что программа Python создает или с чем работает, — это объект.
В более сложных программах вам предстоит создавать сотни или тысячи подобных имен, указывающих на конкретные объекты. Как же Python отслеживает все эти имена и предотвращает их путаницу?
Изучив данную статью, вы узнаете:
Пространства имен в Python
Пространство имен — это совокупность определенных в настоящий момент символических имен и информации об объектах, на которые они ссылаются. Вы можете рассматривать такое пространство как словарь, в котором ключи являются именами объектов, а значения — самими объектами. Каждая пара ключ-значение соотносит имя с соответствующим ему объектом.
Пространства имен — отличная штука! Будем использовать их чаще! — Тим Петерс в “Дзен Python”.
Как утверждает Тим Петерс, пространства имен — отличная штука, которую активно использует Python. Существует 4 типа пространств имен:
Они обладают разными жизненными циклами. По мере выполнения программы Python создает необходимые пространства имен и удаляет их, когда потребность в них пропадает. Как правило, в любой момент времени существует множество пространств имен.
Встроенное пространство имен
Встроенное пространство имен содержит имена всех встроенных объектов, которые всегда доступны при работе в Python. Вы можете перечислить объекты во встроенном пространстве с помощью следующей команды:
При запуске интерпретатор Python создает встроенное пространство имен. Оно сохраняется до тех пор, пока интерпретатор не завершит работу.
Глобальное пространство имен
Глобальное пространство имен содержит имена, определенные на уровне основной программы, и создаётся сразу при запуске тела этой программы. Сохраняется же оно до момента завершения работы интерпретатора.
Теперь, встречая понятие “глобальное пространство имен”, вы будете знать, что оно принадлежит основной программе.
Локальное и объемлющее пространства имен
Интерпретатор создает новое пространство имен при каждом выполнении функции. Это пространство является локальным для функции и сохраняется до момента завершения ее действия.
Функции не существуют независимо друг от друга только на уровне основной программы. Вы также можете определять одну функцию внутри другой.
Все эти пространства существуют до тех пор, пока выполняются соответствующие им функции. По завершении же этих функций Python может не сразу отозвать их из памяти, но при этом все ссылки на содержащиеся в них объекты сразу становятся недоступными.
Область видимости переменной
Наличие нескольких отличных пространств имен означает, что в процессе выполнения программы Python несколько разных экземпляров одного имени могут существовать одновременно. Пока каждый из них находится в собственном пространстве, все они обслуживаются по отдельности, и путаницы не происходит.
Но тут возникает вопрос. Предположим, что вы ссылаетесь на имя x в коде, а оно существует в нескольких пространствах. Как Python узнает, какое именно вы имеете в виду?
Ответ кроется в понятии области видимости имени, представляющей из себя часть программы, в которой данное имя обладает значением. Интерпретатор определяет эту область в среде выполнения, основываясь на том, где располагается определение имени и из какого места в коде на него ссылаются.
С более детальной информацией об области видимости в программировании вы можете ознакомиться на соответствующей странице Википедии.
Эта последовательность составляет суть правила областей видимости LEGB, как его обычно называют в публикациях о Python (хотя, на самом деле, данный термин не встречается в его официальной документации). Интерпретатор начинает поиски имени изнутри, последовательно переходя от локальной области видимости к объемлющей, затем к глобальной и в завершении к встроенной.
Примеры
Пример 1. Одно определение
В этом примере имя x определено только в одной области. Оно находится за пределами функций f() и g() и поэтому относится к глобальной области видимости.
Пример 2. Двойное определение
Пример 3. Тройное определение
Теперь выражение print() в строке 8 должно выбрать из трех возможных вариантов:
Пример 4. Отсутствие определения
Словари пространств имен Python
В первом разделе мы уже рекомендовали вам рассматривать пространство имен как словарь, в котором ключи — это имена объектов, а значения — сами объекты. По сути, для глобальных и локальных пространств они именно таковыми и являются! Python действительно реализует их как словари.
Примечание. Встроенное пространство работает не как словарь. Python реализует его как модуль.
Функция globals()
Встроенная функция globals() возвращает ссылку на текущий словарь глобального пространства имен. Ее можно использовать для обращения к объектам в этом пространстве. Посмотрим, как это будет выглядеть при запуске основной программы.
Теперь посмотрим, что происходит при определении переменной в глобальной области видимости.
Оператор проверки типов is в строке 6 подтверждает, что в действительности это один и тот же объект.
Этот способ создания и изменения объектов в глобальной области видимости выглядит немного оригинальным, учитывая, что с этой задачей справятся и простые выражения присваивания. Но он работает и прекрасно отражает идею.
Функция locals()
Между globals() и locals() существует небольшое отличие, о котором вам будет полезно узнать.
globals() возвращает актуальную ссылку на словарь, содержащий глобальное пространство имен. Это значит, что если вы вызываете globals() , сохраняете возвращаемое значение и после этого определяете дополнительные переменные, то эти новые переменные появятся в словаре, на который указывает сохраненное возвращаемое значение.
В этом примере g является ссылкой на словарь глобального пространства имен. После выражений присваивания в строках 8 и 9 x и y появляются в словаре, на который указывает g .
В свою очередь, locals() возвращает словарь, являющийся текущей копией локального пространства имен, а не ссылкой на него. Дальнейшие дополнения к локальному пространству не повлияют на предыдущее возвращаемое значение locals() до момента ее повторного вызова. Кроме того, вы не можете изменять объекты в текущем локальном пространстве имен, используя возвращаемое значение locals() .
В этом примере loc указывает на возвращаемое значение locals() , являющееся копией локального пространства. Выражение x = 20 в строке 6 добавляет x в локальное пространство, а не в копию, на которую указывает loc . Аналогично этому, выражение в строке 9 изменяет значение для ключа ‘s’ в копии, на которую указывает loc , но это никак не влияет на значение s в текущем локальном пространстве имен.
Это едва уловимое отличие может доставить вам хлопот, если вы его не запомните.
Изменение переменных вне области видимости
Как вам известно, передача аргументов функции в Python может проходить двумя способами: по значению и по ссылке. Иногда функция может изменить свой аргумент в среде вызова, внося коррективы в соответствующий параметр, а иногда у нее такой возможности нет:
Похожая ситуация возникает, когда функция пытается изменить переменную вне своей локальной области, ведь изменение неизменяемого объекта вне ее границ ей недоступно.
Функция может скорректировать объект изменяемого типа, находящийся за пределами ее локальной области видимости, если изменит его внутри:
Это похоже на процесс, при котором f() стремится модифицировать изменяемый аргумент функции.
Объявление global
Объявление nonlocal
Схожая ситуация наблюдается с определениями вложенных функций. Объявление global позволяет функции обращаться к объекту в глобальной области видимости и менять его. А что если вложенной функции необходимо изменить объект в объемлющей области? Рассмотрим пример:
Ключевое слово global не способствует решению этой ситуации:
Лучшие практики
Когда функция меняет данные вне локальной области, используя ключевые слова ( global или nonlocal ) или напрямую преобразуя изменяемый тип внутри, то это своего рода побочный эффект, аналогичный ситуации с изменением функцией одного из своих аргументов. Частая модификация глобальных переменных обычно не приветствуется ни в Python, ни в других языках программирования.
Как и со многими другими аспектами жизни, это, скорее всего, дело вкуса. Бывают ситуации, когда разумный подход к изменению глобальных переменных помогает уменьшить сложность программы.
По крайней мере, использование ключевого слова global в Python явно свидетельствует об изменении функцией глобальной переменной. Во многих других языках функция может менять глобальную переменную только посредством присваивания, не объявляя об этом каким-либо образом. Вследствие чего становится довольно сложно отследить, где происходит изменение глобальных данных.
В общем, изменение переменных за пределами локальной области видимости обычно не требуется. Почти всегда существует лучший способ — обычно с возвращаемыми значениями функции.
Заключение
Фактически все, что программа Python использует или с чем работает, — это объект. Даже будучи короткой, она создаст много разных объектов. А в более сложной программе их количество исчисляется тысячами. Python должен отслеживать все эти объекты и их имена, и помогают ему в этом пространства имен.
Почему параметры передаются за скобки () в globals(), locals() и vars() в Python?
Я очень новичок в Py, но я знаю синтаксическую функцию (param1. paramN) и не могу этого понять:
EDIT: спасибо всем за ваши ответы, у меня всего пара часов игры с Python
В ретроспективе это «obvious» globals() возвращает экземпляр, и я присоединяюсь к индексу, когда пишу globals (‘z’), но Dict возвращается по ссылке, потому что я могу изменить его, просто делая:
или. просто еще один член.:
Все «magic» было просто указателем на индекс 🙂
1 ответ
Я немного повозился с локальными и глобальными пространствами имен и обнаружил немного странное поведение. Если я это сделаю. len(globals().keys()) len(locals().keys()) Я получаю два разных результата, сначала я получаю 344 и тогда я получаю 346. Поэтому ради любопытства я хочу знать, какие.
Для метода sqldf пакета pandasql существует session/environment переменных, может быть locals() или globals(), может ли кто-нибудь дать мне знать, для чего он нужен? И любая ссылка на документ, когда мы должны использовать locals(), и когда мы должны использовать globals().
Попробуйте набрать просто globals() в интерпретаторе python и изучить результат.
Но если вы запустите этот код, то увидите, что на самом деле он принимает параметры и изменяет этот dict / list / whatever: z = 7 globals()[‘z’] = 8 print(«z=», z) # z= 8
Похожие вопросы:
Если я что-то оцениваю в Python: eval(a + b) Это позволит вычислить выражение с использованием текущей области видимости (как локальной, так и глобальной). То, что я разрабатываю, требует, чтобы.
Я немного повозился с локальными и глобальными пространствами имен и обнаружил немного странное поведение. Если я это сделаю. len(globals().keys()) len(locals().keys()) Я получаю два разных.
Для метода sqldf пакета pandasql существует session/environment переменных, может быть locals() или globals(), может ли кто-нибудь дать мне знать, для чего он нужен? И любая ссылка на документ.
предположим, что этот код : >>> iterator=filter(lambda x: x % 3 == 0, [2, 18, 9, 22, 17, 24, 8, 12, 27]) >>> x=int() >>> locals() <'__package__': None, '__spec__': None.
В следующей обернутой функции: def info(self): a = 4 def _inner(): b = 5 print (‘LOCALS’,locals()) print (‘GLOBALS’, globals()) _inner() Он печатает следующее в python3.6 : LOCALS <'b': 5>GLOBALS.
Подробно о locals() и globals() в Python
Метод locals() обновляет и возвращает словарь текущей локальной таблицы символов.
Таблица символов — это структура данных, поддерживаемая компилятором, которая содержит всю необходимую информацию о программе.
К ним относятся имена переменных, методы, классы и т. д.
В основном есть два вида таблиц символов.
В глобальной таблице символов хранится вся информация, относящаяся к глобальной области действия программы, доступ к ней в Python осуществляется с помощью метода globals().
Глобальная область видимости содержит все функции и переменные, которые не связаны ни с каким классом или функцией.
Точно так же в локальной таблице символов хранится вся информация, относящаяся к локальной области действия программы, и доступ к ней в Python осуществляется с помощью метода locals().
Локальная область видимости может находиться внутри функции, внутри класса и т. д.
Синтаксис метода locals():
Метод locals() не принимает никаких параметров.
Метод locals() обновляет и возвращает словарь, связанный с текущей локальной таблицей символов.
Как locals() работает в Python?
Примечание: таблица символов globals() и locals() для глобальной среды одинакова.
Пример как locals() работает внутри локальной области?
Обновление значений словаря
В отличие от словаря globals(), который отражает изменение фактической глобальной таблицы, словарь locals() не может изменять информацию внутри таблицы locals.
Метод globals() возвращает словарь текущей глобальной таблицы символов.
Словарь таблицы глобальных переменных — это словарь текущего модуля (внутри функции это модуль, в котором он определен, а не модуль, в котором он вызывается).
Синтаксис метода globals():
Метод globals() не принимает никаких параметров и возвращает словарь текущей глобальной таблицы символов.
Как метод globals() работает в Python?
Вывод показывает все глобальные переменные и другие символы для текущей программы.