В чем разница между классами list и array в Python?

# list vs array в Python

list — встроенный тип Python

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

Характеристики list:

# Создание list
my_list = [1, "hello", 3.14, True, None, [1, 2, 3]]
print(my_list)  # [1, 'hello', 3.14, True, None, [1, 2, 3]]

# Гетерогенный тип (разные типы в одном списке)
my_list = [1, "text", 3.14]
print(type(my_list[0]))  # <class 'int'>
print(type(my_list[1]))  # <class 'str'>
print(type(my_list[2]))  # <class 'float'>

# Динамический размер
my_list = [1, 2, 3]
my_list.append(4)  # Можно добавлять элементы
my_list.extend([5, 6])
my_list.pop()  # Можно удалять
print(my_list)  # [1, 2, 3, 4, 5]

# Методы list
my_list = [3, 1, 4, 1, 5]
my_list.sort()  # Сортировка
print(my_list)  # [1, 1, 3, 4, 5]

my_list.reverse()  # Разворот
print(my_list)  # [5, 4, 3, 1, 1]

index = my_list.index(3)  # Поиск индекса
print(index)  # 2

count = my_list.count(1)  # Подсчёт элементов
print(count)  # 2

Память list

Каждый элемент list — это указатель на объект:

import sys

my_list = [1, 2, 3]
print(sys.getsizeof(my_list))  # ~56 байт для пустого списка + размер указателей

for item in my_list:
    print(sys.getsizeof(item))  # Каждый int занимает 28 байт

# Из-за указателей list тяжелее array
print(sys.getsizeof([1, 2, 3]))  # ~88 байт

array — типизированный массив

array — это модуль в Python, который предоставляет типизированный массив. Все элементы должны быть одного типа.

Характеристики array:

import array

# Создание array (указываем тип: 'i' = int, 'f' = float, 'd' = double)
my_array = array.array('i', [1, 2, 3, 4, 5])  # Integer array
print(my_array)  # array('i', [1, 2, 3, 4, 5])

# Попытка добавить другой тип — ошибка
try:
    my_array.append(3.14)  # TypeError!
except TypeError as e:
    print(f"Error: {e}")  # Error: cannot convert 'float' to 'i'

# Поддерживаемые типы
type_codes = {
    'b': 'signed char',
    'B': 'unsigned char',
    'i': 'signed int',
    'I': 'unsigned int',
    'f': 'float',
    'd': 'double',
    'l': 'signed long',
    'L': 'unsigned long',
}

# Примеры
int_array = array.array('i', [1, 2, 3])  # Int array
float_array = array.array('f', [1.1, 2.2, 3.3])  # Float array

print(int_array.typecode)  # 'i'
print(float_array.typecode)  # 'f'

Память array

array хранит данные компактно без дополнительных указателей:

import sys
import array

# array намного компактнее list
my_list = [1, 2, 3, 4, 5]
my_array = array.array('i', [1, 2, 3, 4, 5])

print(f"list size: {sys.getsizeof(my_list)} bytes")  # ~104 байт
print(f"array size: {sys.getsizeof(my_array)} bytes")  # ~52 байт

# Каждый элемент в array занимает ровно столько, сколько его тип
print(f"Element size in array: {my_array.itemsize} bytes")  # 4 байта для int

# Total: 52 (header) + 5 * 4 (elements) = 72 байта для array
# vs list с множеством указателей

Таблица сравнения

Примеры использования

list — универсальный выбор

# Работа с разными типами
data = ["Alice", 25, 180.5, True]

# Множество операций
data.append("Engineer")
data.extend([1, 2, 3])
data.pop()
data.sort()  # Ошибка! Не можно сортировать разные типы

# Вложенные списки
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

for row in matrix:
    print(row)

array — для производительности

import array
import time

# Обработка больших объёмов чисел
def process_large_data():
    # Создаём большой массив целых чисел
    arr = array.array('i', range(1_000_000))
    
    # Быстрая обработка
    total = sum(arr)
    
    return total

start = time.time()
result = process_large_data()
print(f"Processing time: {time.time() - start:.4f}s")

# array быстрее и экономнее памяти для числовых данных

Скоростной тест

import array
import time

# Создание списка vs массива
start = time.time()
my_list = list(range(10_000_000))
list_time = time.time() - start

start = time.time()
my_array = array.array('i', range(10_000_000))
array_time = time.time() - start

print(f"list creation: {list_time:.4f}s")
print(f"array creation: {array_time:.4f}s")
print(f"list size: {my_list.__sizeof__()} bytes")
print(f"array size: {my_array.__sizeof__()} bytes")

# array может быть в 2-3 раза быстрее и экономнее

Современная альтернатива: NumPy

Для работы с большими числовыми массивами обычно используют NumPy, а не встроенный array:

import numpy as np

# NumPy array (более мощный)
arr = np.array([1, 2, 3, 4, 5])

# Операции над массивами
result = arr * 2  # [2, 4, 6, 8, 10]
result = arr.sum()  # 15
result = arr.mean()  # 3.0

# Многомерные массивы
matrix = np.array([[1, 2, 3], [4, 5, 6]])
print(matrix.shape)  # (2, 3)

# Очень быстро и удобно для научных вычислений

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

Используй list:

• Основной выбор в 99% случаев
• Когда нужно хранить разные типы данных
• Когда нужны много методов (append, extend, sort, insert и т.д.)
• Когда вложенность и гибкость важнее производительности

Используй array:

• Когда производительность критична и работаете с большими числовыми данными
• Когда нужна экономия памяти (embedded systems, IoT)
• Когда все элементы одного типа
• Редко — в большинстве случаев NumPy лучше

Используй NumPy:

• Для научных вычислений и анализа данных
• Для больших многомерных массивов
• Когда нужны векторизованные операции
• В Data Science, Machine Learning, физике и т.д.

Заключение

list — это основной, универсальный, удобный выбор.

array — это специализированная, быстрая, компактная альтернатива для числовых данных.

NumPy — это промышленный стандарт для работы с массивами в научных приложениях.