Списки в Питоне

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

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

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

L = [x₀, x₁, x₂, ..., x_{n−1}]

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

Формальная модель списка в Python

1. Список как упорядоченная изменяемая последовательность
   

   В Python список – это объект типа list, представляющий конечную упорядоченную последовательность элементов:

   L = [a0, a1, a2, ..., a(n-1)]

   где:

   • порядок элементов фиксирован; 

   • каждый элемент имеет индекс; 

   • элементы могут быть изменены, удалены или добавлены; 

   • длина списка может меняться в процессе выполнения программы. 

   С математической точки зрения список можно интерпретировать как отображение:

   L: {0,1,2,...,n−1} → V

   где V – множество допустимых объектов Python.

2. Гомогенность и гетерогенность
   

   В отличие от массивов в ряде компилируемых языков, список Python допускает хранение элементов разных типов:

   L = [1, "abc", True, 3.14]

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

3. Изменяемость
   

   Список является изменяемым объектом (mutable object). Это означает, что после создания его содержимое можно менять:

   L = [1, 2, 3]
   L[1] = 10
   # теперь L == [1, 10, 3]

   Именно изменяемость отличает список, например, от кортежа (tuple), который по структуре похож на последовательность, но не допускает изменения элементов.

4. Длина списка
   

   Если в списке L содержится n элементов, то его длина вычисляется функцией:

   len(L)

   Формально:

   |L| = n

   Индексы допустимых элементов принадлежат множеству:

   {0, 1, 2, ..., n−1}

Создание списков и способы задания

1. Явное перечисление элементов
   

   Наиболее простой способ задания списка:

   L = [2, 4, 6, 8]

   Это соответствует конечной числовой последовательности фиксированной длины.

2. Конструктор list()
   

   Список можно построить через функцию-конструктор:

   L = list("abc")
   # ['a', 'b', 'c']

   или:

   L = list(range(5))
   # [0, 1, 2, 3, 4]

3. Повторение элементов
   

   Можно создать список повторением:

   L = [0] * 5
   # [0, 0, 0, 0, 0]

   Формально это соответствует последовательности длины n, где каждый элемент равен константе c.

   Однако при работе с вложенными списками такой способ требует осторожности:

   M = [[0] * 3] * 4

   создаёт не четыре независимые строки, а четыре ссылки на один и тот же вложенный список.

4. Генераторы списков
   

   Один из важнейших способов задания:

   L = [x * x for x in range(5)]
   # [0, 1, 4, 9, 16]

   Генератор списка задаёт список через правило:

   L[i] = f(i)

   или более общий процесс фильтрации и преобразования.

Индексация и доступ к элементам

1. Прямая индексация
   

   Элемент списка извлекается по индексу:

   L[i]

   где i – целое число.
   Если:

   0 ≤ i < len(L),

   доступ корректен. Иначе возникает ошибка:

   IndexError

2. Отрицательные индексы
   

   Python допускает отрицательную индексацию:

   L[-1]  # последний элемент
   L[-2]  # предпоследний элемент

   Формально:

   L[-k] = L[len(L) − k]

   если 1 ≤ k ≤ len(L).

3. Изменение элементов
   

   Так как список изменяемый, элемент можно заменить:

   L[i] = value

   Это операция присваивания в фиксированную позицию.

4. Инвариант корректного доступа
   

   Для любой операции индексирования должен соблюдаться инвариант:

   индекс принадлежит допустимому диапазону списка.

   Именно нарушение этого условия является одной из самых частых ошибок начинающих.

Срезы списков

1. Общее понятие среза
   

   Срез позволяет получить подпоследовательность:

   L[start:stop:step]

   где:

   • start – начальный индекс; 

   • stop – индекс, до которого идёт выборка, не включая его; 

   • step – шаг. 

2. Стандартный срез
   

   Пример:

   L = [0, 1, 2, 3, 4, 5]
   L[1:4]   # [1, 2, 3]

   Формально:

   результат содержит элементы с индексами i, для которых
   start ≤ i < stop

3. Срез с шагом
   

   Пример:

   L[0:6:2]   # [0, 2, 4]

   Это выбор элементов через один.

4. Обращение списка через срез
   

   Очень важный приём:

   L[::-1]

   Это создаёт новый список в обратном порядке.

5. Изменение через срез
   

   Срез может стоять слева:

   L[1:3] = [10, 20]

   В этом случае изменяется целый фрагмент списка.

Основные методы списка

1. Добавление элементов
   

   append(x) – добавляет элемент в конец:

   L.append(5)

   insert(i, x) – вставляет элемент в позицию i:

   L.insert(2, 100)

   extend(iterable) – добавляет сразу несколько элементов:

   L.extend([7, 8, 9])

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

   pop() – удаляет и возвращает последний элемент:

   x = L.pop()

   pop(i) – удаляет элемент по индексу:

   x = L.pop(2)

   remove(x) – удаляет первое вхождение значения x:

   L.remove(10)

   clear() – очищает список:

   L.clear()

3. Поиск и подсчёт
   

   index(x) – возвращает индекс первого вхождения:

   i = L.index(7)

   count(x) – возвращает число вхождений:

   k = L.count(7)

4. Сортировка и обращение
   

   sort() – сортирует список на месте:

   L.sort()

   reverse() – обращает список на месте:

   L.reverse()

   Если нужен новый отсортированный список, используют:

   sorted(L)

Семантика присваивания, копирования и ссылок

1. Присваивание не копирует список
   

   Если выполнить:

   A = [1, 2, 3]
   B = A

   то B не становится новым независимым списком. Обе переменные ссылаются на один и тот же объект. Поэтому:

   B[0] = 100

   изменит и A, и B.

2. Поверхностное копирование
   

   Чтобы создать новый список с теми же элементами:

   B = A[:]
   # или
   B = A.copy()
   # или
   B = list(A)

   Это создаёт новый список верхнего уровня.

3. Вложенные списки и глубокое копирование
   

   Если список содержит вложенные списки:

   A = [[1, 2], [3, 4]]
   B = A.copy()

   то внутренние списки остаются общими. Для полного копирования используется:

   import copy
   B = copy.deepcopy(A)

4. Почему это важно для ЕГЭ
   

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

Алгоритмические шаблоны обработки списков

1. Обход списка
   

   Классический способ:

   for x in L:
       ...

   или индексный:

   for i in range(len(L)):
       ...

   Первый удобнее для чтения, второй – когда нужен индекс.

2. Поиск суммы
   

   s = 0
   for x in L:
       s += x

   или:

   s = sum(L)

3. Поиск максимума и минимума
   

   mx = max(L)
   mn = min(L)

   или через ручной алгоритм с инвариантом.

4. Фильтрация
   

   Создание нового списка по условию:

   positives = [x for x in L if x > 0]

5. Подсчёт количества элементов по условию
   

   k = 0
   for x in L:
       if x % 2 == 0:
           k += 1

6. Обработка соседних элементов
   

   Очень часто в задачах ЕГЭ требуется работа с парами соседних элементов:

   for i in range(len(L) - 1):
       if L[i] < L[i + 1]:
           ...

7. Работа с подсписками
   

   Поиск подпоследовательностей, сумм отрезков, серий одинаковых свойств требует аккуратной индексации и понимания срезов.

Вложенные списки и двумерные структуры

1. Список списков
   

   Матрица в Python обычно представляется так:

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

   Тогда:

   M[i][j]

   обозначает элемент строки i, столбца j.

2. Создание двумерного списка
   

   Корректный способ:

   M = [[0 for _ in range(m)] for _ in range(n)]

   Некорректный во многих случаях:

   M = [[0] * m] * n

   потому что строки оказываются связанными ссылками.

3. Обход двумерного списка
   

   for i in range(n):
       for j in range(m):
           ...

   или:

   for row in M:
       for x in row:
           ...

Инженерные правила и практические соглашения

1. Используйте однородные списки в учебных задачах.
   Это повышает предсказуемость вычислений. 

2. Не изменяйте список во время обхода без особой необходимости.
   Это может нарушить логику индексации. 

3. Различайте изменение на месте и создание нового списка.
   sort() меняет исходный список, sorted() создаёт новый. 

4. Понимайте разницу между значением и ссылкой.
   Присваивание списка не эквивалентно копированию. 

5. Для многомерных структур избегайте шаблона с повторением вложенных списков.
   Он создаёт зависимые строки. 

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

7. Используйте встроенные функции там, где это повышает ясность.
   Например, sum, min, max, sorted. 

Мини-шпаргалка по теме

1. Создание списка
   

   L = [1, 2, 3]
   L = list(range(5))
   L = [0] * 10

2. Доступ
   

   L[i]
   L[-1]
   L[a:b:c]

3. Методы
   

   append(x)
   insert(i, x)
   extend(iterable)
   pop()
   pop(i)
   remove(x)
   clear()
   index(x)
   count(x)
   sort()
   reverse()
   copy()

4. Полезные функции
   

   len(L)
   sum(L)
   min(L)
   max(L)
   sorted(L)

5. Копирование
   

   B = A[:]
   B = A.copy()
   import copy
   B = copy.deepcopy(A)

Типичные ошибки и их профилактика

Ошибка 1. Выход за границы списка

Например:

L[len(L)]

неверно, потому что последний индекс:

len(L) - 1

Профилактика: всегда помнить о диапазоне индексов.

Ошибка 2. Путаница между remove и pop

• remove(x) удаляет по значению; 
• pop(i) удаляет по индексу.

Профилактика: различать семантику методов. 

Ошибка 3. Непонимание присваивания

B = A

не копирует список.
Профилактика: использовать copy() или срез.

Ошибка 4. Неправильное создание матрицы

M = [[0] * m] * n

приводит к связанным строкам.
Профилактика: использовать генератор списков.

Ошибка 5. Изменение списка при обходе

Например:

for x in L:
    if x < 0:
        L.remove(x)

может пропускать элементы.
Профилактика: итерироваться по копии или строить новый список.

Связь с подготовкой к ЕГЭ по информатике

Списки в Python напрямую связаны с большинством практических заданий по программированию:

• обработка последовательностей чисел; 
• поиск максимума, минимума, суммы; 
• подсчёт количества элементов по условию; 
• сортировка и фильтрация; 
• анализ соседних элементов; 
• работа с таблицами и матрицами; 
• моделирование состояний и маршрутов. 

Кроме того, работа со списками формирует общие алгоритмические навыки:

• корректная индексация; 
• формулирование инвариантов; 
• аккуратное обращение с памятью и копированием; 
• понимание различий между изменяемыми и неизменяемыми структурами. 

Для ЕГЭ особенно важно не просто знать синтаксис, а понимать семантику действий над списком.

Пять упражнений 

Упражнение 1. Сумма положительных элементов
Условие. Дан список целых чисел. Найдите сумму положительных элементов.
Решение:

L = [3, -1, 5, -7, 2]
s = 0
for x in L:
    if x > 0:
        s += x
print(s)

Пошагово:

• 3 → сумма 3 
• -1 → пропускаем 
• 5 → сумма 8 
• -7 → пропускаем 
• 2 → сумма 10 

Ответ: 10.

Упражнение 2. Копирование списка
Условие. Что выведет программа?

A = [1, 2, 3]
B = A
B[0] = 10
print(A)

Решение.
B = A создаёт вторую ссылку на тот же список. После изменения B[0] меняется и A.

Ответ:

[10, 2, 3]

Упражнение 3. Срез списка
Условие. Дан список:

L = [0, 1, 2, 3, 4, 5]

Чему равен результат:

L[1:5:2]

Решение.
Берутся элементы с индексами 1 и 3:

• L[1] = 1 
• L[3] = 3 

Ответ:

[1, 3] 

Упражнение 4. Создание независимой матрицы
Условие. Почему следующий код работает неверно?

M = [[0] * 3] * 2
M[0][1] = 5
print(M)

Решение.
Обе строки матрицы ссылаются на один и тот же вложенный список. Поэтому изменение в одной строке отражается и в другой.

Результат:

[[0, 5, 0], [0, 5, 0]]

Корректный вариант:

M = [[0] * 3 for _ in range(2)] 

Упражнение 5. Подсчёт возрастающих пар соседей
Условие. Дан список:

L = [1, 3, 2, 5, 4, 6]

Сколько пар соседних элементов удовлетворяют условию:

L[i] < L[i+1]

Решение.
Проверяем пары:

• (1, 3) → да 
• (3, 2) → нет 
• (2, 5) → да 
• (5, 4) → нет 
• (4, 6) → да 

Всего:

3

Программа:

k = 0
for i in range(len(L) - 1):
    if L[i] < L[i + 1]:
        k += 1
print(k)

Ответ: 3.

Практические рекомендации

1. Для большинства задач на ЕГЭ сначала формулируйте, что хранит список. 

2. Если требуется только агрегат, не создавайте лишних промежуточных списков. 

3. Если нужен новый список по условию, удобнее использовать генератор списка. 

4. При работе с индексами всегда отдельно продумывайте начало и конец диапазона. 

5. При анализе кода на Python проверяйте: 
   

   • меняется ли список на месте; 

   • создаётся ли копия; 

   • что происходит при пустом списке.

Заключение

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

Для подготовки к ЕГЭ тема списков особенно значима, поскольку она лежит в основе значительной части задач на обработку данных. Уверенное владение списками в Python означает не только знание методов и синтаксиса, но и понимание формальной логики работы этой структуры. Именно это делает тему списков фундаментальной частью алгоритмической культуры школьника.