Методы списков:
порядок, копия, проверка

Категория

Методы и операции коллекций

Уровень

Начальный

Связанные темы

Списки, вложенные структуры, индексы

Зачем это знать

Разворачивать, копировать и проверять коллекции

§1reverse(): изменить порядок

reverse() разворачивает исходный список на месте и возвращает None.

numbers = [1, 2, 3, 4]
result = numbers.reverse()

print(numbers)
print(result)

[4, 3, 2, 1]
None

Метод не сортирует, а только переворачивает: элементы идут в обратном порядке относительно того, в каком лежали. Для сортировки по убыванию точнее писать numbers.sort(reverse=True), а не сортировать и затем разворачивать.

§2Новый обратный список

Если исходный порядок нужно сохранить, используют срез с шагом -1: он строит новый список, не трогая старый.

numbers = [1, 2, 3, 4]
backward = numbers[::-1]

print(numbers)
print(backward)

[1, 2, 3, 4]
[4, 3, 2, 1]

reversed() удобен прямо в заголовке цикла: for item in reversed(items). Чтобы получить из него именно список, его оборачивают в list().

§3copy(): поверхностная копия

copy() создаёт новый список с теми же элементами. Как показала глава 3.10, простое присваивание такого эффекта не даёт — оно лишь добавляет второе имя.

original = [1, 2, 3]
copied = original.copy()

copied[0] = 100

print(original)
print(copied)

[1, 2, 3]
[100, 2, 3]

b = a          a ─┐
               b ─┴─→ [1, 2, 3]      один объект

b = a.copy()   a ───→ [1, 2, 3]
               b ───→ [1, 2, 3]      два объекта

§4Три способа скопировать

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

numbers = [1, 2, 3, 4]

print(numbers.copy())
print(list(numbers))
print(numbers[:])

[1, 2, 3, 4]
[1, 2, 3, 4]
[1, 2, 3, 4]

Все три создают поверхностную копию — новый внешний список с теми же самыми элементами внутри. Что это значит на практике, показывают §6 и §7.

§5== и is

Есть два разных вопроса: «одинаковое ли содержимое?» и «один ли это объект?». Для них существуют два разных оператора.

a = [1, 2]
b = a.copy()
c = a

print(a == b)
print(a is b)
print(a is c)

True
False
True

Строка a is c даёт True — это и есть признак того, что c = a копией не было. Оператор is в обычном коде нужен редко; его основное штатное применение — проверка if value is None.

§6Вложенные списки

Поверхностная копия копирует только внешний список. Элементы в неё переносятся как есть — а если элемент сам является списком, обе коллекции продолжают ссылаться на один и тот же вложенный объект.

original ──→ [ • , • ]
                │   │
                ▼   ▼
             [1,2] [3,4]      ← общие
                ▲   ▲
                │   │
copied   ──→ [ • , • ]

original = [[1, 2], [3, 4]]
copied = original.copy()

copied[0][0] = 100

print(original)
print(copied)

[[100, 2], [3, 4]]
[[100, 2], [3, 4]]

При этом внешние списки всё-таки независимы. Добавление элемента в копию оригинала не касается:

copied.append([9, 9])

print(original)
print(copied)

[[100, 2], [3, 4]]
[[100, 2], [3, 4], [9, 9]]

§7deepcopy(): все уровни

Когда нужна независимость на всех уровнях вложенности, берут deepcopy() из модуля copy. Он проходит структуру целиком и создаёт новые объекты для каждого уровня.

import copy

original = [[1, 2], [3, 4]]
copied = copy.deepcopy(original)

copied[0][0] = 100

print(original)
print(copied)

[[1, 2], [3, 4]]
[[100, 2], [3, 4]]

Для плоского списка чисел или строк copy() достаточно: числа и строки неизменяемы, и «поделиться» ими безопасно. deepcopy() нужен там, где внутри лежат списки, словари или другие изменяемые объекты.

§8len(): количество элементов

len(collection) — встроенная функция, а не метод списка. Она возвращает количество элементов и работает со строками, кортежами, словарями и множествами.

print(len([10, 20, 30]))
print(len("Python"))
print(len([[1, 2], [3, 4]]))

3
6
2

Третий пример показывает важное: для вложенного списка len() считает только верхний уровень — в нём два элемента, и каждый из них список. Та же функция работает с кортежами, словарями и множествами из модуля 4. Записи items.len() не существует — это функция, а не метод.

§9del: удаление

del — оператор, а не метод, поэтому и записывается иначе: ключевое слово перед тем, что удаляют. Он может убрать элемент по индексу, целый срез или само имя переменной.

numbers = [1, 2, 3, 4, 5]

del numbers[1]
print(numbers)

del numbers[1:3]
print(numbers)

[1, 3, 4, 5]
[1, 5]

Второе удаление работает уже с изменённым списком: срез 1:3 убирает из [1, 3, 4, 5] элементы 3 и 4. Правая граница среза не включается — как и в range().

del numbers без индекса удаляет само имя. Если тот же список доступен под другим именем, он остаётся доступным через него. Отдельные элементы строк и кортежей удалить нельзя: эти типы неизменяемы.

§10in и not in

in проверяет наличие равного элемента, а not in — его отсутствие. Результат всегда логический, поэтому его удобно ставить прямо в условие.

numbers = [10, 20, 30]

print(20 in numbers)
print(50 not in numbers)
print("th" in "Python")

True
True
True

Третья строка показывает важное различие: для строки оператор in ищет непрерывный фрагмент, а не отдельный символ. Для списка правило другое — о нём следующий параграф.

§11Подсписок как элемент

Для списка in не ищет непрерывный фрагмент. Он сравнивает проверяемое значение с каждым отдельным элементом целиком.

print([2, 3] in [1, 2, 3, 4])
print([2, 3] in [1, [2, 3], 4])

False
True

В первом случае элементы списка — числа 1, 2, 3, 4, и ни один из них не равен списку [2, 3]. Во втором случае такой элемент действительно есть.

§12in как защита от ошибок

Проверка in — стандартный способ не дать программе упасть там, где методы выбрасывают исключение.

numbers = [10, 20, 30]
value = 99

if value in numbers:
    numbers.remove(value)
else:
    print("нечего удалять")

нечего удалять

§13Метод, функция или оператор

За три главы набралось три разные формы записи. Различать их полезно: от формы зависит и синтаксис, и то, меняется ли исходная коллекция.

Закономерность почти без исключений: методы списка меняют его на месте и возвращают None, а функции ничего не меняют и возвращают новый результат. Пара sort() / sorted() — самая наглядная иллюстрация этого правила.

§14Частые ошибки

§15Проверьте себя

§16Шпаргалка

Итог главы

reverse() меняет порядок исходного списка, copy() создаёт поверхностную копию, len() считает элементы верхнего уровня, del удаляет по позиции или срезу, а in проверяет наличие отдельного элемента. Поверхностная копия защищает только внешний уровень: для вложенных структур нужен deepcopy().