Python globals: Область видимости в Python

Область видимости в Python

Вы, наверное, не раз слышали термин область видимости, когда изучали программирование. Это весьма важная тема, незнание которой может привести к достаточно запутанным ошибкам. Область видимости указывает интерпретатору, когда наименование (или переменная) видимо. Другими словами, область видимости определяет, когда и где вы можете использовать свои переменные, функции, и т.д. Если вы попытаетесь использовать что-либо, что не является в вашей области видимости, вы получите ошибку NameError.

Python содержит три разных типа области видимости:

• Локальная область видимости
• Глобальная область видимости
• Нелокальная область видимости (была добавлена в Python 3)

Локальная область видимости

Локальная область видимости наиболее часто используется в Python. Когда мы создаем переменную в блоке кода, она будет разрешена при помощи ближайшей области видимости, или областей. Группирование всех этих областей известно как среда блоков кода. Другими словами, все назначения выполняются в локальной области по умолчанию. Если вам нужно что-то другое, тогда вам нужно настроить свою переменную на глобальную или нелокальную область, которые мы рассмотрим немного позже. Сейчас мы создадим простой пример, используя интерпретатор Python, в котором демонстрируется назначение локальной области видимости.

x = 10

def my_func(a, b):
print(x)
print(z)

my_func(1, 2)

Результат

10
Traceback (most recent call last):
File «<pyshell#19>», line 1, in <module>
my_func(1, 2)
File «<pyshell#18>», line 3, in my_func
print(z)
NameError: name ‘z’ is not defined

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

def my_func(a, b):
i = 2
print(x)


if __name__ == ‘__main__’:
x = 10
my_func(1, 2)
print(i)

Переменная i определена только внутри функции, так что при запуске кода мы получаем ошибку NameError. Давайте немного модифицируем первый пример. Разместим данный код в python-файл и попытаемся его запустить:

def my_func(a, b):
x = 5
print(x)


if __name__ == ‘__main__’:
x = 10
my_func(1, 2)
print(x)

1. Что, по-вашему, должно произойти?
2. Выдаст ли код цифру 10 дважды?

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

def my_func(a, b):
print(x)
x = 5
print(x)


if __name__ == ‘__main__’:
x = 10
my_func(1, 2)
print(x)

Кода вы запустите этот код, вы получите ошибку:

UnboundLocalError: local variable ‘x’ referenced before assignment

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

Есть вопросы по Python?

На нашем форуме вы можете задать любой вопрос и получить ответ от всего нашего сообщества!

Telegram Чат & Канал

Вступите в наш дружный чат по Python и начните общение с единомышленниками! Станьте частью большого сообщества!

Паблик VK

Одно из самых больших сообществ по Python в социальной сети ВК. Видео уроки и книги для вас!

Глобальная область видимости

Python содержит оператор global. Это ключевое слово Python. Оператор global объявляет переменную доступной для блока кода, следующим за оператором. Хотя вы и можете создать наименование, перед тем, как объявить его глобальным, я настоятельно не рекомендую этого делать. Давайте попробуем использовать глобальную область для исправления нашей ошибке из предыдущего примера:

def my_func(a, b):
global x
print(x)
x = 5
print(x)


if __name__ == ‘__main__’:
x = 10
my_func(1, 2)
print(x)

Выдача данного кода должна быть следующей:

Объявляя х как глобальный, мы говорим Python использовать первое объявление х для нашего первого оператора вывода в функции. Далее мы даем х новое значение – а именно 5, и выводим его еще раз, перед тем как выйти из функции. Обратите внимание на то, что х становится глобальной переменной, когда мы доходим до последнего оператора вывода в конце кода, и там х все еще равен 5. Давайте смешаем глобальную и локальную область видимости и поглядим, что из этого получится:

def my_func(a, b):
global c
b, a = a, b
d = ‘Mike’
print(a, b, c, d)


a, b, c, d = 1, 2, ‘c is global’, 4
my_func(1, 2)
print(a, b, c, d)

Здесь мы назначаем с в качестве глобальной переменной. Таким образом, «с» будет выводиться и внутри и снаружи нашей функции. Мы также меняем местами значения переменных а и b в функции, чтобы показать, что мы можем переназначить их внутри функции, не меняя их вне функции. Это показывает, что переменные а и b не являются глобальными. Если вы запустите этот код, вы увидите следующую выдачу:

2 1 c is global Mike
1 2 c is global 4

Я хочу обратить ваше внимание на то, что не нужно менять глобальные переменные внутри функции. Комьюнити Python объявило такую практику очень нежелательной, так как из-за этого исправление кода становится намного сложнее. Теперь, с пониманием основных принципов локальных и глобальных областей, мы можем перейти к нелокальной области non_local.

Область nonlocal

В Python 3 было добавлено новое ключевое слово под названием nonlocal. С его помощью мы можем добавлять переопределение области во внутреннюю область. Вы можете ознакомиться со всей необходимой на данный счет информацией в PEP 3104. Это наглядно демонстрируется в нескольких примерах. Один из самых простых – это создание функции, которая может увеличиваться:

def counter():
num = 0
def incrementer():
num += 1
return num
return incrementer

Если вы попробуете запустить этот код, вы получите ошибку UnboundLocalError, так как переменная num ссылается прежде, чем она будет назначена в самой внутренней функции. Давайте добавим nonlocal в наш код:

def counter():
num = 0
def incrementer():
nonlocal num
num += 1
return num
return incrementer

Результат работы:

c = counter()
print(c) # <function counter.<locals>.incrementer at 0x7f45caf44048>

c() # 1
c() # 2
c() # 3

Теперь наша возрастающая функция работает именно так, как мы от нее и ожидаем. Для заметки, тип такой функции называется closure (дословно – закрытие). Такая функция является блоком кода, который «закрывает» переменные nonlocal. Суть в том, что вы можете ссылать переменные, которые определены вне вашей функции. Обычно, nonlocal позволяет вам назначать переменные во внешней области, но не в глобальной. Так что вы не можете использовать nonlocal в функции подсчета, так как в таком случае она попытается передать функцию глобальной области. Попробуйте, и получите ошибку SyntaxError незамедлительно. Вместо этого, вам нужно использовать nonlocal во вложенной функции.

Подведем итоги

В данной статье мы смогли понять то, как переменная ссылается, используя ключевые слова Python global и nonlocal. Мы узнали, где мы можем их использовать и зачем. Мы также узнали кое-что о локальной области видимости. Хорошего дня и продолжайте экспериментировать!

Все, что вы хотели узнать про области видимости в Python, но стеснялись спросить

В преддверии старта нового потока по курсу «Разработчик Python», решили поговорить про области видимости в Python. Что из этого вышло? — Читайте в материале ниже.

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

Области видимости определяют, в какой части программы мы можем работать с той или иной переменной, а от каких переменная «скрыта». Крайне важно понимать, как использовать только те значения и переменные, которые нам нужны, и как интерпретатор языка себя при этом ведет. А еще мы посмотрим, как обходить ограничения, накладываемые областями видимости на действия с переменными. В Python существует целых 3 области видимости:

• Локальная
• Глобальная
• Нелокальная

Последняя, нелокальная область видимости, была добавлена в Python 3.

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

Локальная область видимости

Рассмотрим функцию, которая выведет список some_list поэлементно:

def print_list(some_list):
    for element in some_list:
        print(element)

Здесь element и some_list – локальные переменные, которые видны только внутри функции, и которые не могут использоваться за ее пределами с теми значениями, которые были им присвоены внутри функции при ее работе. То есть, если мы в основном теле программы вызовем print(element), то получим ошибку:

NameError: name 'element' is not defined

Теперь мы поступим следующим образом:

def print_list(some_list):
    for element in some_list:
        print(element) 

element = 'q'
print_list([1, 2, 3])
print(element) 

И получим:

1
2
3
q

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

def print_list(some_list):
    for element in sudden_list:
        print(element) 

sudden_list = [0, 0, 0]
print_list([1, 2, 3])

Результат:

0
0
0

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

Здесь важно поговорить о константах. Интерпретатору Python нет разницы как вы называете переменную, поэтому код выше будет лучше переписать в следующем виде:

SUDDEN_LIST = [0, 0, 0]

def print_list(some_list):
    for element in SUDDEN_LIST:
        print(element) 

print_list([1, 2, 3]) 

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

Глобальная область видимости

В Python есть ключевое слово global, которое позволяет изменять изнутри функции значение глобальной переменной. Оно записывается перед именем переменной, которая дальше внутри функции будет считаться глобальной. Как видно из примера, теперь значение переменной candy увеличивается, и обратите внимание на то, что мы не передаем ее в качестве аргумента функции get_candy().

candy = 5

def get_candy():
    global candy 
    candy += 1
    print('У меня {} конфет.'.format(candy))
    
get_candy()
get_candy()
print(candy)

В результате получим:

	У меня 6 конфет.
У меня 7 конфет.
7

Однако менять значение глобальной переменной изнутри функции – не лучшая практика и лучше так не делать, поскольку читаемости кода это не способствует. Чем меньше то, что происходит внутри функции будет зависеть от глобальной области видимости, тем лучше.

Лайфхак: Чтобы не мучиться с именованием переменных, вы можете вынести основной код программы в функцию main(), тогда все переменные, которые будут объявлены внутри этой функции останутся локальными и не будут портить глобальную область видимости, увеличивая вероятность допустить ошибку.

Нелокальная область видимости

Появилось это понятие в Python 3 вместе с ключевым словом nonlocal. Логика его написания примерно такая же, как и у global. Однако у nonlocal есть особенность. Nonlocal используется чаще всего во вложенных функциях, когда мы хотим дать интерпретатору понять, что для вложенной функции определенная переменная не является локальной, но она и не является глобальной в общем смысле.

def get_candy():
    candy = 5
    def increment_candy(): 
        nonlocal candy
        candy += 1
        return candy
    return increment_candy
    
result = get_candy()()
print('Всего {} конфет.'.format(result))

Результат:

Всего 6 конфет.

Насколько это полезно вам предстоит решить самостоятельно. Больше примеров вы можете найти здесь.

В качестве вывода можно сформулировать несколько правил:

1. Изнутри функции видны переменные, которые были определены и внутри нее и снаружи. Переменные, определенные внутри – локальные, снаружи – глобальные.
2. Снаружи функций не видны никакие переменные, определенные внутри них.
3. Изнутри функции можно изменять значение переменных, которые определены в глобальной области видимости с помощью спецификатора global.
4. Изнутри вложенной функции с помощью спецификатора nonlocal можно изменять значения переменных, которые были определены во внешней функции, но не находятся в глобальной области видимости.

Вот и все, надеюсь этот материал был вам полезен, и он пролил хоть немного света на то, как области видимости функционируют в Python. Разобравшись с областями видимости вы сделаете еще один наш на пути к созданию красивого и читаемого кода.

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

Python 3 — глобальные и локальные переменные: область видимости функций

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

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

Для создания переменных, обладающих локальной областью видимости, необходимо всего лишь поместить их в отдельный блок кода, изолированный от остальной программы. Чтобы увидеть локальную переменную в действии, достаточно инициализировать целочисленный объект с именем x и значением 100 в функции f, как это сделано в следующем примере:

def f():
    x = 100
    print(x)
f()

100

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

def f():
    x = 100
    print(x)
f()
print(x)

100
Traceback (most recent call last):
  File "main.py", line 5, in <module>
    print(x)
NameError: name 'x' is not defined

Так происходит из-за того, что внешняя часть программы ничего не знает о переменной x, поскольку содержит в себе совсем другое пространство имен. Пользоваться локальными объектами можно только в той области, где они были идентифицированы. В обратном же случае компилятор сообщит об ошибке, не сумев обнаружить необходимую переменную.

Глобальные переменные

Чтобы иметь возможность использовать некоторое значение в любой части программы, следует объявить глобальную переменную. Для этого понадобиться создать переменную отдельно от области кода, ограниченной определенным блоком кода, например, функцией. В следующем примере демонстрируется идентификация целочисленного типа данных под названием x, который позже выводится на экран при помощи метода print в функции f:

x = 100
def f():
    print(x)
f()
print(x)

100
100

Как можно заметить из результатов выполнения программы, значение 100 воспроизводится не только через f, но и с помощью обычного print. Таким образом, получение доступа к x осуществляется из любой части кода, благодаря глобальной области видимости подобного объекта. Но что будет, если попытаться изменить значение глобальной переменной в некой функции? Результаты такого эксперимента представлены в следующем фрагменте кода:

x = 100
def f():
    x = 200
f()
print(x)

100

Функция f присваивает значение 200 переменной с именем x, однако, вопреки ожиданиям, внешний метод print выводит число 100, которое принадлежало x изначально. Происходит так потому, что в данной программе создаются два разных объекта x с локальной, а также глобальной областью видимости. Исправить ситуацию поможет ключевое слово global:

x = 100
def f():
    global x
    x = 200
f()
print(x)

200

Пометив переменную x как global, можно обращаться к ее изначальному значению, которое было определено вне зоны действия функции f. Теперь после того как в x поместили число 200, вызов метода print выводит вполне ожидаемый результат, то есть измененное значение.

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

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

def my_abs(val):
    return -val if val < 0 else val
    return val + 1
x = -15
x = my_abs(x)

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

Итак, для обращения к глобальной переменной внутри функции f необходимо использовать ключевое слово global перед ее идентификатором. Но что если требуется вызывать совсем не глобальную, а переменную, которая была определена во внешнем методе, являясь при этом локальной для другого пространства имен, находящегося на уровень выше? Следующий код демонстрирует попытку взаимодействия со значением из внешней функции f1 в методе f2:

def f1():
    x = 100
    def f2():
        x = 200
    f2()
    print(x)
f1()

100

Несмотря на то, что переменной с таким же именем x было присвоено новое значение 200, в результате выполнения написанных методов на экране отобразилось 100. Как и в том случае с двумя разными переменными, локальной и глобальной, здесь имеется также два различных объекта, которые идентифицированы в отдельных блоках кода. Чтобы обратиться к объекту, который не является локальным, необходимо воспользоваться модификатором nonlocal:

def f1():
    x = 100
    def f2():
        nonlocal x
        x = 200
    f2()
    print(x)
f1()

200

Таким образом, в методе f2 осуществляется запись значения 200 в переменную x из функции f1. В результате подобных действий, вызов метода f1 из внешней части программы создает новую переменную x, значение которой меняется в f2 со 100 на 200 и выводится при помощи print.

Важно заметить, что конструкция nonlocal была добавлена только в 3-ей версии языка Python.

Видимость из загружаемого модуля

Теперь разберемся с видимостью глобальных переменных между загружаемыми модулями Python. Например, мы подключаем другой модуль с помощью команды import. Создадим файл “test.py” и в него запишем следующий код:

print('Загружается модуль test')
x = 100
def f():
    print('Из функции x=' + str(x))

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

Теперь создадим файл main.py, который и будем запускать. В нем мы импортируем модуль test, а так же создадим свою глобальную переменную x. После этого выведем значения глобальной переменной из test, вызовим функцию f, а так же проверим, что значение переменной в модуле main не изменилось:

x = 200
print('Из модуля main x=' + str(x))
import test
print('Из модуля test x=' + str(test.x))
print('Присваиваем значение 300')
test.x = 300;
print('Из модуля test x=' + str(test.x))
test.f()
print('Из модуля main x=' + str(x))

Из модуля main x=200
Загружается модуль test
Из модуля test x=100
Присваиваем значение 300
Из модуля test x=300
Из функции x=300
Из модуля main x=200

Мы в первой же строчке записали в x значение 200. Это было сделано, чтобы показать, что после того, как мы загрузим внешний модуль, значение этой переменной не изменится. Так и вышло. Обращаясь к переменной из загруженной библиотеки, удалось прочитать его и изменить значение.

Теперь модифицируем программу следующим образом:

x = 200
print('Из модуля main x=' + str(x))
from test import *
f()
print('Из модуля main x=' + str(x))
print('Присваиваем значение 300')
x = 300
f()
print('Из модуля main x=' + str(x))

Из модуля main x=200
Загружается модуль test
Из функции x=100
Из модуля main x=100
Присваиваем значение 300
Из функции x=100
Из модуля main x=300

В этом случае для загрузки мы использовали команду “from test import *”. Мы импортировали все переменные и функции. После загрузки модуля значение переменной x в модуле main изменилось. Но при вызове функции, мы получаем значение x из модуля test. После присвоения нового значения переменной x, значение, которое выводит функция f не изменяется.

Следует по возможности избегать подключение библиотек с помощью команды from библиотека import *, а подключать только необходимые функции — from библиотека import функция. При этом надо удостовериться, что эти имена не используются в основном модуле.

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

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

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

x = 100
print(x)
class c1:
    global x
    x = 200
    def __init__(self):
        global x
        x = 300
    def f(self):
        global x
        x = 400
print(x)
o1 = c1()
print(x)
o1.f()
print(x)

100
200
300
400

Мы объявили глобальную переменную x. Вывели значение переменной до и после объявления класса. Как видим значение изменилось. После того как мы создали объект класса, значение в очередной раз поменялось. Это произошло, потому что сработал конструктор класса – метод __init__. После вызова функции f у созданного объекта, значение стало 400. В Python использование global переменная и в функции класса, и в его конструкторе, и после описания класса дают возможность изменения глобальной переменной. Если убрать это объявление, то тогда выполнится присвоение локальной переменной.

Конечно же если мы определим локальную переменную в классе, то к ней не будет возможности доступа из другого класса:

class c1:
    x = 100
class c2:
    def f(self):
        print(x)
o = c2()
o.f()

Traceback (most recent call last):
  File "main.py", line 7, in <module> 
    o.f()
  File "main.py", line 5, in f
    print(x)
NameError: name 'x' is not defined

Для того, чтобы код работал, переменная x должна быль глобальной.

Заключение

Таким образом, область видимости переменных в языке программирования Python, является важной составляющей платформы. Правильное взаимодействие со всеми ее особенностями позволяет избежать множества довольно сложных ошибок. Для более безопасного контроля над видимостью отдельных объектов применяются ключевые слова global и nonlocal. Чтобы ознакомиться с дополнительными сведениями по данной теме, следует изучить PEP 3104.

global и nonlocal — tirinox.ru

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

def foo():
    print('x is', x)

x = 5
foo()  # напечает x is 5

Однако если в функции есть присваиваниие x после использования переменной x, то возникнет ошибка:

def foo():
    print('x is', x)
    x = 10

x = 5
foo()  # UnboundLocalError: local variable 'x' referenced before assignment

Обатите внимание, что присваивание бывает в следующих ситуациях:

• x = …
• x += …, x -= … и т.п.
• for x in …:
• with … as x:

Чтобы избежать ошибки, мы должны явно указать перед использованием x, что она относится к глобальной области видимости:

def foo():
    global x  # <-- тут
    print('x is', x)
    x = 10
    print('x is now', x)

x = 5
foo()  # ошибок не будет

Подобная проблема возникает и для вложенных функций, когда во внутренней функции мы хотим поймать в замыкание переменную из внушней функции, чтобы далее присвоить ей другое значение. Вот пример – функция, создающее увеличивающийся на 1 счечтик:

def make_inc():  # внешняя ф-ция
    total = 0     # счетчик
    def helper():  # внутр. ф-ция 
        total += 1  # тут присваивание переменной
        return total 
    return helper  

f = make_inc()

print(f())  # UnboundLocalError: local variable 'total' referenced before assignment

Тут нужно другое ключевое слово – nonlocal, которое укажет, что нужно искать переменную во внешней области видимости. Такой пример будет работать, как задумано:

def make_inc():
    total = 0
    def helper():
        nonlocal total  # <- тут
        total += 1
        return total
    return helper

f = make_inc()
print(f())

Почему мы редко видим global и nonlocal?
nonlocal – специфичная вещь, обычно вместо нее создают класс.
global потакает плохим практикам программирования. Менять глобальные переменные внутри функций – плохая практика.

📎 Пример.

def foo():
    global x
    print('x is', x)
    for x in range(2):
        ...
x = 5
foo()  # x is 5
foo()  # x is 1 (испортили из-за for)

Нет ошибок выполнения, но есть логическая ошибка! После первого вызова foo() мы испортили глобальную переменную x, она стала 1 (последним значением в цикле). Надо было просто называть переменные разными именами, и global не понадобится!

Специально для канала @pyway. Подписывайтесь за новыми статьями. Будет интересно!

1 732

Область видимости в Python

Вы здесь:
Главная — Python — Основы Python — Область видимости в Python

Для понимания особенностей языка важно разбираться в том, как работает область видимости переменных.

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

Локальная область видимости

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

Вот пример:


def some_func():

  r = 10   # создаем локальную переменную

  print(r)

some_func()

print(r) # NameError: name 'r' is not defined - переменная не определена 


Функция внутри функции

В примере выше переменная r доступна только внутри той функции, в которой она определена, т.е. не доступна снаружи, но она будет доступна для любой функции, которая находится внутри данной.

Пример:


def some_func():

  r = 10   # создаем локальную переменную

  

  def inner_func():

    print(r) # функция 

    

  inner_func()

some_func()



Глобальная область видимости:

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

Глобальные переменные — это переменные доступные в любой области видимости. Посмотрите на пример далее:


r = 10   # создаем глобальную переменную

def some_func():

  

  def inner_func():

    print(r) # функция 

    

  inner_func()

some_func()


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

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

Именование переменных

Переменная с одним и тем же именем, но в разных областях видимости в Python рассматривается по разному.

Вот пример:


r = 10   # создаем глобальную переменную

def some_func():

  

  def inner_func():

    r = 20

    print(r) # локальная область видимости, в ней у переменной другое значение

    

  inner_func()

some_func()


Ключевое слово global в Python

Использование ключевого слова global необходимо тогда, есть потребность сделать локальную переменную глобальной.


def some_func():

    global r

    r = 20

    

some_func()

print(r)


Также с помощью данного ключевого слова можно изменить значение глобальной переменной из локальной области.
Вот как это можно сделать:


r = 30

def some_func():

    global r

    r = 20 # обращение к глобальной области видимости

some_func()

print(r)


Таким образом знание области видимости в Python важно для понимания более сложных концепций языка.

• 
  Создано 19.12.2019 12:49:08

• 
  
  Михаил Русаков

Предыдущая статья Следующая статья

Копирование материалов разрешается только с указанием автора (Михаил Русаков) и индексируемой прямой ссылкой на сайт (http://myrusakov.ru)!

Добавляйтесь ко мне в друзья ВКонтакте: http://vk.com/myrusakov.
Если Вы хотите дать оценку мне и моей работе, то напишите её в моей группе: http://vk.com/rusakovmy.

Если Вы не хотите пропустить новые материалы на сайте,
то Вы можете подписаться на обновления: Подписаться на обновления

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

Порекомендуйте эту статью друзьям:

Если Вам понравился сайт, то разместите ссылку на него (у себя на сайте, на форуме, в контакте):

1. 
   Кнопка:
   
   <a href=»https://myrusakov.ru» target=»_blank»><img src=»https://myrusakov.ru/images/button.gif» alt=»Как создать свой сайт» /></a>

   Она выглядит вот так:

2. 
   Текстовая ссылка:
   <a href=»https://myrusakov.ru» target=»_blank»>Как создать свой сайт</a>

   Она выглядит вот так: Как создать свой сайт

3. BB-код ссылки для форумов (например, можете поставить её в подписи):
   
   [URL=»https://myrusakov.ru»]Как создать свой сайт[/URL]

Что такое локальные и глобальные переменные в Python: подробное описание работы

От автора: что такое переменная в Python? Переменная Python является зарезервированной ячейкой памяти для хранения значений. Другими словами, переменная в программе Python передает данные на компьютер для обработки.

Каждое значение в Python имеет тип данных. Различные типы данных в Python: Numbers, List, Tuple, Strings, Dictionary и т. д. Переменные могут быть объявлены с любым именем или даже буквами, например, a, aa, abc и т. д. В этом руководстве мы узнаем, как:

Объявить и использовать переменную

Повторно объявить переменную

Объединить переменные

Бесплатный курс «Python. Быстрый старт»

Получите курс и узнайте, как создать программу для перевода текстов на Python

Получить курс

Что такое локальные и глобальные переменные

Как удалить переменную

Как объявить и использовать переменную

Давайте рассмотрим пример. Мы объявим переменную «а» и выведем ее.

Повторное объявление переменной

Вы можете повторно объявить переменную даже после того, как уже объявили ее один раз. Здесь у нас есть переменная, инициализированная как, f =0. Позже мы переназначим для переменной f значение «guru99″.

Пример Python 2

# Объявление переменной и ее инициализация
f = 0
print f
# повторное объявление переменной тоже работает
f = ‘guru99’
print f

Пример Python 3

# Объявление переменной и ее инициализация
f = 0
print(f)
# повторное объявление переменной тоже работает
f = ‘guru99’
print(f)

Объединение переменных

Посмотрим, сможете ли вы объединить разные типы данных, такие как строка и число. Например, мы объединяем «Guru» с числом «99».

В отличие от Java, который объединяет число со строкой, не объявляя число как строку, Python требует, чтобы число было объявлено как строка, иначе будет отображаться ошибка TypeError.

Для следующего кода вы получите неопределенный вывод:

a=»Guru»
b = 99
print a+b

После того, как целое число объявлено как строка, мы можем объединить в выходных данных «Guru» + str («99″) = «Guru99″.

a=»Guru»
b = 99
print(a+str(b))

Локальные и глобальные переменные

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

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

Переменная «f» является глобальной и ей присваивается значение 101, которое выводится.

Переменная f снова объявлена в функции и предполагает локальную область видимости. Ей присваивается значение «I am learning Python.», которое выводится. Эта переменная отличается от глобальной переменной «f», определенной ранее.

Бесплатный курс «Python. Быстрый старт»

Получите курс и узнайте, как создать программу для перевода текстов на Python

Получить курс

После завершения вызова функции локальная переменная f уничтожается. В строке 12, когда мы снова выводим значение «f», оно отображает значение глобальной переменной f =101.

Пример Python 2

# Объявляем переменную и инициализируем ее
f = 101
print f
# Глобальные и локальные переменные в функциях
def someFunction():
# Глобальная f
f = ‘I am learning Python’
print f
someFunction()
print f

Пример Python 3

# Объявляем переменную и инициализируем ее
f = 101
print(f)
# Глобальные и локальные переменные в функциях
def someFunction():
# Глобальная f
f = ‘I am learning Python’
print(f)
someFunction()
print(f)

Используя ключевое слово global, вы можете ссылаться на глобальную переменную внутри функции.

Переменная «f» является глобальной и ей присваивается значение 101, которое выводится на выходе

Переменная f объявляется с использованием ключевого слова global. Это НЕ локальная переменная, но та же глобальная переменная, объявленная ранее. Следовательно, когда мы выводим ее значение, результат равен 101

Мы изменили значение «f» внутри функции. После завершения вызова функции измененное значение переменной «f» сохраняется. В строке 12, когда мы снова выводим значение «f», оно отображает значение «changing global variable»

Пример Python 2

f = 101;
print f
# Глобальные и локальные переменные в функциях
def someFunction():
global f
print f
f = «changing global variable»
someFunction()
print f

Пример Python 3

f = 101;
print(f)
# Глобальные и локальные переменные в функциях
def someFunction():
global f
print(f)
f = «changing global variable»
someFunction()
print(f)

Удаление переменной

Вы также можете удалить переменную с помощью команды del «имя переменной». В приведенном ниже примере мы удалили переменную f, и когда мы приступили к ее выводу, мы получили ошибку «variable name is not defined», что означает, что вы удалили переменную.

f = 11;
print(f)
del f
print(f)

Заключение:

Переменными называют «конверты» или «контейнеры», в которых может храниться информация. Как и любой другой язык программирования, Python также использует переменную для хранения информации.

Переменные могут быть объявлены любым именем или даже буквами, например, aa, abc и т. д.

Переменные могут быть повторно объявлены даже после того, как вы объявили их один раз

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

Объявляйте локальную переменную, когда хотите использовать ее для текущей функции

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

Для удаления переменной используется ключевое слово «del».

Источник: https://www.guru99.com

Редакция: Команда webformyself.

Бесплатный курс «Python. Быстрый старт»

Получите курс и узнайте, как создать программу для перевода текстов на Python

Получить курс

Локальные и глобальные переменные. Урок 11 курса «Python. Введение в программирование»

В программировании особое внимание уделяется концепции о локальных и глобальных переменных, а также связанное с ними представление об областях видимости. Соответственно, локальные переменные видны только в локальной области видимости, которой может выступать отдельно взятая функция. Глобальные переменные видны во всей программе. «Видны» – значит, известны, доступны. К ним можно обратиться по имени и получить связанное с ними значение.

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

Вернемся к нашей программе из прошлого урока, немного упростив ее для удобства:

def rectangle():
    a = float(input("Ширина: "))
    b = float(input("Высота: "))
    print("Площадь: %.2f" % (a*b))

def triangle():
    a = float(input("Основание: "))
    h = float(input("Высота: "))
    print("Площадь: %.2f" % (0.5 * a * h))

figure = input("1-прямоугольник, 2-треугольник: ")
if figure == '1':
  rectangle()
elif figure == '2':
  triangle()

Сколько здесь переменных? Какие из них являются глобальными, а какие – локальными?

Здесь пять переменных. Глобальной является только figure. Переменные a и b из функции rectangle(), а также a и h из triangle() – локальные. При этом локальные переменные с одним и тем же идентификатором a, но объявленные в разных функциях, – разные переменные.

Следует отметить, что идентификаторы rectangle и triangle, хотя и не являются именами переменных, а представляют собой имена функций, также имеют область видимости. В данном случае она глобальная, так как функции объявлены непосредственно в основной ветке программы.

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

К локальной области относятся тела функций. Если, находясь в глобальной области видимости, мы попытаемся обратиться к локальной переменной, то возникнет ошибка:

…
elif figure == '2':
  triangle()

print(a)

Пример выполнения:

1-прямоугольник, 2-треугольник: 2
Основание: 4
Высота: 5
Площадь: 10.00
Traceback (most recent call last):
  File "test.py", line 17, in <module>
    print(a)
NameError: name 'a' is not defined

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

def rectangle():
    a = float(input("Ширина %s: " % figure))
    b = float(input("Высота %s: " % figure))
    print("Площадь: %.2f" % (a*b))

def triangle():
    a = float(input("Основание %s: " % figure))
    h = float(input("Высота %s: " % figure))
    print("Площадь: %.2f" % (0.5 * a * h))

figure = input("1-прямоугольник, 2-треугольник: ")
if figure == '1':
  rectangle()
elif figure == '2':
  triangle()

Пример выполнения:

1-прямоугольник, 2-треугольник: 1
Ширина 1: 6.35
Высота 1: 2.75
Площадь: 17.46

В данном случае из тел функций происходит обращение к имени figure, которое, из-за того, что было объявлено в глобальной области видимости, видимо во всей программе.

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

Если функции не будут выводить, а только вычислять результат, то его надо где-то сохранить для дальнейшего использования. Для этого подошли бы глобальные переменные. В них можно записать результат. Напишем программу вот так:

result = 0

def rectangle():
    a = float(input("Ширина: "))
    b = float(input("Высота: "))
    result = a*b

def triangle():
    a = float(input("Основание: "))
    h = float(input("Высота: "))
    result = 0.5 * a * h

figure = input("1-прямоугольник, 2-треугольник: ")
if figure == '1':
  rectangle()
elif figure == '2':
  triangle()

print("Площадь: %.2f" % result)

Итак, мы ввели в программу глобальную переменную result и инициировали ее нулем. В функциях ей присваивается результат вычислений. В конце программы ее значение выводится на экран. Мы ожидаем, что программа будет прекрасно работать. Однако…

1-прямоугольник, 2-треугольник: 2
Основание: 6
Высота: 4.5
Площадь: 0.00

… что-то пошло не так.

Дело в том, что в Python присвоение значения переменной совмещено с ее объявлением. (Во многих других языках это не так.) Поэтому, когда имя result впервые упоминается в локальной области видимости, и при этом происходит присваивание ей значения, то создается локальная переменная result. Это другая переменная, никак не связанная с глобальной result.

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

Когда мы вызывали внутри функции переменную figure, то ничего ей не присваивали. Наоборот, мы запрашивали ее значение. Интерпретатор Питона искал ее значение сначала в локальной области видимости и не находил. После этого шел в глобальную и находил.

В случае с result он ничего не ищет. Он выполняет вычисления справа от знака присваивания, создает локальную переменную result, связывает ее с полученным значением.

На самом деле можно принудительно обратиться к глобальной переменной. Для этого существует команда global:

result = 0

def rectangle():
    a = float(input("Ширина: "))
    b = float(input("Высота: "))
    global result
    result = a*b

def triangle():
    a = float(input("Основание: "))
    h = float(input("Высота: "))
    global result
    result = 0.5 * a * h

figure = input("1-прямоугольник, 2-треугольник: ")
if figure == '1':
  rectangle()
elif figure == '2':
  triangle()

print("Площадь: %.2f" % result)

В таком варианте программа будет работать правильно.

Однако менять значения глобальных переменных в теле функции – плохая практика. В больших программах программисту трудно отследить, где, какая функция и почему изменила их значение. Программист смотрит на исходное значение глобальной переменной и может подумать, что оно остается таким же. Сложно заметить, что какая-то функция поменяла его. Подобное ведет к логическим ошибкам.

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

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

Практическая работа

В языке Python можно внутри одной функции определять другую. Напишите программу по следующему описанию.

В основной ветке программы вызывается функция cylinder(), которая вычисляет площадь цилиндра. В теле cylinder() определена функция circle(), вычисляющая площадь круга по формуле πr². В теле cylinder() у пользователя спрашивается, хочет ли он получить только площадь боковой поверхности цилиндра, которая вычисляется по формуле 2πrh, или полную площадь цилиндра. В последнем случае к площади боковой поверхности цилиндра должен добавляться удвоенный результат вычислений функции circle().

Как вы думаете, можно ли из основной ветки программы вызвать функцию, вложенную в другую функцию? Почему?

Примеры решения и дополнительные уроки в android-приложении и pdf-версии курса

Глобальное ключевое слово Python (с примерами)

Перед чтением этой статьи убедитесь, что у вас есть некоторые основы работы с глобальными, локальными и нелокальными переменными Python.

Что такое глобальное ключевое слово

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

Правила глобального ключевого слова

Основные правила для ключевого слова global в Python:

• Когда мы создаем переменную внутри функции, она по умолчанию является локальной.
• Когда мы определяем переменную вне функции, она по умолчанию является глобальной. Вам не нужно использовать ключевое слово global .
• Мы используем ключевое слово global для чтения и записи глобальной переменной внутри функции.
• Использование ключевого слова global вне функции не имеет никакого эффекта.

Использование глобального ключевого слова

Рассмотрим пример.

Пример 1: Доступ к глобальной переменной изнутри функции

  c = 1 # глобальная переменная

def add ():
    печать (с)

добавить ()  

Когда мы запустим вышеуказанную программу, на выходе будет:

  1  

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

Пример 2: Изменение глобальной переменной изнутри функции

  c = 1 # глобальная переменная
    
def add ():
    c = c + 2 # увеличить c на 2
    печать (с)

добавить ()  

Когда мы запускаем вышеуказанную программу, вывод показывает ошибку:

  UnboundLocalError: локальная переменная 'c', на которую ссылается до присвоения  

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

Решением для этого является использование ключевого слова global .

Пример 3: Изменение глобальной переменной изнутри функции с использованием глобального

  c = 0 # глобальная переменная

def add ():
    глобальный c
    c = c + 2 # увеличить на 2
    print ("Внутри add ():", c)

добавлять()
print («В основном:», c)  

Когда мы запустим вышеуказанную программу, на выходе будет:

  Внутри add (): 2
В основном: 2  

В приведенной выше программе мы определяем c как глобальное ключевое слово внутри функции add () .

Затем мы увеличиваем переменную c на 1 , т.е. c = c + 2 . После этого вызываем функцию add () . Наконец, мы печатаем глобальную переменную c .

Как мы видим, изменение также произошло в глобальной переменной вне функции, c = 2 .

Глобальные переменные в модулях Python

В Python мы создаем единый модуль config.py для хранения глобальных переменных и обмена информацией между модулями Python в одной программе.

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

Пример 4: Совместное использование глобальной переменной в модулях Python

Создайте файл config.py для хранения глобальных переменных

  а = 0
b = "пустой"  

Создайте файл update.py для изменения глобальных переменных

  конфигурация импорта

config.a = 10
config.b = "алфавит"  

Создайте файл main.py , чтобы проверить изменения значения

  конфигурация импорта
импорт обновления

печать (config.а)
печать (config.b)  

Когда мы запускаем файл main.py , вывод будет

  10
алфавит  

Выше мы создали три файла: config.py , update.py и main.py .

Модуль config.py хранит глобальные переменные a и b . В файле update.py мы импортируем модуль config.py и изменяем значения a и b .Точно так же в файл main.py мы импортируем модуль config.py и update.py . Наконец, мы печатаем и проверяем значения глобальных переменных независимо от того, изменились они или нет.

Глобальные во вложенных функциях

Вот как вы можете использовать глобальную переменную во вложенной функции.

Пример 5: Использование глобальной переменной во вложенной функции

  def foo ():
    х = 20

    def bar ():
        глобальный x
        х = 25
    
    print ("Панель перед вызовом:", x)
    print ("Панель звонков сейчас")
    бар()
    print ("Панель после вызова:", x)

foo ()
print ("x в главном:", x)  

Вывод:

  Бар перед звонком: 20
Панель звонков сейчас
Бар после звонка: 20
x в основном: 25  

В приведенной выше программе мы объявили глобальную переменную внутри вложенной функции bar () .Внутри функции foo () x не влияет на ключевое слово global.

До и после вызова bar () переменная x принимает значение локальной переменной, то есть x = 20 . Вне функции foo () переменная x будет принимать значение, определенное в функции bar () , то есть x = 25 . Это связано с тем, что мы использовали ключевое слово global в x для создания глобальной переменной внутри функции bar () (локальная область).

Если мы внесем какие-либо изменения в функцию bar () , изменения появятся за пределами локальной области, т.е. foo () .

.

Глобальные, локальные и нелокальные переменные Python (с примерами)

Глобальные переменные

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

Давайте посмотрим на примере создания глобальной переменной в Python.

Пример 1: Создание глобальной переменной

  x = "глобальный"

def foo ():
    print ("x внутри:", x)


foo ()
print ("x снаружи:", x)  

Выход

  x внутри: глобальный
x снаружи: глобальный  

В приведенном выше коде мы создали x как глобальную переменную и определили foo () для печати глобальной переменной x .Наконец, мы вызываем foo () , который выводит значение x .

Что, если вы хотите изменить значение x внутри функции?

  x = "глобальный"

def foo ():
    х = х * 2
    печать (х)

foo ()  

Выход

  UnboundLocalError: локальная переменная 'x', на которую ссылается до присвоения  

Выходные данные показывают ошибку, потому что Python обрабатывает x как локальную переменную, а x также не определяется внутри foo () .

Чтобы это работало, мы используем ключевое слово global . Посетите Python Global Keyword, чтобы узнать больше.

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

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

Пример 2: Доступ к локальной переменной вне области

  def foo ():
    y = "местный"


foo ()
печать (у)  

Выход

  NameError: имя 'y' не определено  

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

Давайте посмотрим на примере создания локальной переменной в Python.

Пример 3: Создание локальной переменной

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

  def foo ():
    y = "местный"
    печать (у)

foo ()  

Выход

  местный  

Давайте посмотрим на более раннюю проблему, когда x было глобальной переменной, и мы хотели изменить x внутри foo () .

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

Здесь мы покажем, как использовать глобальные и локальные переменные в одном коде.

Пример 4: Использование глобальных и локальных переменных в одном коде

  x = "глобальный"

def foo ():
    глобальный x
    y = "местный"
    х = х * 2
    печать (х)
    печать (у)

foo ()  

Выход

  глобальный глобальный
местный  

В приведенном выше коде мы объявляем x как глобальную и y как локальную переменную в foo () .Затем мы используем оператор умножения * для изменения глобальной переменной x и печатаем как x , так и y .

После вызова foo () значение x становится global global , потому что мы использовали x * 2 , чтобы напечатать два раза global . После этого печатаем значение локальной переменной y , то есть local .

Пример 5: Глобальная переменная и Локальная переменная с тем же именем

  х = 5

def foo ():
    х = 10
    print ("локальный x:", x)


foo ()
print ("глобальный x:", x)  

Выход

  местное x: 10
глобальный x: 5  

В приведенном выше коде мы использовали одно и то же имя x как для глобальной, так и для локальной переменной.Мы получаем другой результат, когда печатаем одну и ту же переменную, потому что переменная объявлена ​​в обеих областях, то есть в локальной области видимости внутри foo () и глобальной области вне foo () .

Когда мы печатаем переменную внутри foo () , она выводит local x: 10 . Это называется локальной областью действия переменной.

Точно так же, когда мы печатаем переменную вне foo () , она выводит global x: 5 . Это называется глобальной областью действия переменной.

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

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

Давайте посмотрим на примере создания глобальной переменной в Python.

Мы используем нелокальных ключевых слов для создания нелокальных переменных.

Пример 6: Создание нелокальной переменной

  def external ():
    x = "местный"

    def inner ():
        нелокальный x
        x = "нелокальный"
        print ("внутренний:", x)

    внутренний ()
    print ("внешний:", x)


внешний ()  

Выход

  внутренний: нелокальный
внешний: нелокальный  

В приведенном выше коде есть вложенная функция inner () .Мы используем нелокальных ключевых слов для создания нелокальной переменной. Функция inner () определена в области действия другой функции outer () .

Примечание : Если мы изменим значение нелокальной переменной, изменения появятся в локальной переменной.

.

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

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

Как создать глобальную переменную

globalVar = «Am Global»
def foo ():
print («Внутри -» + globalVar)
foo ()
print («За пределами -» + globalVar)

выход

Внутри — Am Global
Снаружи — Am Global

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

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

Создать глобальный модуль

#Глобальный.ру
current_value = 0

Создать программный файл Python для доступа к глобальной переменной

# updater.py
импорт глобальный
def update_value ():
global.current_value = 100

Создайте другую программу Python, чтобы проверить, изменено ли значение или нет

# display_value.py
импорт глобальный
средство обновления импорта
updater.update_value ()
печать (global.current_value)

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

К глобалу может получить доступ любая функция , но его можно изменить, только если вы явно объявите его с помощью ключевого слова global внутри функции.Чтобы использовать глобальных переменных внутри функции, вам нужно сделать глобальные внутри функции. Имейте в виду, что вам нужно только объявить их глобальными внутри функции, если вы хотите выполнять назначения / изменять их. global не требуется для печати и доступа.

, пример

myGlobal = 5
def func1 ():
myGlobal = 50
def func2 ():
глобальный myGlobal
myGlobal = 50
def func3 ():
печать (myGlobal)
func1 ()
func3 ()
print («После использования Global»)
func2 ()
func3 ()

выход

5
После использования Global
50

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

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

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

, пример

def sum (x, y):
сумма = х + у
сумма возврата
печать (сумма (10,20))
печать (х)

выход

Отслеживание (последний вызов последний):
Файл «sample.py», строка 8, в
печать (х)
NameError: имя ‘x’ не определено

Ошибка отображается из-за того, что переменная x имеет только локальную область видимости.

NameError: имя ‘xx’ не определено

Python знает назначение определенных имен (напр. встроенных функций ). Другие имена определены в программе (например, переменные). Если Python обнаружит имя, которое он не распознает, вы, вероятно, получите ошибку NameError: глобальное имя ‘xx’ не определено . В большинстве случаев эта ошибка возникает, когда Python видит имя переменной (глобальное или локальное) и не знает, для чего оно. Эти ошибки могут произойти, если вы забыли инициализировать переменную , если вы неправильно написали переменную или если вы неправильно написали зарезервированное слово, такое как «True».Прежде чем использовать глобальную переменную в своей функции для чтения, ее необходимо сначала где-то инициализировать: либо вне функции, либо внутри нее.

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

def f ():
msg = «Локальная область …»
печать (сообщение)
# Глобальная область видимости
msg = «Глобальная область …»
f ()
печать (сообщение)

выход

Локальный охват…
Глобальный охват …

UnboundLocalError

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

Python по умолчанию имеет лексическую область видимости , что означает, что, хотя закрытая область видимости может получать доступ к значениям в ее охватывающей области , она не может их изменять (если они не объявлены глобальными с глобальным ключевым словом ). Замыкание связывает значения в окружающей среде с именами в локальной среде. Затем локальная среда может использовать связанное значение и даже переназначить это имя чему-то другому, но не может изменить привязку во включающей среде. UnboundLocalError произошло, потому что, когда python видит присвоение внутри функции, он считает эту переменную локальной переменной и не будет извлекать ее значение из охватывающей или глобальной области, когда мы выполняем функцию. Однако для изменения глобальной переменной внутри функции необходимо использовать ключевое слово global.

Типы данных и переменные Python

Каждая переменная в Python рассматривается как как объект . Переменные в Python соответствуют стандартной номенклатуре буквенно-цифровых имен, начинающихся с буквы или подчеркивания.На основании типа данных переменной интерпретатор выделяет память и решает, что можно сохранить в зарезервированной памяти . Вам не нужно объявлять переменные перед их использованием или объявлять их тип. Имена переменных чувствительны к регистру. Большинство переменных в Python являются локальными по своей области видимости для своей собственной функции или класса.

Подробнее …. Типы данных и переменные Python

Ищете работу на Python?

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

Перейти к … Вопросы для собеседования по Python

.

глобальных файлов Python ()

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

Сюда входят имена переменных, методы, классы и т. Д.

Существует два основных типа таблиц символов.

1. Таблица локальных символов
2. Глобальная таблица символов

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

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

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

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

Рекомендуемая литература: Пространство имен и область действия в Python

Синтаксис глобальных переменных ()

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

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

globals () 

globals () Параметры

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

Возвращаемое значение из globals ()

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

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

  глобальные ()  

Выход

  {'В': ['', 'globals ()'],
 'Вне': {},
 '_': '',
 '__': '',
 '___': '',
 '__builtin__': <модуль 'builtins' (встроенный)>,
 '__builtins__': <модуль 'builtins' (встроенный)>,
 '__name__': '__main__',
 '_dh': ['/ home / repl'],
 '_i': '',
 '_i1': 'globals ()',
 '_ih': ['', 'globals ()'],
 '_ii': '',
 '_iii': '',
 '_ой': {},
 '_sh': <модуль 'IPython.core.shadowns 'из' /usr/local/lib/python3.5/dist-packages/IPython/core/shadowns.py '>,
 'exit': ,
 'get_ipython': <связанный метод InteractiveShell.get_ipython объекта >,
 'quit': } 
 

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

Пример 2: Изменить глобальную переменную с помощью global ()

  возраст = 23

globals () ['age'] = 25
print ('Возраст:', возраст)  

Выход

  Возраст: 25 
 

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

Доступ к возвращенному словарю осуществляется с помощью ключа переменной age и изменяется на 25.

Это снова отражается в глобальной таблице символов.

.