В этой статье вы познакомитесь с основами использования глобальных переменных: узнаете, что они из себя представляют, как их определять и работать с ними.
Для начала мы напомним, как вообще объявляются переменные в Python и что означает термин «область видимости переменной».
Затем мы разберем различия между локальными и глобальными переменными и расскажем, как определить глобальную переменную и как использовать ключевое слово global.
Что такое переменные в Python и как их создавать — введение для начинающих
Вы можете представлять себе переменные как некие контейнеры для хранения информации.
Переменные — это контейнеры для хранения данных, информации и различных значений, которые мы хотели бы сохранить в памяти компьютера. Мы можем ссылаться на них или даже манипулировать ими в какой-то момент жизни программы.
У переменной есть символическое имя. Вы можете представлять это имя как некую метку на контейнере хранилища, которая действует как ее идентификатор.
Имя переменной будет ссылкой и указателем на данные, хранящиеся внутри нее. Таким образом, нет необходимости запоминать детали ваших данных и информации. Всё, что вам нужно, это сослаться на имя переменной, которая содержит эти данные в себе.
Давая переменной имя, убедитесь, что оно описывает данные, которые она содержит. Имена переменных должны быть четкими и понятными как для вас в будущем, так и для других разработчиков, с которыми вы, возможно, будете работать.
Безусловно, в самом начале обучения вы можете использовать названия переменных в духе a, b, c и т.д. Однако когда вы перейдете к написанию больших программ и начнете разрабатывать серьезные штуки, логичное название переменных станет необходимостью, иначе не то что кто-то другой — вы сами через несколько дней не поймете, что вы написали. Подробней про присваивание имен переменным можно узнать в статье «Факты и мифы об именах и значениях в Python».
Теперь давайте посмотрим, как на деле создавать переменные в Python.
Объявление переменной в Python
Интересно, что при объявлении переменных в Python вам не нужно указывать их тип данных, и это очень удобно.
Например, в языке программирования C вы должны явно указать тип данных, которые будут храниться в переменной. Допустим, вы хотите сохранить свой возраст в виде целого числа или типа int. Тогда на языке C вам нужно написать следующее:
#include <stdio.h>
int main(void)
{
int age = 28;
// 'int' - это тип данных
// 'age' - имя переменной
// 'age' может хранить целочисленные значения
// это положительные и отрицательные целые числа, а также 0
// '=' - оператор присваивания
// '28' - значение
}
А вот как вы могли бы написать то же самое на Python:
age = 28 #'age' - имя переменной или идентификатор # '=' - оператор присваивания #'28' - значение переменной 'age'
Намного проще, не правда ли? Имя переменной всегда находится слева, а значение, которое вы хотите присвоить, идет справа после оператора присваивания =.
Имейте в виду, что вы можете изменять значения переменных на протяжении всей жизни программы. Например, это можно сделать следующим образом:
my_age = 28
print(f"My age in 2022 is {my_age}.")
my_age = 29
print(f"My age in 2023 will be {my_age}.")
#output
#My age in 2022 is 28.
#My age in 2023 will be 29.
Вы сохраняете то же имя переменной, my_age, но меняете значение с 28 на 29.
Что такое «область видимости переменной» в Python?
Область видимости переменной — это та часть кода, где переменная доступна, открыта и видима.
Существует четыре типа области видимости для переменных Python, которые также известны как правило LEGB:
- Local (локальная область видимости)
- Enclosing (охватывающая)
- Global (глобальная)
- Built-in (встроенная)
В оставшейся части этой статьи мы сосредоточимся на изучении переменных с глобальной областью видимости и разберем разницу между локальной и глобальной областями.
Как определить локальную переменную в Python
Переменные, определенные внутри тела функции, имеют локальную область видимости. Это означает, что они доступны только внутри данной конкретной функции. Другими словами, они «локальны» для этой функции.
Вы можете получить доступ к локальной переменной, только вызвав функцию. Выглядит это следующим образом:
def learn_to_code():
# Создаем локальную переменную
coding_website = "Pythonist"
print(f"The best place to learn to code is with {coding_website}!")
# Вызываем функцию
learn_to_code()
#output
#The best place to learn to code is with Pythonist!
Посмотрите, что произойдет, если мы попытаемся получить доступ к этой переменной с локальной областью видимости из-за пределов тела функции:
def learn_to_code():
# Создаем локальную переменную
coding_website = "Pythonist"
print(f"The best place to learn to code is with {coding_website}!")
# Пытаемся вывести локальную переменную 'coding_website' вне функции
print(coding_website)
#output
#NameError: name 'coding_website' is not defined
Код вызывает ошибку NameError, потому что данная переменная «не видна» в остальной части программы. Она доступна только внутри функции, в которой была определена.
Как определить глобальную переменную в Python
Когда вы определяете переменную вне функции, например, в начале файла, она имеет глобальную область видимости и называется глобальной переменной.
Доступ к глобальной переменной возможен из любой точки программы.
Вы можете использовать её внутри тела функции, а также получить к ней доступ извне функции:
# Создаем глобальную переменную
coding_website = "Pythonist"
def learn_to_code():
# Используем переменную 'coding_website' внутри функции
print(f"The best place to learn to code is with {coding_website}!")
# Вызываем функцию
learn_to_code()
# Используем переменную 'coding_website' вне функции
print(coding_website)
#output
#The best place to learn to code is with Pythonist!
#Pythonist
Что же происходит, когда есть глобальная и локальная переменные, и у них одинаковые имена?
# Глобальная переменная
city = "Athens"
def travel_plans():
# Локальная переменная с тем же именем, что и у глобальной
city = "London"
print(f"I want to visit {city} next year!")
# Вызов функции. В выводе будет значение локальной переменной
travel_plans()
# Ссылка на глобальную переменную. В выводе будет значение глобальной переменной
print(f"I want to visit {city} next year!")
#output
#I want to visit London next year!
#I want to visit Athens next year!
Возможно, вы не ожидали, что код поведет себя таким образом. Вы могли думать, что значение переменной city изменится, когда мы присвоим ему другое значение внутри функции. Тогда при ссылке на глобальную переменную строкой print(f" I want to visit {city} next year!"), результатом было бы I want to visit London next year!, а не I want to visit Athens next year!. Однако при вызове функции она напечатала значение локальной переменной.
Затем, когда мы сослались на глобальную переменную вне функции, было напечатано значение, присвоенное глобальной переменной. Они просто никак не пересекались друг с другом.
Тем не менее, использование одного и того же имени переменной для глобальных и локальных переменных не считается хорошей практикой. Следите за тем, чтобы ваши переменные не имели одинаковых имен. Иначе вы можете получить весьма непредсказуемые результаты при запуске вашей программы.
Как использовать ключевое слово global в Python
Что же делать, если у вас есть глобальная переменная, но вы хотите изменить ее значение внутри функции?
Посмотрите, что произойдет, если мы попытаемся это сделать следующим образом:
# Глобальная переменная
city = "Athens"
def travel_plans():
# Это похоже на попытку доступа к глобальной переменной, определенной вне функции.
# Само по себе это работает прекрасно, как вы уже видели раньше.
print(f"I want to visit {city} next year!")
# Но когда мы пытаемся изменить значение глобальной переменной 'city' внутри функции
# и затем вывести его,
# выбрасывается ошибка
city = "London"
print(f"I want to visit {city} next year!")
# Вызов функции
travel_plans()
#output
#UnboundLocalError: local variable 'city' referenced before assignment
По умолчанию Python думает, что внутри функции вы хотите использовать локальную переменную.
И когда мы сначала пытаемся вывести значение переменной, а затем повторно присваиваем значение переменной, к которой мы пытаемся получить доступ, Python запутывается.
Чтобы изменить значение глобальной переменной внутри функции, нужно использовать ключевое слово global. К примеру, это можно сделать следующим образом:
# Глобальная переменная
city = "Athens"
# Выводим значение глобальной переменной
print(f"I want to visit {city} next year!")
def travel_plans():
global city
# Выводим начальное значение глобальной переменной
print(f"I want to visit {city} next year!")
# Присваиваем глобальной переменной другое значение внутри функции
city = "London"
# Выводим новое значение
print(f"I want to visit {city} next year!")
# Вызов функции
travel_plans()
# Выводим значение глобальной переменной
print(f"I want to visit {city} next year!")
Прежде чем ссылаться на глобальную переменную, нужно использовать ключевое слово global, иначе получите ошибку: SyntaxError: name 'city' is used prior to global declaration. Это значит, что вы попытались использовать переменную до того, как объявили её глобальной.
Ранее мы видели, что мы не можем получить доступ к переменным, созданным внутри функций, извне, поскольку они имеют локальную область видимости.
Ключевое слово global изменяет область видимости переменной, объявленной внутри функций. И тогда наш код будет работать следующим образом:
def learn_to_code():
global coding_website
coding_website = "Pythonist"
print(f"The best place to learn to code is with {coding_website}!")
# Вызов функции
learn_to_code()
# Доступ к переменной вне функции
print(coding_website)
#output
#The best place to learn to code is with Pythonist!
#Pythonist
Заключение
Теперь вы знаете, как определить глобальную переменную переменную в Python. Мы обсудили, что собой представляют глобальные переменные и чем они отличаются от локальных.
Надеемся, что данная статья была для вас полезной. Спасибо за чтение и успехов в написании кода!
Перевод статьи «Python Global Variables – How to Define a Global Variable Example».
