Типовые задачи с последовательностями в Python [2.6]

1. Цели урока

• Узнать, как работает индексация и как уверенно доставать элементы.
• Научиться делать срезы ([start:stop:step]) и понимать их правила.
• Познакомиться с преобразованиями между типами последовательностей: list(), tuple().
• Научиться сортировать: sorted(), list.sort(), key, reverse.

2. Что такое последовательности и что в них “типового”

Последовательность — это упорядоченный набор элементов, у которого обычно есть длина и поддерживается доступ по индексу. К типичным последовательностям относятся: list, tuple, str, range.

lst = [10, 20, 30]      # список
tup = (10, 20, 30)      # кортеж
s = "python"            # строка — тоже последовательность символов
r = range(5)            # ленивое "как бы последовательность" чисел

Чем отличаются set и dict

set — неупорядоченная структура: индексации и срезов нет. dict — отображение ключ→значение: доступ идёт по ключу, а не по позиции.

3. Индексация: как доставать элементы

s[i] и базовые правила

Индексация в Python начинается с нуля: s[0] — первый элемент, s[1] — второй и т.д.

arr = ["a", "b", "c", "d"]
print(arr[0])  # a
print(arr[2])  # c

Отрицательные индексы

Отрицательные индексы считаются от конца: -1 — последний элемент, -2 — предпоследний и т.д.

arr = ["a", "b", "c", "d"]
print(arr[-1])  # d
print(arr[-2])  # c

Типовые задачи на индексацию

arr = [10, 20, 30, 40]
first = arr[0]
last = arr[-1]
print(first, last)  # 10 40

arr = [10, 20, 30]
arr[1] = 999
print(arr)  # [10, 999, 30]

Типичные ошибки индексации

arr = [1, 2, 3]
# print(arr[3])  # IndexError: list index out of range

4. Срезы (slicing): как брать “кусок” последовательности

Синтаксис [start:stop:step]

Срез — это способ получить часть последовательности. Общая форма: [start:stop:step]. Граница stop не включается.

arr = [0, 1, 2, 3, 4, 5]
print(arr[1:4])   # [1, 2, 3] (4 не включается)
print(arr[:3])    # [0, 1, 2]
print(arr[3:])    # [3, 4, 5]

Значения по умолчанию

• start по умолчанию: начало последовательности.
• stop по умолчанию: конец последовательности.
• step по умолчанию: 1.
• Отрицательные значения поддерживаются.
• -1 в индексации означает “последний элемент”.

Срез со шагом

arr = list(range(10))
print(arr[::2])   # [0, 2, 4, 6, 8]
print(arr[1::2])  # [1, 3, 5, 7, 9]
print(arr[2:9:3]) # [2, 5, 8]

Отрицательный шаг и разворот

Если step отрицательный, срез идёт справа налево. Самый популярный приём — развернуть список: s[::-1].

arr = [1, 2, 3, 4]
print(arr[::-1])  # [4, 3, 2, 1]

Типовые рецепты со срезами

arr = [10, 20, 30, 40, 50]
print(arr[:2])   # [10, 20]
print(arr[-2:])  # [40, 50]

arr = [10, 20, 30, 40, 50]
print(arr[1:-1])  # [20, 30, 40]

a = [1, 2, 3]
b = a[:]          # поверхностная копия
print(a, b)       # [1, 2, 3] [1, 2, 3]

Срез-присваивание (только list)

Списки изменяемы, поэтому можно заменять “кусок” списка другим набором элементов.

arr = [0, 1, 2, 3, 4, 5]
arr[2:4] = [200, 300, 400]
print(arr)
# [0, 1, 200, 300, 400, 4, 5]

Типичные ошибки со срезами

arr = [0, 1, 2, 3, 4]
print(arr[1:3])  # [1, 2], а не [1, 2, 3]

arr = [0, 1, 2, 3, 4]
print(arr[1:4:-1])  # [] — идём назад, но stop "не в ту сторону"
print(arr[4:1:-1])  # [4, 3, 2]

5. Преобразование типов последовательностей

Конструкторы list(iterable) и tuple(iterable) принимают любой итерируемый объект: список, кортеж, строку, генератор, range и т.д. Они перебирают элементы и создают новую структуру.

print(list("abc"))        # ['a', 'b', 'c']
print(tuple([1, 2, 3]))   # (1, 2, 3)
print(list(range(5)))     # [0, 1, 2, 3, 4]

Копирование: a[:] vs list(a)

a = [1, 2, 3]
b1 = a[:]        # копия срезом
b2 = list(a)     # копия через конструктор
print(b1, b2)    # [1, 2, 3] [1, 2, 3]

Типичные ошибки преобразования

a = [[1], [2]]
b = a[:]

b[0].append(999)
print(a)  # [[1, 999], [2]]  изменилось и в a

6. Сортировка последовательностей

sorted() vs list.sort()

• sorted(iterable) принимает итерируемый объект и возвращает новый отсортированный список.
• list.sort() сортирует сам список на месте и возвращает None.

a = [3, 1, 2]

b = sorted(a)
print(a)  # [3, 1, 2]
print(b)  # [1, 2, 3]

a.sort()
print(a)  # [1, 2, 3]

reverse=True

a = [3, 1, 2]
print(sorted(a, reverse=True))  # [3, 2, 1]

Сортировка по ключу: key=...

Аргумент key — функция, которая получает элемент и возвращает “ключ сортировки”. Частый пример: сортировать слова без учёта регистра.

words = ["Python", "java", "Kotlin", "go"]
print(sorted(words, key=str.lower))
# ['go', 'java', 'Kotlin', 'Python']

Стабильность сортировки

Сортировка в Python стабильна: если ключи равны, элементы сохраняют исходный порядок. Это позволяет делать многошаговую сортировку.

data = [("Ann", 20), ("Bob", 20), ("Chris", 19)]

# Сначала сортируем по имени, потом по возрасту:
data_sorted = sorted(data, key=lambda x: x[0])
data_sorted = sorted(data_sorted, key=lambda x: x[1])

print(data_sorted)
# [('Chris', 19), ('Ann', 20), ('Bob', 20)]

Timsort: почему сортировка часто “умная”

Встроенная сортировка Python использует алгоритм Timsort — гибридный подход, сочетающий идеи сортировки вставками и сортировки слиянием. Он хорошо работает на реальных данных, где часто есть частично упорядоченные фрагменты.

Типичные ошибки сортировки

a = [3, 1, 2]
x = a.sort()
print(x)  # None
print(a)  # [1, 2, 3]

items = [1, "2", 3]
# sorted(items)  # TypeError: '<' not supported between instances of 'str' and 'int'

7. Практика: типовые задачи (с решениями)

Задачи на срезы

arr = [10, 20, 30, 40, 50, 60, 70]

print(arr[:3])    # [10, 20, 30]
print(arr[-3:])   # [50, 60, 70]
print(arr[1:-1])  # [20, 30, 40, 50, 60]

arr = list(range(1, 21))
print(arr[1::3])
# [2, 5, 8, 11, 14, 17, 20]

Задачи на индексацию

arr = [1, 2, 3, 4, 5]
arr[0], arr[-1] = arr[-1], arr[0]
print(arr)  # [5, 2, 3, 4, 1]

Задачи на сортировку

words = ["Python", "java", "Kotlin", "go"]
print(sorted(words, key=str.lower))
# ['go', 'java', 'Kotlin', 'Python']

people = [("Bob", 20), ("Ann", 20), ("Chris", 19), ("Dan", 19)]

# Вариант 1: одним ключом (кортеж ключей)
res1 = sorted(people, key=lambda x: (x[1], x[0]))
print(res1)
# [('Chris', 19), ('Dan', 19), ('Ann', 20), ('Bob', 20)]

# Вариант 2: два прохода, используя стабильность сортировки
res2 = sorted(people, key=lambda x: x[0])  # вторичный ключ
res2 = sorted(res2, key=lambda x: x[1])    # первичный ключ
print(res2)
# [('Chris', 19), ('Dan', 19), ('Ann', 20), ('Bob', 20)]

Задачи на преобразования типов

r = range(1, 6)
lst = list(r)
print(lst)       # [1, 2, 3, 4, 5]
print(lst[::-1]) # [5, 4, 3, 2, 1]

8. Чек‑лист самопроверки знаний

Отметьте пункты, которые вы действительно понимаете и можете применить без подсказок.