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

Создание списка и смешанные типы данных

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

numbers = [10, 20, 30, 40, 50]
empty = []
letters = list("abc")   # ['a', 'b', 'c']
print(numbers)
print(len(numbers))     # 5
print(letters)

Функция len возвращает количество элементов, и к ней привыкают с первых дней: она пригождается и в проверках, и в циклах. Главная особенность списка в том, что элементы не обязаны быть одного типа. Число, строка, логическое значение и даже другой список спокойно уживаются под одной крышей:

mixed = [42, "привет", 3.14, True, [1, 2, 3]]
print(mixed[1])     # привет
print(mixed[4])     # [1, 2, 3]
print(mixed[4][0])  # 1

Списки легко складываются друг с другом: знак плюс склеивает два списка в третий, новый, а звёздочка повторяет готовый список нужное число раз:

first = [1, 2, 3]
second = [4, 5]
print(first + second)   # [1, 2, 3, 4, 5]
print([0] * 5)          # [0, 0, 0, 0, 0]

Такая свобода выручает, когда данные разнородные: карточка человека может держать имя строкой, возраст числом и список телефонов вложенным списком. В реальных проектах программисты чаще собирают однотипные списки, потому что с ними меньше сюрпризов, но язык никак не ограничивает фантазию и не требует объявлять тип заранее.

Индексы с нуля и отрицательная нумерация

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

fruits = ["яблоко", "банан", "вишня", "груша"]
print(fruits[0])   # яблоко
print(fruits[2])   # вишня
print(fruits[3])   # груша
print(fruits[-1])  # груша
print(fruits[-2])  # вишня

Отрицательные индексы отсчитываются с конца списка, и это не экзотика, а повседневный инструмент. Последний элемент почти всегда достают через [-1], потому что не нужно помнить его позицию. Полезное правило звучит так: положительные номера считают с начала, отрицательные с конца, и в списке длины n номер n-1 указывает на тот же элемент, что и номер -1.

Индекс годится не только для чтения. Присваивание по номеру перезаписывает старое значение новым, и для этого не требуется ничего удалять:

fruits[1] = "апельсин"
print(fruits)  # ['яблоко', 'апельсин', 'вишня', 'груша']

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

prices = [100, 250, 80]
print(prices[0] + prices[2])   # 180
print(prices[-1] < prices[0])  # True

Срезы достают диапазон элементов с шагом

Индекс даёт один элемент, а срез вырезает целую часть списка. Запись вида [a:b] читается как "возьми элементы с позиции a включительно по b исключительно". Любую границу можно опустить: без начала срез начинается с первого элемента, без конца тянется до последнего:

days = ["пн", "вт", "ср", "чт", "пт", "сб", "вс"]
print(days[1:4])   # ['вт', 'ср', 'чт']
print(days[:3])    # ['пн', 'вт', 'ср']
print(days[4:])    # ['пт', 'сб', 'вс']
print(days[:])     # копия всего списка

Третий параметр задаёт шаг. Шаг 2 оставляет каждый второй элемент, отрицательный шаг идёт по списку в обратную сторону и заодно переворачивает его:

nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(nums[::2])    # [0, 2, 4, 6, 8]
print(nums[1::3])   # [1, 4, 7]
print(nums[::-1])   # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

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

row = [1, 2, 3, 4, 5]
row[1:3] = [20, 30, 40]
print(row)   # [1, 20, 30, 40, 4, 5]

Срез никогда не меняет исходный список, он возвращает новый, и на этом держится приятное свойство: выход за границы внутри среза не вызывает ошибку. Срез [5:100] от списка из семи элементов спокойно вернёт то, что существует, без лишних вопросов. С одиночным индексом поведение другое, и об этой разнице полезно помнить: к ошибке IndexError разговор вернётся в конце урока. Те же правила работают у строк и у кортежей, так что навык окупится не единожды.

Методы добавления и удаления элементов

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

  1. append добавляет один элемент в конец списка;
  2. insert вставляет элемент по любому индексу, сдвигая остальные;
  3. remove удаляет первое вхождение значения по его содержимому;
  4. pop вынимает элемент по индексу и возвращает его, без аргумента берёт последний;
  5. clear очищает список полностью.

Небольшой пример собирает все пять в одну историю:

todo = []
todo.append("Купить хлеб")
todo.append("Позвонить маме")
todo.insert(0, "Полить цветы")
print(todo)            # ['Полить цветы', 'Купить хлеб', 'Позвонить маме']

todo.remove("Купить хлеб")
last = todo.pop()
print(todo)            # ['Полить цветы']
print(last)            # Позвонить маме

Пара append и pop превращает список в стек, структуру, где последним добавили, первым и забрали. Достаточно ограничиться этими двумя операциями, и список поведёт себя как аккуратная стопка тарелок:

stack = []
stack.append("первый")
stack.append("второй")
stack.append("третий")
print(stack.pop())  # третий
print(stack.pop())  # второй

А вызов pop(0) забирает элемент с начала списка, что выручает, когда порядок обработки обязан совпадать с порядком поступления заявок. Метод remove ищет значение по содержимому и убирает только первое совпадение, остальные остаются на своих местах. Если значения в списке нет, remove отвечает ошибкой ValueError, поэтому перед удалением наличие проверяют оператором in. Метод pop выручает, когда элемент нужен и вне списка: он одновременно удаляет значение и возвращает его, а без аргумента берёт последний элемент. Метод clear применяют нечасто, обычно вместо очистки переменной присваивают новый пустой список, но в чужом коде он встречается, и распознать его стоит.

Сортировка списка и поиск нужных значений

Метод sort расставляет элементы по возрастанию прямо в исходном списке, а функция sorted возвращает новый отсортированный список и старый не трогает. Разница между ними - классический вопрос на собеседовании, и ответ лучше запомнить сразу:

marks = [7, 3, 9, 1, 5]
marks.sort()
print(marks)            # [1, 3, 5, 7, 9]

source = [4, 2, 8]
result = sorted(source)
print(source)           # [4, 2, 8] без изменений
print(result)           # [2, 4, 8]

Аргумент reverse=True переводит порядок на убывающий. Отдельный метод reverse ничего не сортирует, а просто разворачивает список задом наперёд:

marks.sort(reverse=True)
print(marks)            # [9, 7, 5, 3, 1]
marks.reverse()
print(marks)            # [1, 3, 5, 7, 9]

Для быстрой оценки содержимого есть функции max и min: первая находит наибольшее значение, вторая наименьшее, и обе обходят список без единого цикла в коде:

temps = [12, 7, 19, 3, 15]
print(max(temps))  # 19
print(min(temps))  # 3

Строки сортируются по алфавиту, числа по величине, и в обоих случаях вся работа укладывается в один вызов. Проверка наличия выполняется оператором in, который отвечает True или False. Метод index сообщает индекс первого вхождения значения, метод count считает, сколько раз значение встретилось в списке:

guests = ["Анна", "Борис", "Вера", "Борис"]
print("Вера" in guests)      # True
print("Олег" in guests)      # False
print(guests.index("Вера"))  # 2
print(guests.count("Борис")) # 2

Связка if значение in список перед вызовом index спасает от ошибки ValueError, когда элемента в списке нет. В примере строки, но с числами всё работает точно так же.

Перебор списка циклом for и функция enumerate

Перебрать список по элементам проще всего, отдав его циклу for напрямую, без всяких range:

scores = [4, 5, 3, 5, 4]
total = 0
for score in scores:
    total += score
print(total)  # 21

Когда вместе со значением нужен его номер, выручает функция enumerate: на каждом шаге она отдаёт пару из индекса и элемента, и код становится чище, чем при ручном подсчёте:

for i, score in enumerate(scores):
    print(i, score)   # 0 4, 1 5, 2 3 и так далее

У enumerate есть приятный второй аргумент: start=1 начинает нумерацию с единицы, и человек рядом с экраном видит привычные номера, а не программистский ноль:

tasks = ["Купить хлеб", "Позвонить маме", "Полить цветы"]
for n, task in enumerate(tasks, start=1):
    print(n, task)   # 1 Купить хлеб, 2 Позвонить маме, 3 Полить цветы

Вариант через range(len(scores)) тоже встречается, и у него есть законное место там, где по ходу перебора значения перезаписываются по индексу:

for i in range(len(scores)):
    scores[i] = scores[i] * 2
print(scores)  # [8, 10, 6, 10, 8]

Для простого суммирования в Python припасена функция sum: она принимает список и складывает всё сама. Цикл с накоплением при этом остаётся отличной тренировкой и выручает, когда правило сложения нестандартное, например нужны только чётные значения.

Вложенные списки и защита от IndexError

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

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
]
print(matrix[1])     # [4, 5, 6], вся вторая строка
print(matrix[1][2])  # 6, вторая строка, третий столбец
matrix[0][0] = 99
print(matrix[0])     # [99, 2, 3]

Двойные квадратные скобки читаются слева направо: первая пара выбирает строку, вторая элемент внутри неё. Присваивание через matrix[0][0] меняет конкретную ячейку. Обойти всю матрицу помогают вложенные циклы, внешний шагает по строкам, внутренний по значениям строки:

for row in matrix:
    for value in row:
        print(value, end=" ")
    print()

Классическая задача по матрице - посчитать сумму каждой строки. Вложенный цикл справляется с ней за пару ходов, а функция sum складывает значения строки одной фразой:

for i, row in enumerate(matrix):
    print("Строка", i, "сумма", sum(row))   # Строка 0 сумма 104 и так далее

Настала очередь главной ловушки темы. Обращение к индексу за границами списка вызывает ошибку IndexError, и новичок встречает её раньше любой другой:

short = ["a", "b"]
print(short[5])   # IndexError: list index out of range

empty = []
print(empty[0])   # IndexError: list index out of range

Сообщение list index out of range честно намекает, что запрошенного номера не существует. Защита простая: перед обращением сверяться с длиной через len, держать в голове, что последний допустимый индекс равен len-1, и помнить про предел у отрицательных номеров, ведь в списке из двух элементов номер -3 уже за границей. Второй частый источник сюрпризов - пустой список: у него нет даже нулевого элемента, поэтому обращение по индексу к пустому списку падает с той же ошибкой.

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