Что такое пространство имен?

Что такое пространство имен (namespace)

Пространство имен (namespace) - это отображение (словарь) между именами переменных/функций/классов и их объектами в памяти. Python использует пространства имен для организации кода и избежания конфликтов имен.

Основная идея

# Пространство имен - это словарь
namespace = {
    'x': 10,
    'name': 'Alice',
    'print': <built-in function print>,
    'len': <built-in function len>,
}

# Когда я пишу: print(x)
# Python ищет в пространстве имен:
# 1. 'print' -> <built-in function print>
# 2. 'x' -> 10

Четыре типа пространств имен

1. Built-in namespace (встроенные)

# Доступны везде
print(len([1, 2, 3]))  # print, len - встроенные
print(dict)  # dict - встроенный класс
print(True)  # True - встроенная константа

# Все встроенные функции
import builtins
print(dir(builtins))
# ['__doc__', '__name__', '__loader__', '__spec__', '__annotations__', 
#  'abs', 'all', 'any', 'ascii', 'bin', 'bool', ...]

2. Global namespace (глобальное)

# На уровне модуля
x = 10  # Global
y = 20  # Global

def my_function():
    # Внутри функции может видеть x, y
    print(x)  # 10
    print(y)  # 20

my_function()

# Проверить глобальное пространство
print(globals())
# {'__name__': '__main__', 'x': 10, 'y': 20, 'my_function': ...}

3. Local namespace (локальное)

def my_function():
    # Локальное пространство функции
    a = 1  # Локальная переменная
    b = 2  # Локальная переменная
    
    print(a)  # 1 - из локального пространства
    print(locals())
    # {'a': 1, 'b': 2}

my_function()

print(a)  # NameError - нет 'a' в глобальном

4. Enclosing namespace (из вложенной функции)

def outer():
    x = 'outer'  # Enclosing
    
    def inner():
        print(x)  # Может видеть 'x' из outer
        y = 'inner'  # Локальная переменная
    
    inner()

outer()  # Печатает: outer

LEGB правило поиска имен

Когда Python ищет переменную, смотрит в порядке:

1. Local (L) - локальное пространство функции
2. Enclosing (E) - пространство вложенной функции
3. Global (G) - глобальное пространство модуля
4. Built-in (B) - встроенное пространство Python

x = 'global'  # Global namespace

def outer():
    x = 'enclosing'  # Enclosing namespace
    
    def inner():
        x = 'local'  # Local namespace
        print(x)  # Какой x будет выведен?
    
    inner()

outer()  # Выведет: local

Практический пример

name = 'Alice'  # Global

def print_names():
    name = 'Bob'  # Local
    
    def inner():
        name = 'Charlie'  # Local
        print(f"Inner: {name}")  # Берет из Local
    
    inner()
    print(f"Outer: {name}")  # Берет из Local outer

print(f"Global: {name}")  # Берет из Global
print_names()

# Вывод:
# Global: Alice
# Inner: Charlie
# Outer: Bob

Модификация переменных из других пространств

x = 10  # Global

def modify():
    global x  # Указываю, что использую глобальную
    x = 20  # Модифицирую глобальную переменную

print(x)  # 10
modify()
print(x)  # 20

# Без global - создается локальная переменная
def modify_without_global():
    x = 30  # Создается локальная переменная

modify_without_global()
print(x)  # Все еще 20 - глобальная не изменилась

Nonlocal - для вложенных функций

def outer():
    x = 10  # Enclosing namespace
    
    def inner():
        nonlocal x  # Указываю, что использую enclosing
        x = 20  # Модифицирую enclosing переменную
    
    print(f"Before: {x}")  # 10
    inner()
    print(f"After: {x}")   # 20

outer()

Пространство имен модуля

# Файл: mymodule.py
x = 10
y = 20

def my_function():
    return x + y

# Файл: main.py
import mymodule

print(mymodule.x)  # Доступ через пространство имен модуля
print(mymodule.my_function())  # 30

# Пространство имен модуля - это его __dict__
print(mymodule.__dict__)
# {'x': 10, 'y': 20, 'my_function': <function>, ...}

Пространство имен класса

class Dog:
    species = 'Canis familiaris'  # Переменная класса
    
    def __init__(self, name):
        self.name = name  # Переменная экземпляра
    
    def bark(self):
        return f"{self.name} says Woof!"

# Пространство имен класса
print(Dog.__dict__)
# {'species': 'Canis familiaris', '__init__': <function>, 'bark': <function>}

dog = Dog('Rex')
# Пространство имен экземпляра
print(dog.__dict__)
# {'name': 'Rex'}

Проверка пространств имен

x = 'global'

def my_function():
    y = 'local'
    
    print('Local:', locals())   # {'y': 'local'}
    print('Global:', globals()) # {'x': 'global', 'my_function': ...}
    print('Built-in:', dir(__builtins__))  # Встроенные функции

my_function()

# Проверить есть ли переменная
if 'x' in globals():
    print("x есть в глобальном пространстве")

Вывод

Пространство имен - это фундаментальная концепция Python:

1. Определяет, где Python ищет переменные
2. Позволяет избежать конфликтов имен
3. Используется везде: модули, классы, функции
4. Правило LEGB помогает понять, какая переменная будет использована

Понимание пространств имен критично для написания правильного и безошибочного кода.