Python. Области видимости имен в Python. Локальные имена. Правила видимости имен. Правило LEGB. Ключевое слово global. Переопределение имен в функциях

Области видимости имен в Python. Локальные и глобальные имена. Правила видимости имен. Правило LEGB. Ключевое слово global. Переопределение имен в функциях

Содержание

Поиск на других ресурсах:

1. Значение имен в Python

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

⇑

2. В каких областях видимости можно присваивать значения именам переменных?

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

локальная переменная – это переменная, которой присваивание значения происходит внутри инструкции def (внутри функции) или lambda;
нелокальная переменная – это переменная, которой присваивается значение в границах объемлющей инструкции def;
глобальная переменная – это переменная, которой присваивается значение за пределами всех инструкций def (за пределами всех функций) или всередине инструкции def с указанием ключевого слова global.

⇑

3. Локальные имена. Правила видимости локальных имен

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

Пространство имен локального имени определяется пространством имен функции в котором это имя определено. Для локальных имен можно сформулировать следующие правила видимости:

имя, которое определено внутри функции (внутри инструкции def), есть доступным только в программном коде этой функции с момента его первого использования;
имена, которые определены внутри функции, не конфликтуют с именами, которые объявлены (используются) за пределами функции. Таким образом, внутри функции (инструкции def) и за ее пределами могут использоваться одинаковые имена;
за пределами функции нет доступа к локальным именам, объявленным внутри функции.

Пример.

# Локальные имена

# Определение имен за пределами функции - глобальные переменные
a = 'Hello world!' # Имя a, которое является строкой
b = [ 2, 3, 8.55, 'Textbook' ] # Имя b, которое является списком

# Определение имен внутри функции
def Fn():
    a = 2.777 # имя a - число с плавающей точкой
    b = { 1:'One', 2:'Two' } # имя b - словарь
    c = [ 0.1, 0.01, 0.001 ] # имя c - список
    print('Fn.a = ', a)
    print('Fn.b = ', b)
    print('Fn.c = ', c)

# Вывести имена, которые объявлены за пределами функции
print('a = ', a)
print('b = ', b)

# Вызвать функцию
Fn()

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

Результат работы программы

a = 'Hello world!'
b = [2, 3, 8.55, 'Textbook']
Fn.a = 2.777
Fn.b = {1: 'One', 2: 'Two'}
Fn.c = [0.1, 0.01, 0.001]

⇑

4. Какие области видимости существуют в Python?

В языке Python существуют четыре области видимости:

встроенная область видимости. Эта область видимости включает заведомо определенные имена в модуле встроенных имен. Примеры таких имен: print, open, set, range, slice и прочие;
глобальная область видимости в пределах модуля;
локальная область видимости объемлющих функций;
локальная область видимости внутри функций. Такие имена объявляются внутри инструкции def или lambda.

На рисунке 1 отображен доступ к именам в разных областях видимости.

Рисунок 1. Области видимости имен в Python

⇑

5. Как осуществляется поиск имен в областях видимости? Как работает правило LEGB

Если в функции (локальная область видимости) объявлено имя, то интерпретатор ищет это имя в следующем порядке:

в локальной области видимости внутри функции (Local);
в локальных областях видимости объемлющих функций (Enclosing);
в глобальной области видимости (Global);
во встроенной области видимости (Built-in).

Такой порядок соответствует так называемому правилу LEGB: Local — Enclosing — Global — Built-in.

Если происходит обращение к имени в глобальной области видимости, то поиск происходит в этой области а также во встроенной области (см. рисунок 1).

⇑

6. Как определить имена встроенной области видимости? Пример

Имена встроенной области видимости помещены в модуле стандартной библиотеки builtins. Чтобы получить список имен нужно этот модуль подключить. Список имен получается с помощью функции dir.

# Определение имен встроенной области видимости

# Импортировать модуль builtins
import builtins

# Получить перечень имен в виде списка
names = dir(builtins)

# Вывести имена в цикле
for t in names:
    print(t)

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

Если в программе подключен модуль builtins следующим образом

import builtins

то с помощью имени builtins. можно обращаться к встроенным именам. Например

# Создать пустое множество
A = builtins.set()

# Создать пустой список
L = builtins.list()

⇑

7. Какие существуют взаимосвязи между локальной и глобальной областями видимости?

Между локальной и глобальной областями видимости существуют следующие взаимосвязи:

модуль – это глобальная область видимости (пространство имен). Это область, в которой создаются глобальные переменные на верхнем уровне в файле модуля. За пределами модуля глобальные переменные являются атрибутами объекта модуля;
глобальная область видимости определяется в едином файле. Глобальные имена в пределах этого файла всегда относятся к данному модулю;
вызов любой функции создает новую локальную область видимости. Эта область видимости имеет границы, которые определяются инструкцией def или lambda;
если в программном коде реализована рекурсия (функция циклически вызывает самая себя многократно), то каждый вызов функции создает новую локальную область видимости (пространство имен);
если внутри функции используется операция присваивания =, то эта операция создает локальные имена по умолчанию. Если нужно объявить глобальное имя внутри функции, то перед этим именем нужно указать ключевое слово global. Если в инструкции def нижнего уровня (в случае вложенных функций) нужно присвоить значение имени, которое объявляется в инструкции def верхнего уровня, то это имя может быть объявлено с ключевым словом nonlocal.

⇑

8. Как происходит переопределение встроенного и глобального имен внутри функции? Пример

Согласно правилу LEGB встроенные и глобальные имена могут быть переопределены внутри функции.

Пример. В нижеследующем коде переопределяется глобальное имя x и встроенное имя list.

# Переопределение встроенных и глобальных имен
# внутри функций

# 1. Переопределение встроенного имени list в функции Fn1()
# 1.1.Определить функцию Fn1()
def Fn1():
    list = 'This is a text'
    print(list)
    return

# 1.2. Вызов функции Fn1()
Fn1()

# 2. Переопределение глобального имени x внутри функции
# 2.1. Определить глобальное имя
x = 30

# 2.2. Определить функцию Fn2(), в которой используется
#     собственное локальное имя x
def Fn2():
    # Определить локальное имя
    x = 'Local x'

    # Вывести локальное имя на экран
    print(x) # Local x

    return

# Вызвать функцию Fn2()
Fn2()

# Вывести глобальное имя
print(x) # 30

После запуска программа выдает следующий результат

This is a text
Local x
30

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

⇑

9. Объявление глобального имени внутри функции. Ключевое слово global. Пример

Глобальное имя внутри функции можно объявить с помощью ключевого слова global. В общем случае такое объявление имеет вид:

def FuncName(parameters):
    ...
    global var
    var = value
    ...
    return

здесь

FuncName – имя функции;
var – имя, которое объявляется глобальным внутри функции FuncName;
value – присвоение некоторого значения глобальному имени

Пример.

# Глобальные переменные. Ключевое слово global

x = 25 # глобальное имя

def Fn():
    # объявление глобального имени t внутри функции
    global t
    t = 30 # присвоить глобальному имени t значение

    # вывести глобальное имя x внутри функции
    print(x)

    return

Fn()

# Использовать глобальное имя t, объявленное внутри функции Fn()
z = x+t # z = 25+30 = 55
print(z)

⇑

Связанные темы

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

⇑

BestProg