Последовательности данных в языке программирования Python

Расширенные примеры работы с последовательностями

Пример 1. Срезы с шагом и отрицательные индексы

data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# Шаг 2
print(data[::2])          # [0, 2, 4, 6, 8]
# Обратный порядок
print(data[::-1])         # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
# Срез с конца с шагом -2
print(data[-1::-2])       # [9, 7, 5, 3, 1]

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

Срезы работают со всеми последовательностями, включая строки и кортежи.

Пример 2. Копирование списков: поверхностное и глубокое

import copy
original = [[1, 2], [3, 4]]
# Поверхностная копия
shallow = original.copy()
shallow[0][0] = 99
print(original)  # [[99, 2], [3, 4]] - изменено!
# Глубокая копия
deep = copy.deepcopy(original)
deep[0][0] = 0
print(original)  # [[99, 2], [3, 4]] - не изменено

[[99, 2], [3, 4]]
[[99, 2], [3, 4]]

Для списков и bytearray следует различать копирование ссылок и содержимого.

Пример 3. Преобразование строки в bytes и обратно, модификация bytearray

# Строка в байты
s = 'Привет'
b = s.encode('utf-8')
print(b)  # b'\xd0\x9f\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82'
# Байты в строку
s2 = b.decode('utf-8')
print(s2)  # Привет
# Создание bytearray и изменение
ba = bytearray(b'abcdef')
ba[2:5] = b'XYZ'  # замена среза
print(ba)          # bytearray(b'abXYZf')

b'\xd0\x9f\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82'
Привет
bytearray(b'abXYZf')

Метод encode()/decode() обязателен при переходе между str и bytes. Bytearray поддерживает изменение срезов.

Пример 4. Memoryview для эффективного доступа к байтовому буферу

ba = bytearray(b'A' * 10)
mv = memoryview(ba)
# Чтение через memoryview
print(mv[0])      # 65 (код 'A')
# Создание среза без копирования
mv_slice = mv[2:5]
mv_slice[0] = 66  # изменяет оригинальный ba
print(ba)         # bytearray(b'AABAAAAAAA')

65
bytearray(b'AABAAAAAAA')

Memoryview позволяет работать с буфером байтового массива, не создавая копии подстроки.

Пример 5. Генерация списка с условием (list comprehension)

# Список квадратов чётных чисел от 0 до 9
squares = [x**2 for x in range(10) if x % 2 == 0]
print(squares)  # [0, 4, 16, 36, 64]
# Эквивалентный цикл
squares2 = []
for x in range(10):
    if x % 2 == 0:
        squares2.append(x**2)
print(squares2) # [0, 4, 16, 36, 64]

[0, 4, 16, 36, 64]
[0, 4, 16, 36, 64]

Генераторы списков (list comprehensions) предоставляют лаконичный способ создания последовательностей на основе существующих.

Пример 6. Упаковка и распаковка кортежей

# Упаковка
t = 1, 2, 3   # без скобок - тоже кортеж
print(t)      # (1, 2, 3)
# Распаковка с *
first, *middle, last = (10, 20, 30, 40, 50)
print(first, middle, last)  # 10 [20, 30, 40] 50

(1, 2, 3)
10 [20, 30, 40] 50

Распаковка с * (звездочка) позволяет захватывать оставшиеся элементы в список.

Пример 7. Сравнение производительности list и tuple

import timeit
# Время создания
list_time = timeit.timeit('list(range(1000))', number=10000)
tuple_time = timeit.timeit('tuple(range(1000))', number=10000)
print(f'list: {list_time:.4f}, tuple: {tuple_time:.4f}')
# Время доступа по индексу
access_list = timeit.timeit('l[500]', setup='l = list(range(1000))', number=1000000)
access_tuple = timeit.timeit('t[500]', setup='t = tuple(range(1000))', number=1000000)
print(f'list access: {access_list:.4f}, tuple access: {access_tuple:.4f}')

list: 0.2345, tuple: 0.1876
list access: 0.0456, tuple access: 0.0443

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

Пример 8. Вложенные последовательности и их обработка

# Список кортежей (например, координаты)
points = [(1, 2), (3, 4), (5, 6)]
# Извлечение x и y с помощью распаковки
for x, y in points:
    print(f'x={x}, y={y}')
# Кортеж списков
data = ([1, 2], [3, 4])
# Изменение вложенного списка
data[0].append(5)
print(data)  # ([1, 2, 5], [3, 4])

x=1, y=2
x=3, y=4
x=5, y=6
([1, 2, 5], [3, 4])

Вложенные последовательности позволяют моделировать многомерные данные. Изменяемость внутренних объектов сохраняется даже внутри кортежа.