Когда лучше использовать массив?

Когда использовать массивы в Python

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

Основные массивные структуры в Python

1. Список (list) — универсальный выбор

Список — это динамический массив, который используется в 99% случаев:

# Основные операции со списком
data = [1, 2, 3, 4, 5]

# Доступ по индексу: O(1)
first = data[0]
last = data[-1]

# Добавление в конец: O(1) амортизированное
data.append(6)

# Удаление с конца: O(1)
data.pop()

# Итерация: O(n)
for item in data:
    print(item)

Когда использовать список:

• Нужна переменная длина
• Часто добавляешь/удаляешь элементы
• Нужен быстрый доступ по индексу
• Нужна гибкость типов данных

# Реальный пример
users = []  # Начинаем с пустого списка
users.append({'id': 1, 'name': 'Alice'})
users.append({'id': 2, 'name': 'Bob'})

# Проверка наличия элемента
if any(u['id'] == 1 for u in users):
    print("Найден пользователь 1")

2. Кортеж (tuple) — неизменяемый массив

Кортеж используется, когда данные не должны меняться:

# Неизменяемый кортеж
coordinates = (10, 20, 30)
x, y, z = coordinates  # Распаковка

# Нельзя изменить
# coordinates[0] = 15  # TypeError!

# Хеширование возможно (списки нельзя)
locations = {coordinates: 'Point A'}  # OK
# locations = {[10, 20]: 'Point B'}  # TypeError!

Когда использовать кортеж:

• Данные не должны меняться
• Используешь как ключи словаря
• Функция возвращает несколько значений
• Передаёшь в множество (set)
• Критична производительность

# Возврат нескольких значений
def get_user_info():
    return (1, 'Alice', 'alice@example.com')

user_id, name, email = get_user_info()

# Использование как ключа
cache = {}
key = ('user', 123)  # Кортеж как ключ
cache[key] = {'name': 'Alice'}

3. Модуль array — типизированный массив

array используется для хранения больших объёмов одного типа данных экономно:

import array

# Массив целых чисел (экономнее списка)
integers = array.array('i', [1, 2, 3, 4, 5])
integers.append(6)
integers[0] = 10

print(integers)  # array('i', [10, 2, 3, 4, 5, 6])

# Типовые коды:
# 'i' - целое число (signed int)
# 'f' - число с плавающей точкой (float)
# 'd' - число с плавающей точкой (double)
# 'b' - байт (signed char)

Когда использовать array:

• Хранишь миллионы элементов одного типа
• Нужна экономия памяти
• Нужна совместимость с C/системным кодом
• Не нужна гибкость типов

import array
import sys

# Сравнение памяти
list_data = list(range(1000000))
array_data = array.array('i', range(1000000))

print(f"List: {sys.getsizeof(list_data) / 1024 / 1024:.2f} MB")
print(f"Array: {sys.getsizeof(array_data) / 1024 / 1024:.2f} MB")
# Array в 3-4 раза компактнее!

4. NumPy ndarray — многомерные массивы

NumPy используется для численных вычислений и многомерных данных:

import numpy as np

# 1D массив
v = np.array([1, 2, 3, 4, 5])
print(v * 2)  # [2, 4, 6, 8, 10] - векторизация!

# 2D массив (матрица)
matrix = np.array([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
])

# Матричные операции
result = matrix @ matrix.T  # Матричное умножение
print(result)

# 3D массив (тензор)
tensor = np.zeros((10, 20, 30))
print(tensor.shape)  # (10, 20, 30)

Когда использовать NumPy:

• Научные вычисления
• Машинное обучение
• Обработка изображений
• Матричные операции
• Большие наборы числовых данных

import numpy as np

# Обработка изображения
image = np.random.rand(800, 600, 3)  # RGB image
blurred = np.convolve(image, kernel, mode='same')

# Матричные операции в ML
X = np.array([[1, 2], [3, 4], [5, 6]])  # 3x2 матрица
weights = np.array([[0.5], [0.3]])       # 2x1 матрица
y = X @ weights  # Матричное умножение

5. collections.deque — очередь

Deque оптимизирована для операций с обоими концами:

from collections import deque

# Инициализация
q = deque([1, 2, 3])

# Добавление в конец и начало
q.append(4)          # [1, 2, 3, 4]
q.appendleft(0)      # [0, 1, 2, 3, 4]

# Удаление с конца и начала
q.pop()              # Удалить 4
q.popleft()          # Удалить 0

# Вращение
q.rotate(2)          # Сдвинуть вправо на 2

Когда использовать deque:

• Реализуешь очередь (FIFO)
• Реализуешь двусторонюю очередь (Deque)
• Часто вставляешь/удаляешь в начало
• Нужна максимальная производительность операций с концами

from collections import deque

# Очередь для обработки задач
task_queue = deque()
task_queue.append('task1')
task_queue.append('task2')

while task_queue:
    task = task_queue.popleft()  # O(1)
    print(f"Обрабатываю {task}")

6. Множество (set) — уникальные элементы

Множество используется для уникальности и быстрой проверки принадлежности:

# Создание множества
fruit_set = {'apple', 'banana', 'orange'}

# Проверка наличия: O(1) vs O(n) для списка
if 'apple' in fruit_set:
    print("Есть яблоко")

# Удаление дубликатов
duplicates = [1, 2, 2, 3, 3, 3]
unique = list(set(duplicates))

# Теоретико-множественные операции
set_a = {1, 2, 3}
set_b = {3, 4, 5}

print(set_a & set_b)  # Пересечение {3}
print(set_a | set_b)  # Объединение {1,2,3,4,5}
print(set_a - set_b)  # Разность {1,2}

Когда использовать set:

• Нужна быстрая проверка принадлежности
• Нужно удалить дубликаты
• Нужны теоретико-множественные операции
• Порядок не важен

Сравнительная таблица

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

# 1. Динамический список - использовать list
scores = []
for i in range(100):
    scores.append(i * 2)

# 2. Неизменяемые координаты - использовать tuple
point_cache = {
    (0, 0): 'origin',
    (1, 1): 'diagonal',
    (5, 10): 'offset'
}

# 3. Поиск дубликатов - использовать set
email_set = set()
for email in emails:
    if email in email_set:
        print(f"Дубликат: {email}")
    email_set.add(email)

# 4. Научные вычисления - использовать NumPy
import numpy as np
data = np.array([1, 2, 3, 4, 5])
mean = np.mean(data)
std = np.std(data)

# 5. Очередь задач - использовать deque
from collections import deque
tasks = deque()
tasks.append('task1')
work_item = tasks.popleft()

Вывод: Выбор структуры данных зависит от того, как ты будешь с ней работать. В большинстве случаев используй список, но знай альтернативы для специфических задач.