Списки

Зачем нужны списки

Представьте, что вы записываете оценки за контрольную у целого класса — тридцать учеников. Заводить тридцать отдельных переменных grade1, grade2, grade3 и так далее — неудобно и почти невозможно: вы не сможете написать программу, которая одинаково работает и для десяти учеников, и для тридцати. Нужен способ хранить много значений под одним именем, чтобы можно было обращаться то к одному из них, то ко всем сразу.

Именно для этого в Python существуют коллекции — типы данных, которые хранят внутри себя сразу несколько значений. Список — первая и самая ходовая из них.

Официальный термин: список (list) — это упорядоченная и изменяемая коллекция элементов. "Упорядоченная" значит, что элементы хранятся именно в том порядке, в котором вы их положили, и у каждого есть свой номер (индекс). "Изменяемая" значит, что список можно менять после создания: добавлять, удалять, заменять элементы — в отличие, например, от строки, которую после создания изменить нельзя.

Создание списка: [] и list()

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

Официальный термин: запись [значение1, значение2, ...] называется литералом списка. Есть и второй способ — встроенная функция list(), которая превращает в список что-то другое: строку, диапазон range() или другую коллекцию.

grades = [5, 4, 5, 3, 5, 4]
fruits = ["яблоко", "банан", "вишня"]
empty = []

letters = list("hello")
numbers = list(range(1, 6))

Добавление элементов: append, insert, extend

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

Термины: действие, которое можно выполнить над объектом (в данном случае — над списком), называется методом. Метод вызывают через точку после переменной: список.метод(аргументы).

cart = ["хлеб", "молоко"]

cart.append("сыр")
print(cart)

cart.insert(1, "яйца")
print(cart)

more_items = ["масло", "сахар"]
cart.extend(more_items)
print(cart)

Удаление элементов: remove, pop, del, clear

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

Термины: remove(значение) ищет и удаляет первое совпадение по значению. pop(индекс) удаляет элемент по индексу и, в отличие от остальных способов, возвращает удалённый элемент. del список[индекс] — это не метод, а отдельный оператор языка, тоже удаляет по индексу, но ничего не возвращает. clear() удаляет всё содержимое, оставляя пустой список.

letters = ["a", "b", "c", "b", "d"]
letters.remove("b")
print(letters)

numbers = [10, 20, 30, 40]
removed = numbers.pop(1)
print(removed)
print(numbers)

del numbers[0]
print(numbers)

Разбор по шагам:

• letters.remove("b") — ищет первое "b" в списке и убирает именно его. Второе "b" остаётся: ["a", "c", "b", "d"].
• removed = numbers.pop(1) — удаляет элемент с индексом 1 (это 20) и сразу возвращает его в переменную removed. Печать removed покажет 20.
• print(numbers) после pop покажет [10, 30, 40] — элемент с индексом 1 пропал.
• del numbers[0] — удаляет элемент с индексом 0 (10), но ничего не возвращает, поэтому эту строку нельзя присвоить переменной. После неё numbers равен [30, 40].

Поиск и подсчёт: in, index(), count(), len()

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

Термины: оператор in проверяет принадлежность и возвращает True или False. Метод index(значение) возвращает индекс первого совпадения. Метод count(значение) считает, сколько раз значение встречается. Функция len(список) вам уже знакома по строкам — для списка она возвращает число элементов.

nums = [3, 7, 2, 9, 7, 1]

print(7 in nums)
print(5 in nums)
print(nums.index(7))
print(nums.count(7))
print(len(nums))

По порядку: 7 in nums — True, семёрка в списке есть. 5 in nums — False, пятёрки нет. nums.index(7) вернёт 1 — это индекс ПЕРВОЙ семёрки (вторая, на индексе 4, не в счёт). nums.count(7) вернёт 2 — семёрка встречается дважды. len(nums) вернёт 6 — всего элементов.

Сортировка: sort() и sorted()

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

Термины: sort() — метод, который сортирует список "на месте": меняет сам исходный список и ничего не возвращает (точнее, возвращает None). sorted(список) — встроенная функция, которая создаёт и возвращает НОВЫЙ отсортированный список, а исходный оставляет без изменений.

nums = [3, 1, 4, 1, 5]
nums.sort()
print(nums)

original = [3, 1, 4, 1, 5]
new_list = sorted(original)
print(original)
print(new_list)

desc = sorted(original, reverse=True)
print(desc)

Что произошло: nums.sort() отсортировал сам список nums — печать покажет [1, 1, 3, 4, 5]. А вот original после sorted(original) остался прежним: [3, 1, 4, 1, 5], потому что sorted() не трогает исходный список, а собирает новый и отдаёт его в new_list. Аргумент reverse=True у обоих способов разворачивает порядок на убывание.

Копирование: почему b = a — ловушка

Простыми словами: когда вы пишете b = a для чисел или строк, у вас появляются два независимых значения. Со списками это правило неожиданно ломается — и это самая частая путаница у новичков.

Термин: список — изменяемый объект, и переменная хранит не сам список, а ссылку на него — место, где он лежит в памяти. Запись b = a не создаёт новый список, а создаёт второе имя для ТОГО ЖЕ списка. Изменение через одно имя видно через другое.

a = [1, 2, 3]
b = a
b.append(4)
print(a)
print(b)

c = a.copy()
c.append(99)
print(a)
print(c)

Разбор: b = a — теперь a и b смотрят на один и тот же список. b.append(4) меняет этот единственный список, поэтому и print(a), и print(b) покажут [1, 2, 3, 4], хотя изменяли через b. Дальше c = a.copy() создаёт настоящую, независимую копию. c.append(99) меняет только c: print(a) по-прежнему покажет [1, 2, 3, 4], а print(c) — [1, 2, 3, 4, 99].

Объединение и повтор: + и *

Простыми словами: два списка можно "склеить" в один новый, а один список — размножить несколько раз подряд.

Термин: оператор + между списками возвращает НОВЫЙ список из элементов обоих, не трогая исходные. Оператор * между списком и числом повторяет содержимое списка нужное число раз.

a = [1, 2, 3]
b = [4, 5, 6]
c = a + b
print(c)
print(a)

zeros = [0] * 5
print(zeros)

c = a + b создаёт новый список [1, 2, 3, 4, 5, 6], а a остаётся [1, 2, 3] — операция ничего не меняет в исходных списках. [0] * 5 повторяет список из одного нуля пять раз подряд: [0, 0, 0, 0, 0]. Этим приёмом удобно готовить заготовку нужного размера, например поле для игры.

Перебор списка через while

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

fruits = ["яблоко", "банан", "вишня"]

i = 0
while i < len(fruits):
    print(fruits[i])
    i += 1

Разбор: i = 0 — начинаем с первого индекса. Условие i < len(fruits) держит цикл, пока индекс не выйдет за границы списка. fruits[i] внутри тела берёт элемент под текущим номером. i += 1 в конце каждого прохода сдвигает счётчик на следующий индекс. Программа напечатает по очереди яблоко, банан, вишня.

Вложенные списки — матрицы и таблицы

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

Термин: список, элементами которого являются другие списки, называют вложенным списком, а прямоугольную таблицу из чисел — матрицей. Чтобы попасть в конкретную ячейку, к списку применяют индекс дважды подряд: matrix[строка][столбец].

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
]

print(matrix[0][0])
print(matrix[1][2])

matrix[0][1] = 99
print(matrix[0])

Разбор: matrix — это список из трёх списков, каждый по три числа. matrix[0] берёт первую строку целиком, [1, 2, 3], а второй индекс [0] берёт из неё первый элемент — получаем 1. matrix[1][2] означает "вторая строка (индекс 1), третий элемент (индекс 2)" — это 6. Присваивание matrix[0][1] = 99 заменяет элемент внутри вложенного списка: строка с индексом 0 становится [1, 99, 3].

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

Ошибка 1. Спутать append и extend.

items = [1, 2, 3]
items.append([4, 5])
print(items)

Ожидали [1, 2, 3, 4, 5], а получили [1, 2, 3, [4, 5]] — список [4, 5] добавился как один-единственный элемент. Нужен был extend([4, 5]).

Ошибка 2. Забыть, что index() падает с ошибкой.

colors = ["красный", "синий"]
position = colors.index("зелёный")

Программа остановится с ValueError: 'зелёный' is not in list, потому что такого значения в списке нет. Перед вызовом index() для непроверенного значения используйте in.

Ошибка 3. Думать, что b = a создаёт копию.

original = [1, 2, 3]
backup = original
backup.append(4)
print(original)

Многие ждут, что original не изменится, ведь меняли backup. На деле выведет [1, 2, 3, 4] — backup и original это одно и то же место в памяти под двумя именами. Для независимой копии нужен original.copy().