Python: полный мануал с примерами и справочником функций

Глава 5 · начальный

Списки, кортежи и изменение данных

Организовать последовательность и понимать, какие действия её изменяют.

Последовательность нужна, когда важны порядок и положение элементов: шаги инструкции, строки отчёта, карточки каталога. Список удобно изменять, кортеж — использовать как фиксированную запись, range — описывать диапазон целых. Сначала решите, меняется ли набор по ходу работы и нужно ли сохранять исходный порядок. Одинаковый внешний вид квадратных или круглых скобок не означает одинаковый договор данных.

Список и кортеж

list хранит упорядоченные элементы и позволяет добавлять, удалять и заменять их. Элементы могут иметь разные типы, но для обработки обычно проще придерживаться одной понятной структуры. tuple тоже хранит порядок, однако его позиции нельзя переназначить. Одноэлементный кортеж записывается с запятой: (value,). Одни скобки вокруг значения кортеж не создают.

Неизменяемость кортежа не замораживает вложенный список. Если кортеж содержит список, этот список можно изменить. Поэтому кортеж не всегда годится как ключ словаря: все его элементы тоже должны быть хешируемыми. Для записи вроде пары координат из чисел кортеж удобен; для растущего списка задач обычно понятнее list.

Индекс, срез и диапазон

Индексы начинаются с нуля; отрицательный индекс считает с конца. Отсутствующая позиция вызывает IndexError. Срез items[start:stop:step] берёт элементы до stop, не включая границу. Выходящие за края границы среза допустимы. Для списка срез создаёт новый внешний список, но вложенные объекты остаются общими. Проверяйте пустой список перед обращением к первой позиции.

range(start, stop, step) описывает арифметическую последовательность целых и не хранит отдельный список каждого числа. Stop также не включается; шаг не может быть нулём. Для движения назад нужен отрицательный шаг и согласованные границы. range(3) даст 0, 1, 2, а не 1, 2, 3. Для номера позиции в готовом наборе чаще удобнее enumerate.

Добавление, удаление и возвращаемое значение

append(x) добавляет один объект. extend(values) добавляет элементы другого iterable, а insert(index, x) вставляет в указанное место. Если передать список в append, он останется одним вложенным элементом. pop() удаляет и возвращает элемент, remove(x) удаляет первое равное значение и при отсутствии вызывает ValueError. Выбирайте метод по тому, известна позиция или значение.

Методы изменения вроде sort() обычно возвращают None. Поэтому items = items.sort() теряет ссылку на список в этом имени. Сам объект отсортирован, но имя теперь обозначает None. Если нужна новая сортированная последовательность, используйте sorted(). Такое разделение помогает сохранять исходник для повторного сравнения.

items = [3, 1, 2]
result = items.sort()
print(items)
print(result)
items.append([4, 5])
print(items)
items.pop()
items.extend([4, 5])
print(items)

[1, 2, 3]
None
[1, 2, 3, [4, 5]]
[1, 2, 3, 4, 5]

Критерий и стабильная сортировка

Параметр key задаёт значение, по которому сортируются элементы. Для записей это может быть цена или пара «цена, название». Сортировка стабильна: равные ключи сохраняют взаимный порядок исходных элементов. Это удобно, когда сначала выбран важный порядок поступления и его нужно оставить при одинаковых оценках. Reverse меняет направление сортировки; он не превращает произвольный ключ в другой смысл.

records = [
    {"name": "Макет", "price": 150},
    {"name": "Иконка", "price": 100},
    {"name": "Шаблон", "price": 100},
]
ordered = sorted(records, key=lambda record: record["price"])
print([record["name"] for record in ordered])
print([record["name"] for record in records])

['Иконка', 'Шаблон', 'Макет']
['Макет', 'Иконка', 'Шаблон']

Строки по умолчанию сравниваются по значениям Unicode, а не по любому желаемому языковому порядку. Если задача требует безрегистровой сортировки, задайте подходящий key, например casefold. Для смешанных несовместимых типов вроде числа и словаря обычная сортировка не знает универсального порядка. Лучше нормализовать данные или явно определить критерий.

Копия и общие вложенные объекты

items.copy(), list(items) и срез items[:] создают поверхностную копию списка. Изменение его внешних позиций не изменит исходные позиции, однако оба списка ещё ссылаются на одни вложенные объекты. copy.deepcopy() копирует вложенную структуру по правилам объектов. Используйте глубокую копию по необходимости, а не как обязательную операцию для любого числа или строки.

from copy import deepcopy

original = [[1], [2]]
shallow = original.copy()
deep = deepcopy(original)
shallow[0].append(9)
print(original)
print(deep)
shared_rows = [[]] * 2
shared_rows[0].append("x")
print(shared_rows)
independent_rows = [[] for _ in range(2)]
independent_rows[0].append("x")
print(independent_rows)

[[1, 9], [2]]
[[1], [2]]
[['x'], ['x']]
[['x'], []]

Повторение [[]] * n повторяет ссылки на один внутренний список. Для независимых строк создайте каждую отдельно через comprehension. Та же идея нужна при построении таблицы: решить, должны ли ячейки разделять объект или хранить собственное состояние. Ошибка общего объекта может проявиться только после первого изменения, поэтому проверяйте не только первоначальный вывод.

Comprehension, enumerate и zip

Comprehension удобно описывает небольшое преобразование: [x * x for x in values if x > 0]. Для нескольких побочных действий яснее обычный цикл. Не удаляйте элементы списка одновременно с обходом того же списка: позиции сдвигаются и часть значений можно пропустить. Создайте отфильтрованный результат отдельно либо обходите специально подготовленную копию.

enumerate(items, start=1) даёт номер и элемент. zip(a, b) объединяет наборы по позициям и обычно останавливается на самом коротком. Если длины обязаны совпасть, с Python 3.10 используйте strict=True: несовпадение станет ошибкой при обходе. Сам zip — ленивый объект, поэтому проверка возникает во время потребления, а не обязательно в строке его создания.

names = ["А", "Б"]
counts = [2]
try:
    pairs = list(zip(names, counts, strict=True))
except ValueError:
    print("Длины не совпали")
for number, name in enumerate(names, start=1):
    print(number, name)

Длины не совпали
1 А
2 Б

Bytes, bytearray и представление буфера

bytes неизменяемы, bytearray допускает изменение байтов. Индекс даёт целое число, не односимвольный str. memoryview предоставляет доступ к буферу без обязательного создания отдельной копии его содержимого. Возможность записи зависит от исходного буфера. Эти типы полезны для двоичных форматов; для обычного текста сначала выполните decode с согласованной кодировкой.

data = bytearray(b"ABC")
with memoryview(data) as view:
    view[1] = ord("Z")
    print(bytes(data))
    print("Только чтение:", view.readonly)
data.append(ord("D"))
print(bytes(data))

b'AZC'
Только чтение: False
b'AZCD'

View обращается к исходному буферу: изменение через него видно в bytearray. После блока with представление освобождено, и исходную последовательность можно увеличить. Пока представление активно, изменение размера такого буфера может быть запрещено. Не обращайтесь к освобождённому view; хранить отдельную постоянную копию следует через bytes, если именно это требуется дальнейшей обработке.

Упражнение: фильтрация без изменения исходника

Из значений [3, -1, 0, 4] создайте список квадратов положительных чисел. Ноль здесь исключён по правилу задачи, исходный список должен остаться прежним. Проверьте также пустой вход. Для этого преобразования достаточно comprehension; временное удаление элементов из исходного списка не требуется.

values = [3, -1, 0, 4]
squares = [value * value for value in values if value > 0]
print(squares)
print(values)
print([value * value for value in [] if value > 0])

[9, 16]
[3, -1, 0, 4]
[]

Методы и свойства list

Все 11 методов списка из официального раздела More on Lists; многие методы на странице типов описаны как общие операции последовательностей, поэтому индивидуального list.* якоря у них нет.