Введение в глобальные и локальные переменные в Python

Python обрабатывает переменные очень нестандартным образом. В то время как многие языки программирования по умолчанию считают переменные глобальными (если только они не объявлены как локальные), Python считает переменные локальными, если они не объявлены наоборот. Основная причина, по которой Python считает переменные по умолчанию локальными, заключается в том, что использование глобальных переменных обычно считается плохой практикой кодирования.

Таким образом, при программировании на Python, когда определение переменных происходит внутри функции, они по умолчанию являются локальными. Любые модификации или манипуляции, которые вы делаете с этой переменной в теле функции, останутся только в пределах области действия этой функции. Или, другими словами, эти изменения не будут отражены ни в какой другой переменной вне функции, даже если переменная имеет то же имя, что и переменная функции. Все переменные существуют в области действия функции, в которой они определены, и содержат это значение. Чтобы получить практический опыт работы с переменными и проектами Python, попробуйте наши сертификаты по науке о данных от лучших университетов США.

В этой статье давайте рассмотрим понятие локальных и глобальных переменных в Python, а также то, как вы определяете глобальные переменные. Мы также рассмотрим нечто, известное как «нелокальные переменные».

Читать дальше!

Глобальные и локальные переменные в Python

Давайте рассмотрим пример, чтобы понять, как глобальные значения могут использоваться в теле функции в Python:

Программа:

Функция определения():

печать (строка)

string = «Я люблю Python!»

функция()

Выход

Я люблю Питон!

Как видите, переменной string присвоено значение «Я люблю Python!» перед вызовом функции func(). Тело функции состоит только из оператора печати. Поскольку в теле функции нет присваивания строковой переменной, вместо этого она примет значение глобальной переменной.

В результате на выходе будет любое глобальное значение строки переменной, в данном случае это «Я люблю Python!».

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

Программа:

Функция определения():

string = «Я люблю Java!»

печать (строка)

string = «Я люблю Python!»

функция()

печать (строка)

Выход:

Я люблю Яву!

Я люблю Питон!

В приведенной выше программе мы определили функцию func(), и внутри нее у нас есть строка переменной со значением «Я люблю Java!». Итак, эта переменная является локальной для функции func(). Затем у нас есть глобальная переменная, как и раньше, а затем мы вызываем функцию и оператор печати. Во-первых, функция запускается, вызывая оператор печати этой функции и выдавая вывод «Я люблю Java!» – это локальная переменная для этой функции. Затем, как только программа выходит из области действия функции, значение s изменяется на «Я люблю Python», и поэтому мы получаем обе строки в качестве вывода.

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

К счастью, Python не допускает такой путаницы и выдает ошибку. Вот как:

Программа:

Функция определения():

печать (строка)

string = «Я люблю Java!»

печать (строка)

string = «Я люблю Python!»

функция()

Вывод (ошибка):

—————————————————————————

UnboundLocalError Traceback (последний последний вызов)

<ipython-input-3-d7a23bc83c27> в <модуле>

5

6 строка = «Я люблю Python!»

---> 7 функция()

<ipython-input-3-d7a23bc83c27> в func()

1 определение функции():

---> 2 печатать(строка)

3 строка = «Я люблю Java!»

4 печать (строка)

5

UnboundLocalError: ссылка на локальную переменную 's' перед назначением

Очевидно, Python не позволяет переменной быть одновременно глобальной и локальной внутри функции. Итак, это дает нам локальную переменную, так как мы присваиваем значение строке в функции func(). В результате первый оператор печати показывает уведомление об ошибке. Все переменные, созданные или измененные в рамках любой функции, являются локальными, если только они не были явно объявлены как «глобальные».

Определение глобальных переменных в Python

Ключевое слово global необходимо, чтобы сообщить Python, что мы обращаемся к глобальным переменным. Вот как:

Программа:

Функция определения():

глобальная строка

печать (строка)

string = «Но я тоже хочу выучить Python!»

печать (строка)

string = «Я хочу изучать Java!»

функция()

печать (строка)

Выход:

Я ищу, чтобы изучить Java!

Но я тоже хочу выучить Python!

Но я тоже хочу выучить Python!

Как видно из вывода, Python распознает здесь глобальные переменные и соответствующим образом оценивает оператор печати, выдавая соответствующий вывод.

Использование глобальных переменных во вложенных функциях

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

Программа:

Функция определения():

язык = «английский»

определение функции1():

глобальный язык

язык = «испанский»

print("Перед вызовом func1: " + язык)

print("Вызов func1 сейчас:")

функция1()

print("После вызова func1: " + язык)

функция()

print("Значение языка в main: " + язык)

Выход:

Перед вызовом func1: английский

Вызов func1 сейчас:

После вызова func1: английский

Значение языка в основном: испанский

Как видите, ключевое слово global при использовании во вложенной функции func1 не влияет на переменную 'language' родительской функции. То есть значение сохраняется как «английский». Это также показывает, что после вызова func() в пространстве имен модуля существует переменная «язык» со значением «испанский».

Этот вывод согласуется с тем, что мы выяснили в предыдущем разделе: переменная, определенная внутри тела функции, всегда является локальной, если не указано иное. Однако должен быть механизм доступа к переменным, принадлежащим и к другим областям видимости.

Вот тут-то и появляются нелокальные переменные!

Нелокальные переменные

Нелокальные переменные — это новые типы переменных, представленные в Python3. Они имеют много общего с глобальными переменными и также чрезвычайно важны. Однако одно различие между нелокальными и глобальными переменными заключается в том, что нелокальные переменные не позволяют изменять переменные из области модуля.

Посмотрите следующие примеры, чтобы понять это:

Программа:

Функция определения():

глобальный язык

печать (язык)

язык = «немецкий»

функция()

Выход:

Немецкий

Как и ожидалось, программа возвращает «Франкфурт» в качестве выходных данных. Теперь давайте изменим «глобальный» на «нелокальный» и посмотрим, что произойдет:

Программа:

Функция определения():

неместный язык

печать (язык)

язык = «немецкий»

функция()

Выход:

Файл «<ipython-input-9-97bb311dfb80>», строка 2

неместный язык

^

SyntaxError: привязка для нелокального «языка» не найдена

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

Программа:

Функция определения():

язык = «английский»

определение функции1():

неместный язык

язык = «немецкий»

print("Перед вызовом func1: " + язык)

print("Вызов func1 сейчас:")

функция1()

print("После вызова func1: " + язык)

язык = «испанский»

функция()

print («язык» в основном: «+ язык»)

Выход:

Перед вызовом func1: английский

Вызов func1 сейчас:

После вызова func1: немецкий

'язык' в основном: испанский

Вышеприведенная программа работает, потому что переменная 'language' была определена до вызова функции func1(). Если он не определен, мы получим ошибку, как показано ниже:

Программа:

Функция определения():

#language = «английский»

определение функции1():

неместный язык

язык = «немецкий»

print("Перед вызовом func1: " + язык)

print("Вызов func1 сейчас:")

функция1()

print("После вызова func1: " + язык)

язык = «испанский»

функция()

print («язык» в основном: «+ язык»)

Выход:

Файл «<ipython-input-11-5417be93b6a6>», строка 4

неместный язык

^

SyntaxError: привязка для нелокального «языка» не найдена

Однако программа будет работать нормально, если мы заменим нелокальный на глобальный:

Программа:

Функция определения():

#language = «английский»

определение функции1():

глобальный язык

язык = «немецкий»

print("Перед вызовом func1`: " + язык)

print("Вызов func1 сейчас:")

функция1()

print("После вызова func1: " + язык)

язык = «испанский»

функция()

print («язык» в основном: «+ язык»)

Выход:

Перед вызовом func1: английский

Вызов func1 сейчас:

После вызова func1: немецкий

'язык' в основном: немецкий

Если вы заметили, значение глобальной переменной (язык) также изменяется в приведенной выше программе! Вот сила, которую несут с собой нелокальные переменные!

В заключение

В этой статье мы обсудили локальные, глобальные и нелокальные переменные в Python, а также различные варианты их использования и возможные ошибки, на которые следует обратить внимание. Имея под рукой эти знания, вы можете двигаться дальше и начать практиковаться с различными типами переменных и замечать тонкие различия.

Python — чрезвычайно популярный язык программирования во всем мире, особенно когда речь идет о решении проблем и задач, связанных с данными. В upGrad у нас есть база учащихся в более чем 85 странах, более 40 000 платных учащихся по всему миру, а наши программы затронули более 500 000 работающих специалистов. Наши курсы по науке о данных и машинному обучению были разработаны, чтобы помочь мотивированным студентам с любым опытом начать свой путь и преуспеть в области науки о данных. Наша комплексная карьерная поддержка на 360 градусов гарантирует, что после того, как вы зарегистрируетесь у нас, ваша карьера будет только продвигаться вверх. Свяжитесь с нами сегодня и испытайте силу взаимного обучения и глобальной сети!