Как хранится информация в ячейке памяти в Python?

Хранение информации в ячейке памяти в Python

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

Основные принципы

1. Всё есть объект Каждое значение в Python — целое число, строка, список, функция — является объектом, размещённым в динамической памяти. Объект содержит:

• Тип данных (определяет возможные операции и структуру)
• Значение (фактические данные)
• Счётчик ссылок (для управления сборкой мусора)

2. Переменные как ссылки Когда вы присваиваете значение переменной, создаётся ссылка на существующий или новый объект:

# Создаётся объект int со значением 42 и счётчиком ссылок = 1
a = 42

# b теперь ссылается на тот же объект, счётчик ссылок увеличивается до 2
b = a

# Проверка идентичности объектов
print(a is b)  # True - одна и та же ячейка памяти
print(id(a) == id(b))  # True - одинаковые идентификаторы

3. Динамическая типизация Тип привязан к объекту, а не к переменной:

x = 10      # x ссылается на объект int
x = "текст" # Теперь x ссылается на объект str
# Старый объект int уничтожается, если на него нет других ссылок

Организация памяти для разных типов

Неизменяемые типы (int, float, str, tuple, frozenset, bytes):

• При "изменении" создаётся новый объект
• Python может кэшировать часто используемые значения

# Кэширование малых целых чисел (-5 до 256)
a = 100
b = 100
print(a is b)  # True - один и тот же кэшированный объект

c = 1000
d = 1000
print(c is d)  # False (в большинстве реализаций) - разные объекты

Изменяемые типы (list, dict, set, bytearray, пользовательские классы):

• Объект может изменяться на месте
• Присваивание создаёт новую ссылку на тот же объект

list1 = [1, 2, 3]
list2 = list1    # Две ссылки на один объект
list2.append(4)
print(list1)     # [1, 2, 3, 4] - изменился "оригинал"

# Создание независимой копии
list3 = list1.copy()  # или list3 = list1[:]
list3.append(5)
print(list1)     # [1, 2, 3, 4] - не изменился

Механизм управления памятью

Счётчик ссылок (reference counting) Каждый объект содержит счётчик количества ссылок на него. Когда счётчик достигает нуля, память освобождается:

import sys

obj = [1, 2, 3]
print(sys.getrefcount(obj))  # 2 (obj + временная ссылка в getrefcount)

ref = obj      # счётчик увеличивается
del ref        # счётчик уменьшается
del obj        # счётчик = 0 → объект удалён

Циклический сборщик мусора (garbage collector) Дополняет счётчик ссылок, обнаруживая и удаляя циклические ссылки:

# Циклическая ссылка
list_a = [1, 2]
list_b = [3, 4]
list_a.append(list_b)
list_b.append(list_a)

# Даже после удаления внешних ссылок объекты остаются в памяти
# до работы циклического сборщика мусора

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

1. Эффективность работы с неизменяемыми типами

# Неэффективно: создаётся много временных объектов
result = ""
for i in range(1000):
    result += str(i)  # Каждый раз создаётся новый объект str

# Эффективно: используется StringBuilder-подход
parts = []
for i in range(1000):
    parts.append(str(i))
result = "".join(parts)

2. Передача аргументов в функции Все аргументы передаются по присваиванию (по ссылке):

def modify_list(lst):
    lst.append(100)  # Изменяет оригинальный объект

def reassign_list(lst):
    lst = [1, 2, 3]  # Создаёт локальную ссылку, не меняя оригинал

original = [10, 20]
modify_list(original)
print(original)  # [10, 20, 100]

reassign_list(original)
print(original)  # [10, 20, 100] - не изменился

3. Использование is vs ==

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)  # True - одинаковые значения
print(a is b)  # False - разные объекты в памяти
print(a is c)  # True - один и тот же объект

Внутреннее представление в CPython

В реализации CPython каждый объект начинается с заголовка, содержащего:

• Указатель на тип объекта (PyTypeObject*)
• Счётчик ссылок (Py_ssize_t)
• Значение (зависит от типа)

Для оптимизации Python использует:

• Интернирование строк для часто используемых литералов
• Кэширование малых целых чисел
• Пулы памяти для уменьшения фрагментации

Понимание модели памяти Python критически важно для:

• Оптимизации производительности
• Избежания утечек памяти
• Корректной работы с изменяемыми/неизменяемыми типами
• Отладки сложных сценариев с циклическими ссылками

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