Кот-наставник— Список покупок - банальная, но хорошая учебная программа. И вот для каждой покупки в чеке ты заводишь отдельную переменную:
item1,item2,item3... А если покупок сто?— Списки придумали ровно для этого: одна переменная — и в ней сколько угодно значений. Сейчас разберёмся, как с ними работать.
Список (list) — это самая используемая структура данных в Python. Если ты только начинаешь и пришёл за ответом на запрос «как работают списки python» — это та тема, без которой дальше никуда: списки встречаются буквально в каждой программе. Разберём всё по порядку: как создать список, как достать из него элемент, как добавлять, удалять, искать, сортировать и резать на части. С рабочими примерами, которые можно повторить.
Под списком понимается упорядоченная коллекция значений, которые хранятся в одной переменной. Представь коробку с пронумерованными ячейками: в каждой ячейке лежит какое-то значение, а у каждой ячейки есть свой номер.
Список (
list) — упорядоченная изменяемая коллекция элементов. Элементы идут по порядку и нумеруются с нуля. В одном списке могут лежать значения любых типов.
Как создать список?
Список создаётся в квадратных скобках [], а элементы внутри перечисляются через запятую.
Создадим первый список — список покупок:
shopping = ["молоко", "хлеб", "яйца"]
print(shopping)['молоко', 'хлеб', 'яйца']
Синтаксис списка:
- Квадратные скобки
[]обозначают список - Элементы перечисляются через запятую
- Типы можно смешивать: строки, числа, даже другие списки
Списки могут хранить что угодно — и даже быть пустыми:
numbers = [1, 2, 3, 4, 5]
names = ["Анна", "Борис", "Вера"]
mixed = [42, "Python", 3.14, True] # типы вперемешку — это норма
empty = [] # пустой список
print(numbers)
print(mixed)
print(empty)[1, 2, 3, 4, 5] [42, 'Python', 3.14, True] []
Доступ к элементам по индексу
Каждый элемент списка имеет индекс — порядковый номер. Главное, что нужно запомнить: нумерация начинается с нуля, а не с единицы. Первый элемент — это список[0].
Получим элементы списка по индексу:
fruits = ["яблоко", "банан", "апельсин", "груша"]
print(fruits[0]) # первый
print(fruits[1]) # второй
print(fruits[3]) # четвёртыйяблоко банан груша
Список fruits = ["яблоко", "банан", "апельсин", "груша"]. Каждый элемент доступен по двум индексам: положительному (отсчёт с начала, с нуля) и отрицательному (отсчёт с конца).
| Элемент | Индекс с начала | Индекс с конца |
|---|---|---|
| "яблоко" | 0 | -4 |
| "банан" | 1 | -3 |
| "апельсин" | 2 | -2 |
| "груша" | 3 | -1 |
Отрицательные индексы отсчитываются с конца списка. Это удобно, когда нужен последний элемент, а длину списка ты заранее не знаешь: список[-1] — всегда последний.
Достанем элементы с конца:
fruits = ["яблоко", "банан", "апельсин", "груша"]
print(fruits[-1]) # последний
print(fruits[-2]) # предпоследнийгруша апельсин
numbers = [10, 20, 30]
print(numbers[5])Почему возникает эта ошибка, как вычислить последний допустимый индекс и безопасно получить последний элемент через [-1] — в статье IndexError: list index out of range в Python.
Длина списка: функция len()
Функция len() возвращает количество элементов в списке. Та же функция, что и для строк.
shopping = ["молоко", "хлеб", "яйца", "сыр"]
count = len(shopping)
print("Товаров в списке:", count)
print("Последний индекс:", count - 1)Товаров в списке: 4 Последний индекс: 3
Срезы списков (slices)
Срез — это способ взять не один элемент, а целый кусок списка. Синтаксис: список[начало:конец]. Важный нюанс: элемент с индексом начало входит в срез, а элемент с индексом конец — нет (граница не включается).
Возьмём разные куски списка:
nums = [10, 20, 30, 40, 50, 60]
print(nums[1:4]) # с индекса 1 до 4 (не включая 4)
print(nums[:3]) # с начала до индекса 3
print(nums[3:]) # с индекса 3 до конца
print(nums[-2:]) # последние два[20, 30, 40] [10, 20, 30] [40, 50, 60] [50, 60]
У среза есть третий параметр — шаг: список[начало:конец:шаг]. С его помощью можно брать каждый второй элемент или развернуть список задом наперёд.
Шаг среза и разворот списка:
nums = [10, 20, 30, 40, 50, 60]
print(nums[::2]) # каждый второй элемент
print(nums[::-1]) # список задом наперёд[10, 30, 50] [60, 50, 40, 30, 20, 10]
Изменение элементов списка
Списки в Python изменяемые — это одно из их главных свойств. Чтобы поменять элемент, обращаемся к нему по индексу, но теперь ставим его слева от знака =.
fruits = ["яблоко", "банан", "апельсин"]
print("До:", fruits)
fruits[1] = "манго"
print("После:", fruits)До: ['яблоко', 'банан', 'апельсин'] После: ['яблоко', 'манго', 'апельсин']
numbers = [10, 20, 30]
backup = numbers # это НЕ копия, а вторая ссылка
numbers[0] = 999
print("numbers:", numbers)
print("backup:", backup)numbers: [999, 20, 30] backup: [999, 20, 30]
Кот-наставник— Удивлён, что
backupтоже изменился?numbersиbackup— это две таблички с именами на одной и той же коробке.— Чтобы получить настоящую копию, используй срез
backup = numbers[:]илиbackup = list(numbers). Тогда коробки будут разные.
Как добавить элемент в список?
Списки динамические — они растут и уменьшаются на лету. Для добавления есть три метода и один оператор. Разберём, когда какой нужен.
Метод .append() — добавить в конец
.append() добавляет один элемент в самый конец списка — это самый частый способ:
tasks = ["Проснуться", "Позавтракать"]
tasks.append("Написать код")
print(tasks)['Проснуться', 'Позавтракать', 'Написать код']
Метод .insert() — вставка в нужное место
.insert(индекс, элемент) вставляет элемент перед указанным индексом, а остальные сдвигает вправо:
tasks = ["Обед", "Встреча", "Отчёт"]
tasks.insert(0, "Позвонить клиенту")
print(tasks)['Позвонить клиенту', 'Обед', 'Встреча', 'Отчёт']
Метод .extend() и оператор + — соединить списки
.extend() добавляет в список все элементы другого списка по очереди. А оператор + склеивает два списка в новый, не трогая исходные.
.append([4, 5]) — добавляет список как один элемент
numbers = [1, 2, 3]
numbers.append([4, 5])
print(numbers) # [1, 2, 3, [4, 5]]Метод .append() кладёт переданный список целиком, одним вложенным элементом. В списке становится 4 элемента: последний — это вложенный список [4, 5].
.extend([4, 5]) — добавляет элементы по отдельности
numbers = [1, 2, 3]
numbers.extend([4, 5])
print(numbers) # [1, 2, 3, 4, 5]Метод .extend() разбирает переданный список и добавляет каждый его элемент по отдельности. В списке становится 5 элементов.
Подробное сравнение поведения обоих методов, вложенных списков и ловушки extend() со строкой — в статье append vs extend в Python: в чём разница.
Как удалить элемент из списка?
Способов удаления несколько, и каждый — под свою ситуацию: знаешь значение, знаешь индекс или хочешь забрать удалённый элемент себе.
Три основных способа удаления:
shopping = ["хлеб", "молоко", "яйца", "сыр"]
shopping.remove("молоко") # по значению
print("remove:", shopping)
last = shopping.pop() # удалить и вернуть последний
print("pop вернул:", last)
print("после pop:", shopping)
del shopping[0] # по индексу, без возврата
print("del:", shopping)remove: ['хлеб', 'яйца', 'сыр'] pop вернул: сыр после pop: ['хлеб', 'яйца'] del: ['яйца']
| Способ | Что указываешь | Возвращает элемент | Когда использовать 4 |
|---|---|---|---|
| .remove(значение) | Значение | Нет | Знаешь, что удалить |
| .pop(индекс) | Индекс | Да | Нужен удалённый элемент |
| .pop() | — | Да | Удалить последний |
| del список[индекс] | Индекс | Нет | Знаешь, где удалить |
| .clear() | — | Нет | Очистить весь список |
Перебор списка в цикле
Чаще всего со списком хочется не достать один элемент, а пройтись по всем. Самый питоничный способ — цикл for: он сам берёт элементы по очереди, без всяких индексов. Сами циклы — for, while, функция range() и операторы break с continue — разобраны в гайде Циклы в Python: for, while, break и continue.
Простой перебор через for:
fruits = ["яблоко", "банан", "апельсин"]
for fruit in fruits:
print("Беру:", fruit)Беру: fruit
А если нужен и номер элемента, и его значение — используй enumerate(). Он выдаёт пару «индекс + элемент» на каждом шаге.
Перебор с нумерацией:
fruits = ["яблоко", "банан", "апельсин"]
for i, fruit in enumerate(fruits, start=1):
print(f"{i}. {fruit}")i_s. fruit
Поиск элементов в списке
Три инструмента под три вопроса: есть ли элемент (in), где он стоит (.index()) и сколько раз встречается (.count()).
Проверяем наличие, позицию и количество:
chat = ["привет", "как дела", "привет", "пока", "привет"]
print("привет" in chat) # есть ли вообще
print(chat.index("привет")) # индекс первого вхождения
print(chat.count("привет")) # сколько раз встречается
print("спам" not in chat) # удобно для проверокTrue 0 3 True
| Операция | Что возвращает | Если элемента нет |
|---|---|---|
| значение in список | True / False | Вернёт False |
| список.index(значение) | Индекс первого вхождения | ValueError — ошибка! |
| список.count(значение) | Число вхождений | Вернёт 0 |
Из всех трёх только .index() может упасть с ошибкой, если элемента нет. in и .count() безопасны. Поэтому .index() всегда прикрывай проверкой через in.
Сортировка списка
Для сортировки есть два инструмента, и важно не путать их. Метод .sort() сортирует список на месте (меняет оригинал), а функция sorted() возвращает новый отсортированный список, оставляя исходный нетронутым. Как функции принимают данные и отдают результат через return, разбираем в гайде Функции в Python: от def до lambda.
Сравним .sort() и sorted():
scores = [42, 17, 88, 5, 63]
new_list = sorted(scores) # новый список, оригинал цел
print("sorted:", new_list)
print("оригинал:", scores)
scores.sort() # меняет сам scores
print("после .sort():", scores)sorted: [5, 17, 42, 63, 88] оригинал: [42, 17, 88, 5, 63] после .sort(): [5, 17, 42, 63, 88]
Чтобы отсортировать по убыванию, добавь параметр reverse=True — он работает и в .sort(), и в sorted(). А вот метод .reverse() — это не сортировка: он просто переворачивает список задом наперёд.
Сортировка по убыванию и разворот — это разные вещи:
scores = [42, 17, 88, 5]
print(sorted(scores, reverse=True)) # сортировка по убыванию
nums = [3, 1, 2]
nums.reverse() # просто переворот, без сортировки
print(nums)[88, 42, 17, 5] [2, 1, 3]
| Операция | Меняет оригинал | Возвращает | Что делает |
|---|---|---|---|
| список.sort() | Да | None | Сортирует на месте |
| sorted(список) | Нет | Новый список | Сортирует в копии |
| sorted(список, reverse=True) | Нет | Новый список | Сортирует по убыванию |
| список.reverse() | Да | None | Переворачивает, не сортируя |
Подробное сравнение, ловушка a = a.sort() и случаи выбора разобраны в статье sort vs sorted в Python: в чём разница.
Быстрая статистика: min(), max(), sum()
Для числовых списков Python даёт три встроенные функции, которые мгновенно отвечают на частые вопросы: какой минимум, какой максимум и какова сумма.
Считаем минимум, максимум, сумму и среднее:
grades = [4, 5, 3, 5, 4, 2]
print("Минимум:", min(grades))
print("Максимум:", max(grades))
print("Сумма:", sum(grades))
print("Среднее:", round(sum(grades) / len(grades), 2))Минимум: 2 Максимум: 5 Сумма: 19 Среднее: 3.83
Генератор списков (list comprehension)
Сравни обычный цикл и генератор:
# Обычный способ
squares = []
for x in range(1, 6):
squares.append(x ** 2)
# То же самое генератором списка
squares = [x ** 2 for x in range(1, 6)]
# С условием — только чётные
evens = [x for x in range(10) if x % 2 == 0]
print(squares)
print(evens)[1, 4, 9, 16, 25] [0, 2, 4, 6, 8]
Шпаргалка по методам списков
| Метод / функция | Что делает? |
|---|---|
| .append(x) | Добавить элемент в конец |
| .insert(i, x) | Вставить элемент на позицию i |
| .extend(other) | Добавить все элементы другого списка |
| .remove(x) | Удалить первое вхождение по значению |
| .pop(i) | Удалить и вернуть элемент (по индексу или последний) |
| .clear() | Удалить все элементы |
| .index(x) | Найти индекс первого вхождения |
| .count(x) | Посчитать, сколько раз встречается |
| .sort() | Отсортировать на месте |
| .reverse() | Перевернуть порядок |
| .copy() | Сделать поверхностную копию |
| len(список) | Количество элементов |
| sorted(список) | Новый отсортированный список |
| min() / max() / sum() | Минимум / максимум / сумма |
Частые ошибки при работе со списками
- Забыл, что индексы с нуля. Первый элемент — это
список[0], а последний —список[len(список) - 1](илисписок[-1]). Обращение к несуществующему индексу даётIndexError. - Присвоил результат
.append()или.sort(). Эти методы меняют список на месте и возвращаютNone. Никогда не пишиx = список.append(...)илиx = список.sort()— потеряешь данные. - Перепутал ссылку и копию.
b = aне создаёт новый список — обе переменные указывают на один и тот же. Нужна настоящая копия — пишиb = a[:]илиb = a.copy().
Главное запомнить
- Список — упорядоченная изменяемая коллекция
nums = [42, "Python", 3.14] # квадратные скобки, типы можно смешиватьЭлементы хранятся по порядку и нумеруются с нуля.
- Доступ — по индексу, кусок — срезом
nums[0] # первый элемент nums[-1] # последний элемент nums[1:3] # срез — кусок списка nums[::-1] # развернуть список - Добавление и удаление — это методы
nums.append(99) # добавить в конец nums.remove(99) # удалить по значению nums.pop() # удалить и вернуть последнийЕщё есть
.insert(),.extend(), операторdelи.clear(). - Перебор — через
forfor x in nums: # самый питоничный способ print(x)Нужен ещё и номер элемента — оберни список в
enumerate(). .sort()и.append()возвращаютNonenums.sort() # верно — список меняется сам nums = nums.sort() # ошибка! теперь nums равен None
Кот-наставник— Списки — это рабочая лошадка Python. Создавать, резать, добавлять, искать, сортировать — теперь ты умеешь всё основное.
— Но читать про код и писать его — разные вещи. Лучший способ закрепить — открыть редактор и пощупать списки руками.
Списки запоминаются не глазами, а пальцами.
На SkillPy списки — это не теория для заучивания, а интерактивная практика: ты сам пишешь код, AI-наставник проверяет каждую строку, ловит ошибки и подсказывает следующий шаг. Результат виден сразу.