Где хранятся переменные в Python?

Где хранятся переменные в Python

Переменные в Python хранятся в памяти, но точное место зависит от области видимости (scope), типа данных и способа их использования. Это критически важно для понимания поведения программы.

Виды памяти в Python

Все переменные находятся в оперативной памяти (RAM), но логически разделены на несколько областей:

1. Stack (стек) — переменные функций, локальные переменные
2. Heap (куча) — объекты, списки, словари, пользовательские классы
3. Global/Static — глобальные переменные, константы
4. Register — очень часто используемые значения (управляется процессором)

Stack — локальные переменные

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

def my_function():
    x = 5  # Целое число
    y = 10  # Целое число
    return x + y

# После выхода из функции x и y удаляются из Stack

Как работает стек:

Вызов функции:
my_function():
  Stack: [x=5, y=10]
  
Возврат из функции:
  Stack: [] (очищено)

Heap — объекты и сложные структуры

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

# Значение в Stack, объект в Heap
def create_list():
    my_list = [1, 2, 3, 4, 5]  # Ссылка в Stack объект в Heap
    return my_list

result = create_list()
# my_list удалена из Stack, но объект в Heap ещё существует
# result указывает на тот же объект в Heap

print(result)  # [1, 2, 3, 4, 5]

Stack содержит ссылку (адрес), Heap содержит данные:

Stack:                    Heap:
my_list -> 0x1000    ->    [1, 2, 3, 4, 5]
                         
result -> 0x1000    ->    [1, 2, 3, 4, 5]  (тот же объект)

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

Глобальные переменные хранятся в глобальной области памяти, доступны из любого места программы.

# Глобальная переменная
GLOBAL_CONSTANT = 100

def my_function():
    print(GLOBAL_CONSTANT)  # Доступна
    
my_function()  # 100

print(GLOBAL_CONSTANT)  # 100

Области видимости (Scopes)

Python использует LEGB порядок поиска переменных:

L - Local (локальная область функции)
E - Enclosing (область оборачивающей функции)
G - Global (глобальная область модуля)
B - Built-in (встроенная область Python)

def outer():
    x = "outer"
    
    def inner():
        y = "inner"
        print(x)  # Найдёт в Enclosing scope
        print(y)  # Найдёт в Local scope
    
    inner()

outer()  # outer, inner
print(x)  # NameError

Визуализация памяти

import sys

def memory_demo():
    a = 5  # Целое число
    b = 5  # Может быть ТОЖЕ целое число (кэш)
    
    c = 1000  # Большое число
    d = 1000  # Другое целое число
    
    print(id(a), id(b))  # Одинаковые (кэш для -5 до 256)
    print(id(c), id(d))  # Разные
    
    my_list = [1, 2, 3]
    print(id(my_list))  # Адрес объекта в Heap
    print(sys.getsizeof(my_list))  # Размер в байтах

Целые числа: кэширование

Python кэширует целые числа от -5 до 256 для оптимизации.

a = 5
b = 5
print(a is b)  # True (одинаковые объекты)
print(id(a) == id(b))  # True

c = 257
d = 257
print(c is d)  # False (разные объекты)
print(id(c) == id(d))  # False

Функции и переменные

def my_func():
    pass

print(id(my_func))  # Адрес объекта функции в Heap
print(type(my_func))  # class function

# Функции - это объекты, хранятся в Heap
my_func_ref = my_func  # Ссылка на функцию
print(my_func_ref())  # Работает

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

class MyClass:
    class_var = 10  # Хранится в классе
    
    def __init__(self):
        self.instance_var = 20  # Хранится в объекте

obj = MyClass()
print(obj.class_var)  # 10 (найдена в классе)
print(obj.instance_var)  # 20 (найдена в объекте)
print(MyClass.class_var)  # 10

Практические следствия

Изменяемые объекты в функциях:

def modify_list(my_list):
    my_list.append(4)  # Изменяет объект в Heap

original = [1, 2, 3]
modify_list(original)
print(original)  # [1, 2, 3, 4] - ИЗМЕНИЛСЯ!

# Потому что обе переменные указывают на один объект

Неизменяемые объекты в функциях:

def modify_int(x):
    x = x + 1  # Создаёт НОВОЕ целое число

original = 5
modify_int(original)
print(original)  # 5 - не изменился

# Потому что x = x + 1 создаёт новый объект

Сборка мусора (Garbage Collection)

import gc

my_list = [1, 2, 3]  # Объект в Heap
del my_list  # Удаляем ссылку из Stack

# Когда нет ссылок на объект, сборщик мусора удалит его из Heap
gc.collect()  # Явный вызов сборщика

Резюме хранилищ

В заключении: понимание где хранятся переменные критически важно для понимания aliasing, garbage collection и производительности Python программ.