что такое global в питоне
Область видимости в Python
Вы, наверное, не раз слышали термин область видимости, когда изучали программирование. Это весьма важная тема, незнание которой может привести к достаточно запутанным ошибкам. Область видимости указывает интерпретатору, когда наименование (или переменная) видимо. Другими словами, область видимости определяет, когда и где вы можете использовать свои переменные, функции, и т.д. Если вы попытаетесь использовать что-либо, что не является в вашей области видимости, вы получите ошибку NameError.
Python содержит три разных типа области видимости:
Локальная область видимости
Локальная область видимости наиболее часто используется в Python. Когда мы создаем переменную в блоке кода, она будет разрешена при помощи ближайшей области видимости, или областей. Группирование всех этих областей известно как среда блоков кода. Другими словами, все назначения выполняются в локальной области по умолчанию. Если вам нужно что-то другое, тогда вам нужно настроить свою переменную на глобальную или нелокальную область, которые мы рассмотрим немного позже. Сейчас мы создадим простой пример, используя интерпретатор Python, в котором демонстрируется назначение локальной области видимости.
Что такое global в питоне
Один из приемов, который часто используют в программировании — глобальные переменные. Но в Python глобальные переменные более детального объяснения. В этой статье вы узнаете, что такое global и зачем он нужен в Python.
Области имен (namespace) определяются блоками кода
Рассмотрим следующий кусок кода:
Что означает ключевое слово global в функции и что оно делает? Первое, что приходит в голову так это то, что переменная становится видимой изнутри функции. Но реальность куда сложнее.
Python-скрипт состоит блоков кода: тела функции и модулей. Например, следующем пример состоит из 3 блоков:
Область видимости
В первую очередь, под областью видимости переменной подразумевают такую область кода, в которой она видна. Программа может состоять из переменных с одинаковым именем, но будут использовать та
В Python область видимости определяется блоками кода. Когда имя используется в блоке, то оно разрешается (т.е. какое значение будет использоваться) ближайшей областью видимости. Перепишем тот код без использования global :
Все дело в связывании в Python
В Си-подобных языках переменные можно объявлять, показав компилятору, что она будет позже использоваться путем присваивания. В Python нет объявлений, но есть связывание (binding), когда значение ассоциируется с именем. Поэтому если нам нужна какая-то переменная, то мы инициализируем её сразу. А вот при присваивании нового значения в той же области видимости происходит повторное связывание (re-binding).
Операция “присваивание” — не единственная операция, которая производит связывание. Следующие конструкции также связывают имена и значения [1]:
В следующей программе сначала напечатается 10, затем 23:
Первое присваивание переменной foo происходит на верхнем модульном уровне. Присваивание внутри функции осуществляется в другом блоке (в функции). Несмотря на то, что используются одинаковые имена никакого повторного связывания не происходит, потому что связывания осуществляется в разных блоках.
Другой пример на Python:
Зачем нужен global в Python
Как использовать global и nonlocal переменные в Python
В этой статье мы рассмотрим глобальные и нелокальные переменные в Python и как их использовать, чтобы избежать проблем при написании кода.
Мы начнем с краткого руководства по областям видимости переменных, прежде чем мы расскажем, как и почему использовать глобальные и нелокальные переменные в ваших собственных функциях.
Области видимости в Python
Прежде чем мы сможем начать, мы сначала должны коснуться областей. Для тех из вас, кто не знаком, «область видимости» относится к контексту, в котором определяется переменная и как к ней можно получить доступ или изменить или, более конкретно, откуда она может быть получена.
И в программировании, как и в жизни, важен контекст.
Ссылаясь на Python прямо сейчас, вы можете сделать вывод из контекста, что я имею в виду язык программирования. Однако в другом контексте Python может быть ссылкой на змею или комедийную группу.
Как правило, переменные, определенные в функции или классе (как переменная экземпляра), по умолчанию являются локальными, а переменные вне функций и классов по умолчанию являются глобальными.
Локальные переменные в Python
Как и ожидалось, этот код выведет нам:
Но что происходит, когда мы перемещаем оператор печати за пределы функции?
Мы получаем ошибку:
Чтобы наша программа могла понимать переменную глобально (вне функции), нам нужно определить ее глобально.
Глобальные переменные в Python
Что, если вместо первоначального определения нашей переменной внутри функции мы переместим ее наружу и инициализируем там?
В этом случае мы можем ссылаться на нее вне функции, и все работает.
Это потому, что fruit мы изменили в функции shopping_list() создав новую локальную переменную. Мы создали ее, присвоили ей значение и после этого ничего не сделали. Это фактически полностью избыточный код. print() выводит значение глобальной переменной.
Ключевое слово global
Определив контекст переменной fruit, которую мы называем глобальной, мы можем затем переопределить и изменить его, насколько нам нравится, зная, что изменения, которые мы вносим в функцию, будут перенесены.
Мы также могли бы определить глобальную переменную в нашей функции и иметь возможность ссылаться на нее и получать к ней доступ в любом другом месте.
Мы могли бы даже объявить глобальную переменную в одной функции и получить к ней доступ в другой, не определяя ее как глобальную во второй:
Осторожность при использовании глобальных переменных
Всегда важно убедиться, что вы манипулируете переменной только в том контексте, который вам нужен, а в противном случае, оставив его в покое, это основной движущий принцип принципа инкапсуляции.
Мы быстро рассмотрим пример потенциальной проблемы, прежде чем перейти к некоторым из способов, которыми глобальные переменные могут быть полезны в вашем собственном коде:
Запустив приведенный выше код, мы получим следующий вывод:
Если мы изменим этот порядок или попытаемся повторить его позже, мы столкнемся с большой проблемой:
Теперь это выводит:
А именно, теперь fruit это строка, которая будет повторяться. Что еще хуже, эта ошибка не проявляется, пока, по-видимому, не станет слишком поздно. Первый код вроде бы работал нормально.
Ключевое слово nonlocal
То, что вам нужно быть осторожным, не означает, что глобальные переменные также не очень полезны. Глобальные переменные могут быть полезны всякий раз, когда вы хотите обновить переменную, не указывая ее в операторе возврата, например счетчик. Они также очень удобны с вложенными функциями.
Поскольку в большинстве наших примеров мы использовали списки покупок и фрукты, мы могли бы подумать о функции оформления заказа, которая суммирует сумму покупок:
Запустив приведенный выше код, мы получим результат:
Таким образом, глобальная переменная count по-прежнему является локальной для внешней функции и не влияет (или не существует) на более высоком уровне. Это дает вам некоторую свободу в добавлении модификаторов к вашим функциям.
Вы всегда можете подтвердить это, попробовав распечатать pct_off не с помощью метода подсчета покупок:
Заключение
Ключевое слово global
В этой статье вы узнаете, для чего нужно ключевое слово global и когда его использовать. А еще мы подробнее поговорим о глобальных переменных.
Поэтому перед прочтением этой статьи ознакомьтесь со статьей «Глобальные, локальные и нелокальные переменные в Python».
Что это такое
Ключевое слово global позволяет изменять переменную вне текущей области видимости в Python. global используется для создания глобальной переменной и изменения ее в локальной области видимости.
Что нужно знать прежде, чем работать с global
Как использовать global
Пример 1. Получаем доступ к глобальной переменной внутри функции
Вывод:
Все работает! Но что если нам нужно изменить глобальную переменную внутри функции?
Пример 2. Изменяем глобальную переменную внутри функции
Вывод:
Python сообщает нам, что мы использовали локальную переменную c до ее объявления. Дело в том, что получить доступ к глобальной переменной внутри функции мы можем, а вот изменять ее в локальной области видимости — уже нет.
Пример 3. Изменяем глобальную переменную внутри функции с помощью global
Вывод:
В приведенной выше программе мы определяем c как глобальную переменную внутри функции add() с помощью ключевого слова `global`.
Глобальные переменные в модулях Python
В Python принято создавать единый модуль config.py для хранения глобальных переменных и обмена информацией между модулями Python в одной программе.
Вот как можно использовать глобальные переменные между модулями Python.
Пример 4. Используем глобальную переменную между модулями
Вывод:
Как использовать global во вложенных функция
Пример 5. Используем глобальные переменные во вложенных функциях
Вывод:
Как создать и объявить глобальную переменную в Python
Переменная, к которой может получить доступ другой блок, называется глобальной переменной. Его можно определить вне блока. Другими словами, глобальная переменная определяется вне функции, и мы можем получить к ней доступ внутри функции.
С другой стороны, переменная, определенная в блоке и доступная для этого блока, называется локальной переменной. К такой переменной можно получить доступ только в определенном блоке.
Давайте разберемся как создать и объявить глобальную переменную в Python и посмотрим примеры локальной и глобальной переменных.
Пример локальной переменной:
Переменная определяется внутри функции и может использоваться только в определенной функции, поэтому природа переменной называется локальной переменной. Мы не можем получить к ним доступ в других функциях.
Чтобы преодолеть эту проблему, мы используем глобальные переменные. Давайте разберемся в примере глобальной переменной.
В приведенном выше коде мы определили две глобальные переменные a и b вне функций. Мы использовали их внутри функций sum() и sub(). Обе функции вернули результат при вызове.
Если мы определим локальную переменную с таким же именем, она напечатает значение, которое находится внутри функции, а затем значение глобальной переменной.
Мы определили локальную переменную с тем же именем, что и глобальная переменная; сначала напечатали локальную переменную, а затем значение глобальной переменной.
Глобальное ключевое слово
Python предоставляет глобальное ключевое слово, которое используется для изменения значения глобальной переменной внутри функции. Это полезно, когда мы хотим изменить значение глобальной переменной или присвоить другое значение. Ниже приведены несколько правил для определения глобальных переменных.
Правила глобальных ключевых слов:
Пример – без глобального ключевого слова:
В приведенном выше коде возникла ошибка, поскольку мы пытались присвоить значение глобальной переменной. Мы можем изменить значение глобального значения внутри функции, используя ключевое слово global.
Пример – с глобальным ключевым словом:
В приведенном выше примере мы определили переменную c в функции mul() с помощью ключевого слова global. Значение c умножается на 10; следовательно, возвращается 200. Мы видим в выходных данных, что изменение значения внутри функции отражается на значении вне глобальной переменной.
Глобальные переменные в модулях Python
Преимущество ключевого слова global заключается в создании глобальных переменных и совместном использовании их между различными модулями. Например, мы создаем name.py, который состоит из глобальных переменных. Если мы изменим эти переменные, то это изменение отразится повсюду. Давайте разберемся в следующем примере.
Код – 1: Создайте файл name.py для хранения глобальных переменных.
Код – 2: Создайте файл change.py для изменения глобальных переменных.
Здесь мы изменили значение a, b и msg. Эти глобальные переменные были определены в файле name.py, и мы импортировали name и получили доступ к этим переменным.
Код – 3: Создайте файл result.py для печати измененных глобальных переменных.
Ключевое слово global во вложенных функциях
Мы можем использовать ключевое слово global внутри вложенной функции. Мы должны объявить переменную, используя ключевое слово global внутри вложенной функции. Давайте разберемся в следующем примере.
В приведенном выше коде значение внутри add() принимает значение локальной переменной x = 15. В функции modify() мы присвоили x = 20 с помощью ключевого слова global. Это изменение отражено в переменной функции add().