Что возвращает функция locals python

Подробно о locals() и globals() в Python

Метод locals() обновляет и возвращает словарь текущей локальной таблицы символов.

Таблица символов — это структура данных, поддерживаемая компилятором, которая содержит всю необходимую информацию о программе.

К ним относятся имена переменных, методы, классы и т. д.

В основном есть два вида таблиц символов.

В глобальной таблице символов хранится вся информация, относящаяся к глобальной области действия программы, доступ к ней в Python осуществляется с помощью метода globals().

Глобальная область видимости содержит все функции и переменные, которые не связаны ни с каким классом или функцией.

Точно так же в локальной таблице символов хранится вся информация, относящаяся к локальной области действия программы, и доступ к ней в Python осуществляется с помощью метода locals().

Локальная область видимости может находиться внутри функции, внутри класса и т. д.

Синтаксис метода locals():

Метод locals() не принимает никаких параметров.

Метод locals() обновляет и возвращает словарь, связанный с текущей локальной таблицей символов.

Как locals() работает в Python?

Примечание: таблица символов globals() и locals() для глобальной среды одинакова.

Пример как locals() работает внутри локальной области?

Обновление значений словаря

В отличие от словаря globals(), который отражает изменение фактической глобальной таблицы, словарь locals() не может изменять информацию внутри таблицы locals.

Метод globals() возвращает словарь текущей глобальной таблицы символов.

Словарь таблицы глобальных переменных — это словарь текущего модуля (внутри функции это модуль, в котором он определен, а не модуль, в котором он вызывается).

Синтаксис метода globals():

Метод globals() не принимает никаких параметров и возвращает словарь текущей глобальной таблицы символов.

Как метод globals() работает в Python?

Вывод показывает все глобальные переменные и другие символы для текущей программы.

Как изменить глобальную переменную с помощью global()?

Источник

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 👈

Источник

Пространства имен и области видимости в 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 должен отслеживать все эти объекты и их имена, и помогают ему в этом пространства имен.

Источник

Использование функции Python Locals ()

Сегодня мы будем смотреть на использование функции Python Locals (). Это еще одна полезная функция, которая весьма полезна для отладки вашей программы.

Сегодня мы будем смотреть на использование Python Местные жители () функция. Это еще одна полезная функция, которая весьма полезна для отладки вашей программы.

Функция Locals () дает нам текущую локальную таблицу символов, как словарь.

Теперь, если вы не уверены в том, что именно локальная таблица символов сохраняет чтение. Пойдем шаг за шагом, начиная с определения таблицы символов.

Что такое символ стол?

Ну, таблица символов – это таблица, состоящая из информации относительно разных символов. Здесь символ может означать что-либо – имя переменной, ключевое слово, имя функции и т. Д.

Они представляют все имена всех переменных, классов и функций в вашей программе.

Как правило, таблица символов не только состоит из названий этих объектов, но и другая полезная информация, как и тип объекта, объем и т. Д.

Теперь, когда вы знаете, что означает символ таблицы, давайте приходим к классам таблиц символов.

Есть 2 типа таблиц символов, для программы Python:

Это две таблицы символов, определенные на основе глобального объема и локального (текущего) объема.

Когда мы ссылаемся на локальный символ таблицы, мы ссылаемся на всю информацию в нашем Текущий Область применения, когда интерпретатор выполняет нашу линию кода по линии.

Что именно делает функцию Python Locals ()?

Теперь, что за Местные жители () Функция делает, это просто вставить информацию о локальной таблице символов на консоли, на этой области, где Местные жители () был назван!

Так что это естественно означает, что выпуск Python Местные жители () Будет словарь всех переменных имен и атрибутов, объем и т. Д.

Например, если у вас есть файл под названием main.py Отказ Давайте поставить Местные жители () Как наше единственное утверждение, и посмотрите, что происходит. Мы должны получить всю связанную информацию в Главная Область (в этом случае это так же, как глобальный объем)

Ну, мы могли видеть некоторые атрибуты Главная Модуль (глобальный объем), который также включает в себя некоторые детали пакета!

Как некоторые из вас могут сразу реализовать, это так же, как глобал () Здесь, поскольку оба относятся к тому же глобальному объему.

Вызов местных жителей () от локальной области

Теперь давайте рассмотрим звонить Местные жители () Внутри местного охвата, от функции.

Вызов местных жителей () внутри функции

Здесь есть заметное изменение изнутри Веселье (A, B) Отказ Здесь локальная таблица символов состоит только из имени, связанных с этой функцией.

Поскольку локальный объем не является частью пакета, нет информации пакета, и это содержит только переменные, связанные с функцией, а также аргументы.

Также обратите внимание, что глобальная переменная Global_var является частью таблицы глобального символа и отсутствует в локальной таблице символов в результате!

Вызов местных жителей () внутри класса

Это похоже на вызов из функции, но это будет содержать все методы класса и соответствующие атрибуты.

Давайте быстро посмотрим, используя пример.

Здесь мы будем звонить Местные жители () Внутри класса после определения всех методов классов. Таким образом, эти методы класса также должны быть частью локальной таблицы символов.

Действительно, как вы можете видеть, Местные жители () Дает соответствующие методы!

Когда мы называем Местные жители () Из-за корпуса класса мы получим имя модуля, имя класса и переменные классов.

Таблица глобального символа не имеет ничего особенного, как и ожидалось.

Заключение

В этой статье мы узнали, как мы можем получить информацию от местного объема, используя Местные жители () функция. Это возвращает словарь всех полезных имен и атрибутов из локальной таблицы символов и очень полезен для отладки.

Источник

Python locals: How to Use locals() Function in Python

Python locals() is an inbuilt function that returns the dictionary containing the variables defined in a local namespace. Calling locals ( ) in a global namespace is the same as calling the globals() and returns the dictionary representing the global namespace of the module.

Python locals()

The locals() method updates and returns the dictionary of the current local symbol table.

The symbol table is the data structure maintained by the compiler which contains all necessary information about the program.

These include variable names, methods, classes, etc.

There are mainly two kinds of symbol tables.

A Global symbol table stores all the information related to a global scope of the program, and is accessed in the Python using the globals() method.

The global scope contains all the functions, variables that are not associated with any class or function.

Likewise, the Local symbol table stores all information related to the local scope of the program, and is accessed in Python using the locals() method.

The local scope could be within the function, within a class, etc.

Syntax

See the following syntax.

The locals() method doesn’t take any parameters.

The locals() method updates and returns the dictionary associated with a current local symbol table.

The globals() and locals() symbol table for the global environment is the same.

See the following example.

In the above example, we have defined the two functions.

In the collab() function, we did not define any variable. So that function does not contain any local variable.

In the localscollab() function, we have defined one local variable called the cross. So, when the function returns the locals(), it will contain the cross variable.

See the following output.

Updating locals() dictionary values

Okay, now let’s try to update the local value and then read the value.

See the following output.

Unlike, the globals() dictionary which reflects the change to the actual global table, whereas the locals() dictionary may not change the information inside the locals table.

Get the filename of the current program

Okay, let’s write the code that will return the current file name using the locals() function. My current file name is app.py.

Python locals() inside class

Let’s see the outcome when the locals() function is called inside the class body.

When invoked inside a class body, the locals() contains the module name, class name, and class variables.

Difference between locals() and globals()

There is no difference because we are executing the locals() and globals() in the current module itself.

We can see the difference when we call these functions inside a method or class.

In which context and scope we are using to decide the values of these functions.

There is also the third function called vars().

If the locals() is called inside a function it constructs a dictionary of the function namespace as of that moment and returns it, any further name assignments are not reflected in the returned dictionary, and any assignments to a dictionary are not reflected in an actual local namespace.

Finally, Python locals() Example Tutorial is over.

Источник