PrepBro
← Назад к вопросам

Как работает память на ПК?

2.0 Middle🔥 131 комментариев
#Python Core#Soft Skills

Комментарии (1)

🐱
claude-haiku-4.5PrepBro AI22 мар. 2026 г.(ред.)

Ответ сгенерирован нейросетью и может содержать ошибки

# Как работает память на ПК?

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

Иерархия памяти

1. CPU Registers (Регистры процессора)

  • Самая быстрая память на компьютере
  • Расположены прямо в процессоре
  • Очень небольшой объём (несколько килобайт)
  • Время доступа: наносекунды

2. L1/L2/L3 Cache (Кэш процессора)

  • Очень быстрая память, хранит часто используемые данные
  • L1: самая быстрая, но самая маленькая (32-64 KB)
  • L2: больше, но медленнее (256 KB - 1 MB)
  • L3: ещё больше (2-20 MB)
  • Время доступа: несколько наносекунд

3. RAM (Оперативная память)

  • Основная память для хранения программ и данных
  • Время доступа: десятки наносекунд
  • Быстрая, но энергозависимая (теряется при отключении)
  • Типичный объём: 8-32 GB

4. SSD/HDD (Дисковое хранилище)

  • Постоянная память для хранения данных
  • Время доступа: миллисекунды (намного медленнее!)
  • Большой объём (сотни GB - TB)
  • Не теряется при отключении
Регистры (1 нс)     ▲
  ↑                 │
L1 Cache (4 нс)     │ Скорость
  ↑                 │
L2 Cache (10 нс)    │
  ↑                 │
L3 Cache (40 нс)    │
  ↑                 │
RAM (100 нс)        │
  ↑                 │
SSD (1000 нс = 1 мкс) │
  ↑                 │
HDD (10 мс)         ▼

Виртуальная память

Виртуальная память позволяет ОС управлять памятью для каждого процесса:

import sys

# Узнать адрес объекта в памяти
x = [1, 2, 3]
print(id(x))  # Виртуальный адрес объекта

# Узнать размер объекта в памяти
print(sys.getsizeof(x))  # В байтах

Страницы памяти

ОС делит виртуальную память на страницы (обычно 4 KB):

import gc

# Проверить использование памяти
print(gc.get_count())  # Информация о сборке мусора

# Отследить объекты
objects = gc.get_objects()
print(f"Всего объектов: {len(objects)}")

Управление памятью в Python

Reference Counting (Подсчёт ссылок)

Python отслеживает, сколько ссылок указывает на каждый объект:

import sys

x = []  # Счётчик ссылок: 1
y = x   # Счётчик ссылок: 2
z = x   # Счётчик ссылок: 3

print(sys.getrefcount(x))  # 4 (3 явные + 1 внутри getrefcount)

del y  # Счётчик ссылок: 2
del z  # Счётчик ссильок: 1
del x  # Счётчик ссылок: 0 -> объект удаляется

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

Помимо reference counting, Python использует сборку мусора для удаления циклических ссылок:

import gc

# Отключить автоматическую сборку мусора
gc.disable()

# Ручная сборка мусора
gc.collect()

# Включить обратно
gc.enable()

# Получить статистику
print(gc.get_stats())

Циклические ссылки

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None

# Создаём циклическую ссылку
a = Node(1)
b = Node(2)
a.next = b
b.next = a  # Циклическая ссылка!

# Reference counting не удалит эти объекты
del a
del b

# Нужна сборка мусора
import gc
gc.collect()  # Теперь объекты удаляются

Memory Leak (Утечка памяти)

# ❌ Плохо: утечка памяти
cache = []

def load_data(size):
    data = [0] * size
    cache.append(data)  # Данные никогда не удаляются!
    return data

for i in range(1000000):
    load_data(1000000)  # Память растёт бесконечно

# ✅ Хорошо: используй weakref или ограничи размер
from weakref import WeakValueDictionary

cache = WeakValueDictionary()

# Или используй LRU кэш
from functools import lru_cache

@lru_cache(maxsize=128)  # Максимум 128 записей
def expensive_function(x):
    return x ** 2

Профилирование памяти

# Модуль memory_profiler
from memory_profiler import profile

@profile
def my_function():
    x = [0] * 1000000
    y = [0] * 2000000
    return len(x) + len(y)

my_function()

# Вывод: Line #    Mem usage     Increment  Line Contents
#        5      5.0 MiB      0.0 MiB  @profile
#        6      5.0 MiB      0.0 MiB  def my_function():
#        7      9.6 MiB      4.6 MiB      x = [0] * 1000000
#        8     16.2 MiB      6.6 MiB      y = [0] * 2000000

Кэширование для оптимизации памяти

from functools import lru_cache
import time

@lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# Первый вызов: медленно
start = time.time()
result = fibonacci(35)
print(f"Время: {time.time() - start:.2f} сек")

# Второй вызов: быстро (из кэша)
start = time.time()
result = fibonacci(35)
print(f"Время: {time.time() - start:.6f} сек")

Работа с большими данными

import numpy as np

# ❌ Плохо: создаёшь весь массив в памяти
data = [i for i in range(1000000000)]  # 8+ GB памяти!

# ✅ Хорошо: используй генератор
def data_generator():
    for i in range(1000000000):
        yield i

# Или NumPy для эффективного использования памяти
data = np.arange(1000000, dtype=np.int32)  # Более эффективно

Memory Mapping

import mmap

# Файл отображается в памяти, не загружается целиком
with open("large_file.bin", "r+b") as f:
    with mmap.mmap(f.fileno(), 0) as mmapped_file:
        # Читаешь любую часть файла
        data = mmapped_file[100:200]

Лучшие практики

  1. Избегай циклических ссылок где возможно
  2. Используй генераторы вместо создания списков целиком
  3. Профилируй память с помощью memory_profiler
  4. Кэшируй результаты дорогих операций (но с лимитом!)
  5. Удаляй большие объекты явно, когда они больше не нужны
  6. Используй NumPy для больших числовых массивов
  7. Следи за утечками памяти в长ительных процессах

Заключение

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