Прошлый урок показал, как цикл 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 разговор вернётся в конце урока. Те же правила работают у строк и у кортежей, так что навык окупится не единожды.
Методы добавления и удаления элементов
Список живёт после создания: значения дописываются, вставляются в середину, убираются за ненадобностью. Пять методов закрывают большинство повседневных задач:
- append добавляет один элемент в конец списка;
- insert вставляет элемент по любому индексу, сдвигая остальные;
- remove удаляет первое вхождение значения по его содержимому;
- pop вынимает элемент по индексу и возвращает его, без аргумента берёт последний;
- 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 уже за границей. Второй частый источник сюрпризов - пустой список: у него нет даже нулевого элемента, поэтому обращение по индексу к пустому списку падает с той же ошибкой.
Список стал первым изменяемым контейнером курса, и всё, что он умеет, пригодится дальше. Следующий урок познакомит с кортежами и множествами, двумя родственниками списка: кортеж после создания не меняется, а множество хранит только уникальные значения. После списков разница почувствуется за один вечер.