Методы списков Python: полный обзор и шпаргалка

К этому уроку список уже знаком почти целиком: append и insert из уроков про добавление, remove и pop из урока про удаление, sort из урока про сортировку. Осталась горстка методов — index, count, reverse, clear, copy — и одно правило, которое объединяет их всех и экономит часы отладки: мутаторы возвращают None. Соберём карту целиком, чтобы любой метод из чужого кода узнавался с первого взгляда.

index: где лежит значение

Индексы из урока про индексы достают элемент по позиции, а index решает обратную задачу: по значению находит позицию первого вхождения:

shelf = ['молоко', 'хлеб', 'сыр']

pos = shelf.index('хлеб')
print(pos, shelf[pos])

1 хлеб

Значения в списке нет — метод не возвращает безопасный минус один, а бросает ValueError. Поэтому index страхуют оператором in из урока про проверку in или try-except, когда отсутствие значения — нормальная ситуация:

shelf = ['молоко', 'хлеб', 'сыр']

print('сыр' in shelf)
try:
    shelf.index('кофе')
except ValueError as e:
    print('Ошибка:', e)

True
Ошибка: 'кофе' is not in list

Пара работает в обе стороны: индекс по позиции — shelf[pos], позиция по значению — shelf.index('хлеб'). Сообщение об ошибке называет отсутствующее значение прямо — искать кофейный индекс без проверки in рискованно: программа упадёт в самый неожиданный момент отчёта.

count: сколько раз встречается

count отвечает на вопрос, сколько раз значение встретилось в списке, и не падает никогда — отсутствующее значение даёт честный ноль:

orders = ['молоко', 'хлеб', 'молоко', 'сыр', 'молоко']

print('молоко:', orders.count('молоко'))
print('хлеб:', orders.count('хлеб'))
print('кофе:', orders.count('кофе'))
print('всего позиций:', len(orders))

молоко: 3
хлеб: 1
кофе: 0
всего позиций: 5

count и len — разные вопросы: count считает вхождения одного значения, len — размер списка целиком. Если нужен счёт по всем значениям сразу, это работа для словаря-счётчика из курса про словари; count закрывает только точечный вопрос.

reverse: разворот на месте

reverse переворачивает список на месте — последний элемент становится первым. Срез [::-1] из урока про срезы делает тот же переворот, но по-другому: он строит новый список, не трогая оригинал. Разница видна в паре:

route = ['старт', 'мост', 'финал']

route.reverse()
print(route)
print(route[::-1])

back = route[::-1]
print(route)
print(back)

['финал', 'мост', 'старт']
['старт', 'мост', 'финал']
['финал', 'мост', 'старт']
['старт', 'мост', 'финал']

reverse() изменил route навсегда, а срез каждый раз возвращает свежий список, оставляя оригинал на месте. Выбор по задаче: порядок списка больше не нужен — reverse(), оригинал нужен в прямом порядке — срез. Отдельного метода для нового перевёрнутого списка нет — именно срез его заменяет.

clear: опустошить список

clear удаляет все элементы, но сохраняет сам объект списка — и это отличает его от присваивания пустого списка. Разница становится видна, когда на список смотрят два имени — история ссылок из урока про копирование:

a = ['молоко', 'хлеб']
b = a

a.clear()
print('после clear:  ', a, '-', b)

a = ['молоко', 'хлеб']
b = a
a = []
print('после a = []: ', a, '-', b)

после clear:   [] - []
после a = []:  [] - ['молоко', 'хлеб']

clear опустошил общий объект — b опустел вместе с a. Присваивание a = [] привязало имя a к новому пустому списку, а b остался со старым наполненным. Приём clear() возвращает None, потому что это чистый мутатор: ничего забрать из него нельзя.

Правило None: мутаторы ничего не отдают

Самая дорогая ошибка темы — склеить мутацию с присваиванием. Методы append, sort, reverse, clear меняют список на месте и возвращают None, поэтому присваивание их результата затирает список пустотой:

nums = [3, 1, 2]

nums.sort()
print(nums)

nums = nums.sort()
print(nums)

[1, 2, 3]
None

Первая строка работает как задумано: sort упорядочил список на месте, и печать показывает порядок. Вторая привязала имя nums к возвращённому None — список потерян, и каждая следующая операция с nums падает. Правило: метод-мутатор вызывают отдельной строкой и ничего из него не присваивают; значение отдают только pop и немутаторы index, count, copy.

copy и полная карта

Последний метод из таблицы — copy: встроенный аналог среза a[:] из урока про копирование. Он возвращает новый список с теми же элементами, и правки копии не трогают оригинал:

cart = ['молоко', 'хлеб']
backup = cart.copy()

backup.append('сыр')
print(cart)
print(backup)
print(cart is backup)

['молоко', 'хлеб']
['молоко', 'хлеб', 'сыр']
False

copy, срез a[:] и list(a) дают одинаковый результат — выбор дело вкуса; у метода есть плюс читаемости: cart.copy() по-русски звучит как то, что делает. Полный список методов любой структуры показывает функция dir — здесь он приведён для справки:

print([m for m in dir(list) if not m.startswith('_')])

• добавление: append в конец, insert по индексу, extend пачкой — все на месте;
• удаление: remove по значению, pop с возвратом, del по индексу, clear всё;
• поиск: index даёт позицию и падает без значения, count считает вхождения;
• порядок: sort и reverse меняют на месте, sorted и срез [::-1] строят новые;
• копия: copy(), a[:] и list(a) — поверхностные, deepcopy — полная;
• правило None: мутаторы ничего не возвращают — присваивать их результат нельзя.

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