В чем особенность массива в Python?

# Массивы в Python: особенности и отличия

Важное уточнение

В Python не существует встроенного типа "массив" в классическом смысле (как в C, Java). Вместо этого Python предлагает несколько структур данных, которые выполняют роль массивов. Это одна из главных особенностей Python.

Основные "массивы" в Python

1. List — самый популярный

Динамический массив, может содержать объекты любых типов.

# Создание
my_list = [1, 2, 3, 4, 5]
mixed = [1, "hello", 3.14, True, None, [1, 2, 3]]  # разные типы!

# Доступ
print(my_list[0])  # 1
print(my_list[-1])  # 5 (последний элемент)

# Срезы
print(my_list[1:3])  # [2, 3]
print(my_list[::-1])  # [5, 4, 3, 2, 1] (развёрнутый)

# Изменение
my_list[0] = 10
my_list.append(6)
my_list.extend([7, 8])

# Мутабельный
mutability = my_list
mutability[0] = 999
print(my_list)  # [999, 2, 3, 4, 5, 6, 7, 8] — исходный изменился!

Особенности List:

• Динамический размер (растёт/сжимается при необходимости)
• Мутабельный (изменяемый)
• Может содержать разные типы
• O(1) доступ по индексу
• O(n) вставка/удаление в середину

2. Tuple — неизменяемый список

Реально является неизменяемым кортежем.

# Создание
my_tuple = (1, 2, 3, 4, 5)
single = (1,)  # обязательная запятая!
empty = ()

# Доступ
print(my_tuple[0])  # 1
print(my_tuple[1:3])  # (2, 3)

# Иммутабельный
# my_tuple[0] = 10  # TypeError: 'tuple' object does not support item assignment

# Но если внутри мутабельный объект...
nested = ([1, 2], 3, 4)
nested[0].append(5)  # это работает!
print(nested)  # ([1, 2, 5], 3, 4)

# Можно использовать как ключ в dict
points = {(1, 2): "origin", (3, 4): "point"}
print(points[(1, 2)])  # "origin"

# Можно в set
unique_coords = {(1, 2), (1, 2), (3, 4)}
print(unique_coords)  # {(1, 2), (3, 4)}

Особенности Tuple:

• Иммутабельный (не может быть изменён)
• Может содержать разные типы
• Хешируемый (можно использовать как ключ)
• О(1) доступ по индексу
• Немного быстрее list'ов

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

Официальный модуль для работы с типизированными массивами.

import array

# Создание массива целых чисел
int_array = array.array('i', [1, 2, 3, 4, 5])  # 'i' = signed integer

# Доступ
print(int_array[0])  # 1
print(int_array[1:3])  # array('i', [2, 3])

# Изменение
int_array[0] = 10
int_array.append(6)

# Нельзя добавить неправильный тип
# int_array.append("string")  # TypeError: 'str' object cannot be interpreted as an integer

float_array = array.array('f', [1.1, 2.2, 3.3])  # 'f' = float
char_array = array.array('u', ['a', 'b', 'c'])  # 'u' = unicode

# Итерация
for val in int_array:
    print(val)

Особенности array:

• Типизированный (все элементы одного типа)
• Более эффективен по памяти (нет overhead на тип)
• Быстрее list для больших данных
• Мутабельный
• Используется редко (обычно NumPy вместо этого)

4. NumPy array — профессиональный выбор

Для научных вычислений и работы с большими данными.

import numpy as np

# Создание
arr = np.array([1, 2, 3, 4, 5])
print(arr.dtype)  # int64

# Математические операции
print(arr * 2)  # [2 4 6 8 10]
print(arr + 10)  # [11 12 13 14 15]
print(np.sqrt(arr))  # [1. 1.41421356 1.73205081 2. 2.23606798]

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

# Срезы
print(arr[::2])  # [1 3 5] (каждый второй)
print(matrix[:, 1])  # [2 5] (вся колонка 1)

# Операции
print(np.sum(arr))  # 15
print(np.mean(arr))  # 3.0
print(np.std(arr))  # 1.414... (стандартное отклонение)

Особенности NumPy:

• Высокопроизводительный (написан на C)
• Векторизация (операции над всеми элементами сразу)
• Многомерные массивы
• Огромная библиотека функций
• Стандарт для data science, ML

Главные особенности массивов в Python

1. Динамический размер

my_list = [1, 2, 3]
my_list.append(4)  # можно добавить
my_list.pop()  # можно удалить
print(len(my_list))  # 3 — размер меняется

# В отличие от C:
# int arr[10];  // размер фиксирован!

2. Гетерогенный (смешанные типы)

heterogeneous = [1, "two", 3.0, True, None, [5, 6]]

for item in heterogeneous:
    print(type(item).__name__, item)
# int 1
# str two
# float 3.0
# bool True
# NoneType None
# list [5, 6]

3. Отрицательная индексация

my_list = ['a', 'b', 'c', 'd', 'e']
print(my_list[-1])  # 'e' (последний)
print(my_list[-2])  # 'd' (предпоследний)
print(my_list[-5])  # 'a' (первый)

4. Срезы (Slicing)

my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(my_list[2:5])  # [2, 3, 4] от 2 до 5 (5 не включается)
print(my_list[::2])  # [0, 2, 4, 6, 8] с шагом 2
print(my_list[::-1])  # [9, 8, 7, ...0] развёрнутый
print(my_list[5:2:-1])  # [5, 4, 3] с шагом -1

5. Мутабельность vs Иммутабельность

# Мутабельный — list
list1 = [1, 2, 3]
list2 = list1
list2[0] = 999
print(list1)  # [999, 2, 3] — обе переменные указывают на один список!

# Иммутабельный — tuple
tuple1 = (1, 2, 3)
tuple2 = tuple1
# tuple2[0] = 999  # TypeError

# Копирование
list3 = list1.copy()  # поверхностная копия
list3[0] = 111
print(list1)  # [999, 2, 3] — list1 не изменился

# Глубокая копия
import copy
complex_list = [[1, 2], [3, 4]]
deep_copy = copy.deepcopy(complex_list)
deep_copy[0][0] = 999
print(complex_list)  # [[1, 2], [3, 4]] — не изменился

Сравнение с другими языками

Производительность

import timeit
import array
import numpy as np

# 1 миллион элементов
n = 1_000_000

# List
list_time = timeit.timeit(
    lambda: [i * 2 for i in range(n)],
    number=1
)

# Array
array_time = timeit.timeit(
    lambda: [x * 2 for x in array.array('i', range(n))],
    number=1
)

# NumPy
np_time = timeit.timeit(
    lambda: np.arange(n) * 2,
    number=1
)

print(f"List: {list_time:.4f}s")
print(f"Array: {array_time:.4f}s")
print(f"NumPy: {np_time:.4f}s")  # NumPy будет намного быстрее

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

# ✅ List — для большинства случаев
users = ["Alice", "Bob", "Charlie"]
scores = [95, 87, 92]

# ✅ Tuple — для неизменяемых наборов данных
coordinates = (10, 20, 30)
rgb = (255, 0, 0)

# ✅ Array — когда нужна экономия памяти для больших однородных данных
temperatures = array.array('f', [23.5, 24.1, 22.8, ...])

# ✅ NumPy — для научных вычислений и работы с матрицами
data = np.array([[1, 2, 3], [4, 5, 6]])
result = np.dot(data, data.T)  # матричное умножение

Итоги

Главные особенности массивов в Python:

1. Нет встроенного "массива" — вместо этого несколько типов (list, tuple, array, NumPy)
2. Динамический размер — растёт/сжимается автоматически
3. Гетерогенный — могут содержать разные типы (в list и tuple)
4. Отрицательная индексация — удобный доступ с конца
5. Срезы — мощный инструмент для работы с подмножествами
6. Мутабельность — list мутабельный, tuple иммутабельный
7. Хеширование — tuple можно использовать как ключ, list нет

List — рабочая лошадь Python для большинства случаев. Tuple используется когда нужна неизменяемость. NumPy выбирай для высокопроизводительных вычислений.