Что такое список

Список (list) — это упорядоченная изменяемая коллекция элементов. В одном списке могут быть значения разных типов, хотя обычно хранят однотипные. Создаётся квадратными скобками:

numbers = [1, 2, 3, 4, 5]
fruits = ["яблоко", "банан", "груша"]
mixed = [1, "Анна", True, 3.14]
empty = []

Длина списка — через len():

print(len(numbers))   # 5

Индексация и срезы

Как и у строк, доступ к элементам по индексу (с 0), отрицательные индексы идут с конца:

fruits = ["яблоко", "банан", "груша", "дыня"]

print(fruits[0])    # яблоко
print(fruits[-1])   # дыня — последний
print(fruits[1:3])  # ['банан', 'груша'] — срез
print(fruits[:2])   # ['яблоко', 'банан']
print(fruits[::2])  # ['яблоко', 'груша'] — каждый второй

Изменение списка

Список — изменяемая структура. Можно менять элементы и добавлять новые:

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

fruits[0] = "гранат"          # замена
fruits.append("груша")        # добавить в конец
fruits.insert(1, "киви")      # вставить по индексу
print(fruits)
# ['гранат', 'киви', 'банан', 'груша']

Удаление элементов

fruits = ["яблоко", "банан", "груша", "дыня"]

fruits.remove("банан")     # удалить по значению
del fruits[0]              # удалить по индексу
last = fruits.pop()        # достать и удалить последний
print(fruits)              # ['груша']
print(last)                # дыня

Методы списков

numbers = [3, 1, 4, 1, 5, 9, 2, 6]

print(len(numbers))      # 8 — длина
print(sum(numbers))      # 31 — сумма
print(min(numbers))      # 1
print(max(numbers))      # 9
print(numbers.count(1))  # 2 — сколько раз встречается
print(numbers.index(5))  # 4 — индекс первого вхождения

Сортировка

Есть два способа. sort() меняет исходный список, sorted() — возвращает новый:

numbers = [3, 1, 4, 1, 5]

# sort() — изменяет на месте
numbers.sort()
print(numbers)   # [1, 1, 3, 4, 5]
numbers.sort(reverse=True)
print(numbers)   # [5, 4, 3, 1, 1]

# sorted() — создаёт новый список
original = [3, 1, 4]
sorted_list = sorted(original)
print(original)      # [3, 1, 4] — не изменился
print(sorted_list)   # [1, 3, 4]

Разворот и копирование

a = [1, 2, 3]
a.reverse()         # [3, 2, 1] — на месте

# Копия через срез
b = a[:]            # независимая копия
c = a.copy()        # то же самое

Перебор списка

fruits = ["яблоко", "банан", "груша"]

# Просто элементы
for fruit in fruits:
    print(fruit)

# С индексами
for i, fruit in enumerate(fruits):
    print(f"{i}: {fruit}")

Списочные выражения (list comprehensions)

Это компактный способ создать список на основе другого. Классическая задача — возвести числа в квадрат:

# Длинно — через цикл
squares = []
for n in range(1, 6):
    squares.append(n ** 2)
print(squares)   # [1, 4, 9, 16, 25]

# Коротко — через comprehension
squares = [n ** 2 for n in range(1, 6)]

С условием:

# Только чётные квадраты
even_squares = [n ** 2 for n in range(1, 11) if n ** 2 % 2 == 0]
# [4, 16, 36, 64, 100]

С условным выражением (if/else внутри):

marks = [3, 5, 2, 4, 5]
labels = ["зачёт" if m >= 3 else "незачёт" for m in marks]
# ['зачёт', 'зачёт', 'незачёт', 'зачёт', 'зачёт']

Comprehension читается почти как математическое определение, но не увлекайтесь — если выражение перестаёт помещаться в одну строку, лучше вернуться к обычному циклу.

Кортежи (tuple)

Кортеж — это неизменяемый список. Создаётся круглыми скобками:

point = (10, 20)
single = (42,)        # кортеж из одного элемента — запятая обязательна!
empty = ()

К элементам обращаются так же, как в списке:

print(point[0])    # 10
x, y = point       # распаковка
print(x, y)        # 10 20

Но изменить нельзя:

# point[0] = 5   # TypeError: 'tuple' object does not support item assignment

Зачем нужен кортеж, если есть список

• Неизменяемость — гарантия, что данные не поменяют. Например, координаты, RGB-цвет.
• Хэшируемость — кортеж можно использовать как ключ словаря, список — нет.
• Производительность — кортеж чуть быстрее и занимает меньше памяти.
• Возврат нескольких значений — функция может вернуть кортеж, а вызывающий его «распакует».

Распаковка

Python умеет красиво разбирать последовательности на переменные:

# Полная распаковка
name, age = ("Анна", 28)

# Сбор «лишнего» в список через *
first, *rest = [1, 2, 3, 4]
print(first)   # 1
print(rest)    # [2, 3, 4]

first, *middle, last = [1, 2, 3, 4, 5]
print(middle)  # [2, 3, 4]

Распаковка часто используется при обмене значений без временной переменной:

a, b = 1, 2
a, b = b, a       # теперь a=2, b=1

Кейс из реального проекта: корзина покупок

Корзина интернет-магазина — типичный пример работы со списком. Каждый элемент — кортеж из названия и цены (кортеж, потому что цена товара в корзине не меняется во время перебора):

cart = [
    ("Ноутбук", 89990),
    ("Мышь", 1200),
    ("Коврик", 500),
]

# Вывод чека
print("=== Корзина ===")
for title, price in cart:
    print(f"  {title:<15} {price:>6} руб.")

total = sum(price for _, price in cart)
print(f"{'Итого':<17} {total:>6} руб.")

Сумма здесь посчитана генератором внутри sum() — это более памято-эффективный аналог comprehension, не создающий промежуточный список.

Типичные ошибки

1. Индекс за пределами

fruits = ["яблоко", "банан"]
# print(fruits[5])   # IndexError: list index out of range

Перед обращением проверяйте длину или используйте безопасный доступ через срез: fruits[5:6] вернёт [], а не ошибку.

2. Присваивание по ссылке, а не копии

a = [1, 2, 3]
b = a          # b и a — один и тот же список!
b.append(4)
print(a)       # [1, 2, 3, 4] — изменился и a

# Чтобы не зависеть — копируем
b = a.copy()   # или a[:]

3. Слишком сложное comprehension

# Так лучше НЕ делать — нечитаемо
result = [f(x) for x in xs if g(x) for f in fs if h(f)]

# Разбейте на обычный цикл с промежуточными переменными

Практика

1. Создайте список чисел от 1 до 10. Выведите первый, последний и средний элементы.
2. Дан список цен. Найдите минимальную, максимальную и среднюю цену.
3. Через comprehension создайте список квадратов чётных чисел от 1 до 20.
4. Напишите функцию, которая принимает список слов и возвращает только слова длиннее 5 символов.
5. Распакуйте кортеж ("Анна", 28, "Москва") в три переменные и выведите их.

Итог

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