Глава 8. Циклы `for` и `while`: автоматизация рутины

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

8.1 Цикл `for`: обход списков и последовательностей

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

// PYTHON_EXECUTOR (Pyodide Wasm)

group_scores = [87, 45, 92, 63, 78]

# for <переменная цикла> in <последовательность>:
for score in group_scores:
  status = 'зачёт' if score >= 60 else 'незачёт'   # условие в одну строку из главы 7
  print(f'Балл: {score} — {status}')

// Output:

Балл: 87 — зачёт
Балл: 45 — незачёт
Балл: 92 — зачёт
Балл: 63 — зачёт
Балл: 78 — зачёт

Переменная score — не отдельная сущность, а временное хранилище текущего элемента. На первом проходе в ней лежит 87, на втором 45, и так до конца списка. Имя выбирается по смыслу данных: for score in group_scores, for student in students, for row in csv_rows — так цикл читается как фраза на русском.

Обходить можно любую последовательность, не только список:

// PYTHON_EXECUTOR (Pyodide Wasm)

student_class = '11А'

for char in student_class:      # строка — тоже последовательность, элемент = символ
  print(char)                 # 1, 1, А — каждый символ на своей строке

// Output:

⚠️ Двоеточие в конце строки for ...: и отступ в 4 пробела обязательны. Без отступа Python не понимает, где начинается тело цикла, и падает с IndentationError: expected an indented block.

⚠️ Подводный камень

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

// PYTHON_EXECUTOR (Pyodide Wasm)

module_scores = [87, -1, -1, 45, 92]     # -1 = урок пропущен

for score in module_scores:
  if score == -1:
      module_scores.remove(score)      # правим список прямо во время обхода

print(module_scores)

// Output:

[87, -1, 45, 92]

Ошибка	Что значит для Python	Человеческий перевод
— (тихая ошибка)	«Индекс сместился, беру следующий по счёту»	Удалили первый `-1` — список сжался, и второй `-1` встал на позицию, которую цикл уже прошёл. Итерируйтесь по списку только для чтения, а результат складывайте в новый список.

Правильный паттерн

// PYTHON_EXECUTOR (Pyodide Wasm)

module_scores = [87, -1, -1, 45, 92]
clean_scores = []                        # новый список для чистых данных

for score in module_scores:
  if score != -1:                      # читаем исходник, не трогая его
      clean_scores.append(score)

print(f'Из выгрузки: {module_scores}')   # [87, -1, -1, 45, 92] — исходник цел
print(f'К расчёту: {clean_scores}')      # [87, 45, 92]

// Output:

Пояснение логики: исходная выгрузка остаётся неизменной — если фильтр окажется неверным, всегда видно, что именно пришло из системы. Второй допустимый вариант — итерироваться по копии for score in module_scores[:], а удалять из оригинала. Но «собрать новый список» надёжнее и читается лучше: сразу понятно, что попадёт в расчёт.

8.2 Накопители: паттерны «Счётчик» и «Сумматор»

Зачем это нужно. Почти любая метрика — это накопление: сумма баллов для среднего, количество сдавших для конверсии, максимум для «лучшего результата группы». Цикл проходит по данным, а переменная-накопитель хранит промежуточный итог между проходами.

// PYTHON_EXECUTOR (Pyodide Wasm)

group_scores = [87, 45, 92, 63, 78]
pass_threshold = 60

# Инициализация СТРОГО до цикла
total_score = 0          # сумматор: копит сумму
passed_count = 0         # счётчик: копит количество
best_score = 0           # максимум

for score in group_scores:
  total_score += score                  # то же, что total_score = total_score + score
  if score >= pass_threshold:
      passed_count += 1                 # шаг счётчика — всегда на 1
  if score > best_score:
      best_score = score                # максимум не суммируется, а перезаписывается

average_score = total_score / len(group_scores)

print(f'Сумма баллов: {total_score}')
print(f'Сдали: {passed_count} из {len(group_scores)}')
print(f'Средний балл: {average_score:.1f} | Лучший: {best_score}')

// Output:

Сумма баллов: 365
Сдали: 4 из 5
Средний балл: 73.0 | Лучший: 92

Три накопителя — три роли:

Паттерн	Инициализация	Шаг в цикле
Сумматор	`total_score = 0`	`total_score += score`
Счётчик	`passed_count = 0`	`passed_count += 1`
Максимум	`best_score = 0`	`if score > best_score: best_score = score`

⚠️ С минимумом нулевая инициализация ломается: worst_score = 0 никогда не перезапишется, потому что балл не бывает меньше нуля. Стартовать нужно от заведомо большого значения — worst_score = 100 — или от первого элемента списка worst_score = group_scores[0].

⚠️ Подводный камень

Ловушка первая — накопитель объявлен внутри цикла. На каждом проходе он сбрасывается в ноль, поэтому в конце в нём остаётся вклад только последнего элемента.

// PYTHON_EXECUTOR (Pyodide Wasm)

group_scores = [87, 45, 92, 63, 78]

for score in group_scores:
  total_score = 0          # сброс на КАЖДОМ проходе
  total_score += score

print(f'Сумма баллов: {total_score}')    # 78 — это последний балл, а не сумма

// Output:

Ловушка вторая — накопитель не объявлен вовсе. Здесь Python молчать не станет:

// PYTHON_EXECUTOR (Pyodide Wasm)

group_scores = [87, 45, 92]

for score in group_scores:
  total_score += score     # к чему прибавлять? переменной ещё нет

// Output:

Traceback (most recent call last):
  File "report.py", line 4, in <module>
    total_score += score
NameError: name 'total_score' is not defined

Ошибка	Что значит для Python	Человеческий перевод
`NameError`	«Имя `total_score` в этой области не определено»	`+=` читает старое значение переменной перед тем, как записать новое. Читать нечего — накопитель не создан. Поставьте `total_score = 0` до `for`.
— (тихая ошибка)	«Присваиваю ноль на каждой итерации»	Строка `total_score = 0` попала внутрь тела цикла. Итог обнуляется перед каждым прибавлением, в отчёт уходит значение последней строки выгрузки.

Мнемоника: инициализация — до цикла, изменение — внутри цикла. Если строка начинается с имя = 0, ей место над for.

Правильный паттерн

// PYTHON_EXECUTOR (Pyodide Wasm)

group_scores = []            # выгрузка пришла пустой — группа ещё не сдавала

total_score = 0
passed_count = 0

for score in group_scores:   # цикл по пустому списку просто не выполнится ни разу
  total_score += score
  if score >= 60:
      passed_count += 1

# Защита от деления на ноль: считаем среднее только если есть данные
if len(group_scores) > 0:
  average_score = total_score / len(group_scores)
  print(f'Средний балл: {average_score:.1f}')
else:
  print('Нет данных для расчёта среднего')

// Output:

Пояснение логики: накопители объявлены до цикла, поэтому после пустой выгрузки они честно равны нулю, а не рушат программу. А вот total_score / len(group_scores) на пустом списке даст ZeroDivisionError — среднее по нулю строк математически не существует. Проверка len() > 0 перед делением обязательна везде, где данные приходят извне.

8.3 Функция `range()` и итерирование по индексам

Зачем это нужно. Иногда обходить нечего — нужно выполнить действие ровно N раз: сгенерировать 5 пустых колонок в шаблоне отчёта, распечатать шкалу баллов с шагом 10. А иногда нужен не сам элемент, а его номер: чтобы пронумеровать строки ведомости или сопоставить два параллельных списка.

// PYTHON_EXECUTOR (Pyodide Wasm)

# range(stop) — от 0 до stop, stop НЕ включается
for attempt in range(3):
  print(f'Пустая колонка №{attempt}')       # 0, 1, 2

# range(start, stop) — с указанной точки
for score in range(60, 63):
  print(score)                              # 60, 61, 62

# range(start, stop, step) — с шагом
for grade_border in range(0, 101, 10):
  print(grade_border, end=' ')              # 0 10 20 ... 100

// Output:

Связка range(len(...)) даёт доступ по индексу — это единственный способ идти по двум параллельным спискам одновременно:

// PYTHON_EXECUTOR (Pyodide Wasm)

students = ['Иванов', 'Петрова', 'Сидоров']
scores = [87, 45, 92]

for i in range(len(students)):                # i пробежит 0, 1, 2
  print(f'{i + 1}. {students[i]} — {scores[i]} б.')

// Output:

1. Иванов — 87 б.
2. Петрова — 45 б.
3. Сидоров — 92 б.

⚠️ Подводный камень

Правая граница в range() не включается. То же правило, что и у срезов из главы Строки и f-строки: range(1, 5) выдаёт 1, 2, 3, 4 — четыре значения, а не пять. Ошибка «на единицу» (off-by-one) — самая частая в отчётах: последний ученик или последняя попытка теряются.

// PYTHON_EXECUTOR (Pyodide Wasm)

attempts_count = 5

for attempt in range(1, attempts_count):
  print(f'Попытка {attempt} из {attempts_count}')

// Output:

Попытка 1 из 5
Попытка 2 из 5
Попытка 3 из 5
Попытка 4 из 5

Пятой попытки в отчёте нет. Ошибка тихая — скрипт отработал «успешно».

Вторая ловушка того же семейства — range(len()) по разным спискам. В выгрузке балл выгрузился не у всех, списки разъехались по длине, и здесь Python уже падает:

// PYTHON_EXECUTOR (Pyodide Wasm)

students = ['Иванов', 'Петрова', 'Сидоров']
scores = [87, 45]                    # у Сидорова балл не выгрузился

for i in range(len(students)):       # i дойдёт до 2
  print(f'{students[i]} — {scores[i]}')

// Output:

Иванов — 87
Петрова — 45
Traceback (most recent call last):
  File "report.py", line 5, in <module>
    print(f'{students[i]} — {scores[i]}')
IndexError: list index out of range

Ошибка	Что значит для Python	Человеческий перевод
— (тихая ошибка)	«`stop` — граница, за которую я не захожу»	`range(1, 5)` — это 1, 2, 3, 4. Для нумерации от единицы до N пишите `range(1, count + 1)`.
`IndexError`	«Индекс `2` за пределами списка длиной 2»	Длину взяли у одного списка, а индексируете другой — короче. Считайте длину по короткому списку либо проверяйте `len(students) == len(scores)` до цикла.

Правильный паттерн

// PYTHON_EXECUTOR (Pyodide Wasm)

students = ['Иванов', 'Петрова', 'Сидоров']
scores = [87, 45, 92]
attempts_count = 5

# 1. Нумерация «человеческая», от 1 до N включительно
for attempt in range(1, attempts_count + 1):
  print(f'Попытка {attempt} из {attempts_count}', end='; ')
print()

# 2. Два списка: проверяем согласованность до цикла
if len(students) == len(scores):
  for i in range(len(students)):
      print(f'{i + 1}. {students[i]} — {scores[i]} б.')
else:
  print(f'⚠️ Выгрузка битая: {len(students)} ФИО против {len(scores)} баллов')

// Output:

Пояснение логики: + 1 в правой границе — стандартная поправка на невключение, её проще запомнить как обязательный элемент шаблона «пронумеровать N штук». Проверка равенства длин ставится до цикла: расхождение в выгрузке — это событие для отчёта, а не повод уронить скрипт на середине.

Бонус: когда нужны и номер, и элемент одновременно, есть более короткая запись — enumerate():

// PYTHON_EXECUTOR (Pyodide Wasm)

for i, student in enumerate(students, start=1):
  print(f'{i}. {student}')          # 1. Иванов / 2. Петрова / 3. Сидоров

// Output:

range(len(...)) остаётся незаменимым там, где по индексу нужно достать элемент другого списка.

8.4 Прерывание и пропуск: `break` и `continue`

Зачем это нужно. continue — «этот элемент мне не подходит, дальше»: пропустить пустые строки, не явившихся учеников, пропущенные уроки. break — экстренный останов: нашли в выгрузке признак фальсификации, дальше считать бессмысленно, итог всё равно недостоверен.

// PYTHON_EXECUTOR (Pyodide Wasm)

module_scores = [78, -1, 92, 105, 64]      # -1 = пропуск, >100 = битые данные
max_score = 100

total_score = 0

for score in module_scores:
  if score == -1:
      print('Урок пропущен, не учитываем')
      continue                            # прыжок к следующему элементу
  if score > max_score:
      print(f'⚠️ Балл {score} выше максимума — расчёт остановлен')
      break                               # полный выход из цикла
  total_score += score
  print(f'Учтён балл: {score}')

print(f'Итого набрано: {total_score}')

// Output:

Учтён балл: 78
Урок пропущен, не учитываем
Учтён балл: 92
⚠️ Балл 105 выше максимума — расчёт остановлен
Итого набрано: 170

Разница в одном: continue бросает текущий проход и берёт следующий элемент, break бросает весь цикл целиком. Балл 64 после break не обработан — и это ровно то поведение, которое требовалось.

⚠️ Подводный камень

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

// PYTHON_EXECUTOR (Pyodide Wasm)

groups = [[78, 92], [64, 105], [88, 90]]

for group in groups:
  for score in group:
      if score > 100:
          print('Найден битый балл')
          break                     # выходит ТОЛЬКО из внутреннего цикла
  print(f'Группа {group} обработана')

// Output:

Группа [78, 92] обработана
Найден битый балл
Группа [64, 105] обработана
Группа [88, 90] обработана

Группа с баллом 105 помечена как обработанная, и скрипт продолжил считать остальные — хотя решение было «останов при любой фальсификации».

Ошибка	Что значит для Python	Человеческий перевод
— (тихая ошибка)	«`break` прерывает цикл, в котором он написан»	Ждали выхода из обоих циклов, получили выход из внутреннего. Заведите флаг (`has_error = True`), а на внешнем уровне проверьте его и сделайте второй `break`.

Вторая ловушка — не техническая, а читательская: если break и continue рассыпаны по всему телу цикла вперемешку с расчётами, логику «что и когда учитывается» невозможно восстановить глазами. Это та самая «спагетти-логика».

Правильный паттерн

// PYTHON_EXECUTOR (Pyodide Wasm)

groups = [[78, 92], [64, 105], [88, 90]]
max_score = 100

has_error = False
total_score = 0

for group in groups:
  for score in group:
      if score > max_score:
          has_error = True
          break                     # выход из внутреннего
  if has_error:
      break                         # выход из внешнего
  for score in group:
      total_score += score
  print(f'Группа {group} обработана')

if has_error:
  print('⚠️ Расчёт прерван: обнаружены недостоверные данные')
else:
  print(f'Итого по всем группам: {total_score}')

// Output:

Группа [78, 92] обработана
⚠️ Расчёт прерван: обнаружены недостоверные данные

Пояснение логики: флаг has_error — это память о событии, которая живёт дольше одного цикла. Она же используется в конце для выбора текста отчёта: сам факт break после выхода из цикла уже не виден, а флаг виден.

И правило чтения: все continue-фильтры ставятся в самом начале тела цикла, до расчётов. Тогда цикл читается в два блока — «сначала выбрасываем мусор, потом считаем по чистым данным»:

// PYTHON_EXECUTOR (Pyodide Wasm)

for score in module_scores:
  if score == -1:          # блок фильтров
      continue
  if score is None:
      continue

  total_score += score     # блок расчётов — сюда доходят только валидные данные

// Output:

8.5 Цикл `while`: обработка условий и интерактивный ввод

Зачем это нужно. for знает заранее, сколько будет проходов — столько, сколько элементов. while не знает: он повторяет блок, пока условие истинно. Классика для аналитика — запрашивать балл, пока оператор не введёт корректное значение от 0 до 100.

// PYTHON_EXECUTOR (Pyodide Wasm)

is_valid = False                 # флаг состояния: данные ещё не приняты

while not is_valid:              # «пока не валидно — повторяй»
  score = int(input('Балл от 0 до 100: '))
  if 0 <= score <= 100:
      is_valid = True          # условие цикла изменилось — выход на следующей проверке
  else:
      print('⚠️ Балл вне диапазона, повторите ввод')

print(f'Принят балл: {score}')

// Output:

Балл от 0 до 100: 105
⚠️ Балл вне диапазона, повторите ввод
Балл от 0 до 100: 87
Принят балл: 87

Второй рабочий шаблон — счётчик попыток, чтобы оператор не застрял навсегда:

// PYTHON_EXECUTOR (Pyodide Wasm)

attempts_left = 3
score = None

while attempts_left > 0:
  raw_score = input('Балл от 0 до 100: ')
  attempts_left -= 1                       # шаг счётчика — обязательно!
  if raw_score.isdigit() and 0 <= int(raw_score) <= 100:
      score = int(raw_score)
      break                                # получили корректное — уходим досрочно
  print(f'⚠️ Некорректно. Осталось попыток: {attempts_left}')

if score is None:
  print('Ввод не удался, ставим пропуск (-1)')

// Output:

⚠️ Подводный камень

Бесконечный цикл (infinite loop). Если переменная из условия внутри тела не меняется, условие остаётся истинным навсегда. Программа не падает — она «зависает» и печатает одно и то же, пока её не убьют вручную через Ctrl + C.

// PYTHON_EXECUTOR (Pyodide Wasm)

attempts_left = 3

while attempts_left > 0:
  print('Проверяем следующую строку выгрузки...')
  # attempts_left не уменьшается — условие 3 > 0 истинно вечно

// Output:

Проверяем следующую строку выгрузки...
Проверяем следующую строку выгрузки...
Проверяем следующую строку выгрузки...
^C
Traceback (most recent call last):
  File "report.py", line 4, in <module>
    print('Проверяем следующую строку выгрузки...')
KeyboardInterrupt

Ловушка вторая, коварнее: continue в while перепрыгивает через шаг счётчика, если тот стоит в конце тела.

// PYTHON_EXECUTOR (Pyodide Wasm)

csv_rows = ['Иванов;87', '', 'Петрова;45']
row_index = 0

while row_index < len(csv_rows):
  if csv_rows[row_index] == '':
      continue                     # прыжок к проверке условия — индекс не вырос!
  print(csv_rows[row_index])
  row_index += 1                   # до этой строки на пустой строке не доходим

// Output:

Скрипт напечатает Иванов;87 и навсегда зависнет на пустой строке с индексом 1.

Ошибка	Что значит для Python	Человеческий перевод
— (тихая ошибка)	«Условие всё ещё `True`, повторяю тело»	Забыли изменить переменную условия. В теле `while` обязательно должна быть строка, которая приближает выход: `attempts_left -= 1`, `row_index += 1`, `is_valid = True` или `break`.
`KeyboardInterrupt`	«Выполнение прервано пользователем (`Ctrl + C`)»	Это не ошибка кода, а способ убить зависший цикл. Увидели её после своего `while` — ищите непеременяющееся условие.

Правильный паттерн

// PYTHON_EXECUTOR (Pyodide Wasm)

csv_rows = ['Иванов;87', '', 'Петрова;45']
row_index = 0

while row_index < len(csv_rows):
  current_row = csv_rows[row_index]
  row_index += 1                   # шаг счётчика — В САМОМ НАЧАЛЕ тела

  if current_row == '':            # теперь continue безопасен
      continue

  student_name, score = current_row.split(';')
  print(f'{student_name} — {score} б.')

// Output:

Иванов — 87 б.
Петрова — 45 б.

Пояснение логики: счётчик увеличивается до всех continue и break, поэтому ни один путь исполнения не может «застрять» на текущей строке. Текущий элемент заранее скопирован в current_row — читается лучше, чем csv_rows[row_index] в пяти местах.

И главный вывод раздела: если количество проходов известно заранее — берите for. Пример выше написан на while только для демонстрации; в реальном коде обход списка строк — это for current_row in csv_rows, где зациклиться невозможно по устройству. while оставляют для интерактивного ввода, ожидания события и повторных попыток.

8.6 Мини-словарик ошибок восьмой главы

Ошибка	Что значит для Python	Человеческий перевод
`NameError`	«Имя `total_score` не определено»	Использовали накопитель, не объявив его до цикла. `+=` требует, чтобы переменная уже существовала.
`UnboundLocalError`	«Локальная переменная использована до присваивания»	Тот же случай, но внутри функции: накопитель объявлен снаружи, а меняется внутри. Разбор — в главе Функции.
`IndexError`	«Индекс за пределами списка»	`range(len(students))`, а индексируется более короткий `scores`. Проверяйте длины до цикла.
`ZeroDivisionError`	«Деление на ноль»	Считали среднее по пустой выгрузке: `total_score / len(group_scores)`, где длина `0`.
`TypeError`	«Объект `int` не является итерируемым»	Написали `for score in 87` — по одному числу пройти нельзя, нужна последовательность.
`ValueError`	«Не могу превратить `'не явился'` в число»	`int(input())` внутри `while`: оператор ввёл текст вместо балла.
`IndentationError`	«Ожидался блок с отступом»	Забыли отступ в теле цикла после `for ...:`.
`KeyboardInterrupt`	«Прервано пользователем»	Убили `Ctrl + C` зависший `while` — условие не менялось.
— (тихая ошибка)	«Присваиваю ноль на каждой итерации»	`total_score = 0` внутри тела цикла: в итоге остался вклад только последнего элемента.
— (тихая ошибка)	«`stop` не включается»	`range(1, 5)` вместо `range(1, 6)` — последний ученик или последняя попытка потерялись.
— (тихая ошибка)	«Индекс сместился после удаления»	Удаляли элементы из списка во время итерации по нему — часть мусора осталась.
— (тихая ошибка)	«`continue` — прыжок к проверке условия»	В `while` счётчик стоял после `continue` и не выполнялся. Бесконечный цикл.

Самый обидный случай целиком — TypeError: 'int' object is not iterable. Он приходит, когда в переменной ждали список баллов, а пришёл один балл: так бывает, если выгрузка содержит единственную строку и система вернула не список, а скалярное значение.

// PYTHON_EXECUTOR (Pyodide Wasm)

group_scores = 87              # ожидали список, получили одно число

for score in group_scores:
  print(score)

// Output:

Traceback (most recent call last):
  File "report.py", line 3, in <module>
    for score in group_scores:
TypeError: 'int' object is not iterable

«Итерируемый» — значит «состоящий из элементов, которые можно перебрать». Список, строка, кортеж — итерируемы; int и float — нет. Лечится нормализацией данных на входе:

// PYTHON_EXECUTOR (Pyodide Wasm)

group_scores = 87

if isinstance(group_scores, list):     # это список?
  scores_to_process = group_scores
else:
  scores_to_process = [group_scores] # одно число оборачиваем в список из одного элемента

for score in scores_to_process:
  print(score)                       # 87

// Output:

Мини-кейс: расчёт конверсии прохождения курса

Задача: по списку баллов за модули посчитать сумму и средний балл ученика, пропустив пропущенные уроки (-1), посчитать конверсию прохождения (доля модулей, сданных на 60+) и прервать расчёт, если обнаружен факт фальсификации — балл выше 100.

// PYTHON_EXECUTOR (Pyodide Wasm)

# 1. Сбор данных
student_name = 'Иванов Иван'
module_scores = [78, -1, 92, 45, -1, 88, 95]
pass_threshold = 60
max_score = 100

# 2. Расчёты
total_score = 0          # сумматор баллов
counted_modules = 0      # счётчик учтённых модулей
skipped_modules = 0      # счётчик пропусков
passed_modules = 0       # счётчик сдач на 60+
best_score = 0           # максимум
is_data_valid = True     # флаг достоверности выгрузки

for score in module_scores:
  # 2.1 Блок фильтров — отсекаем мусор в начале цикла
  if score == -1:
      skipped_modules += 1
      continue

  # 2.2 Проверка на фальсификацию — дальше считать бессмысленно
  if score > max_score:
      is_data_valid = False
      break

  # 2.3 Блок расчётов — сюда доходят только валидные баллы
  total_score += score
  counted_modules += 1

  if score >= pass_threshold:
      passed_modules += 1

  if score > best_score:
      best_score = score

# 3. Вывод итогового отчёта
print(f'--- КОНВЕРСИЯ КУРСА: {student_name} ---')

if not is_data_valid:
  print('⚠️ Расчёт прерван: найден балл выше максимума. Выгрузка требует проверки.')
elif counted_modules == 0:
  print('Ни одного сданного модуля — конверсию считать не из чего.')
else:
  average_score = total_score / counted_modules
  conversion = passed_modules / counted_modules * 100

  print(f'Учтено модулей: {counted_modules} | Пропущено: {skipped_modules}')
  print(f'Сумма баллов: {total_score} | Средний: {average_score:.1f} | Лучший: {best_score}')
  print(f'Сдано на {pass_threshold}+: {passed_modules} из {counted_modules}')
  print(f'Конверсия прохождения: {conversion:.0f}%')

// Output:

Прогон на данных из кейса:

--- КОНВЕРСИЯ КУРСА: Иванов Иван ---
Учтено модулей: 5 | Пропущено: 2
Сумма баллов: 398 | Средний: 79.6 | Лучший: 95
Сдано на 60+: 4 из 5
Конверсия прохождения: 80%

Тот же скрипт на выгрузке с фальсификацией — module_scores = [78, -1, 92, 120, 88]:

--- КОНВЕРСИЯ КУРСА: Иванов Иван ---
⚠️ Расчёт прерван: найден балл выше максимума. Выгрузка требует проверки.

Что получилось: один проход по списку дал сразу шесть метрик — сумму, количество учтённых, количество пропусков, количество сдач, максимум и флаг достоверности. Все накопители объявлены до цикла, поэтому на пустой выгрузке скрипт не упадёт, а честно сообщит, что считать нечего. Фильтр пропусков стоит первым — continue отсекает -1 до всех расчётов, и средний балл считается по counted_modules, а не по len(module_scores): пропущенные уроки не занижают результат. Проверка на балл выше максимума ставит флаг и делает break, а решение «что печатать» принимается уже после цикла — по флагу, а не по факту прерывания.

⚠️ Одна дыра осталась: если в выгрузке вместо числа окажется строка 'не явился', сравнение score > max_score упадёт с TypeError: '>' not supported between instances of 'str' and 'int'. Защита от таких данных — try / except из главы Ошибки и исключения. А среднее и максимум по чистому списку можно считать и без ручных накопителей — готовыми функциями из главы Стандартная библиотека.

Чек-лист главы

Дальше: Функции

Глава 8. Циклы `for` и `while`: автоматизация рутины

8.1 Цикл for: обход списков и последовательностей

⚠️ Подводный камень

Правильный паттерн

8.2 Накопители: паттерны «Счётчик» и «Сумматор»

⚠️ Подводный камень

Правильный паттерн

8.3 Функция range() и итерирование по индексам

⚠️ Подводный камень

Правильный паттерн

8.4 Прерывание и пропуск: break и continue

⚠️ Подводный камень

Правильный паттерн

8.5 Цикл while: обработка условий и интерактивный ввод

⚠️ Подводный камень

Правильный паттерн

8.6 Мини-словарик ошибок восьмой главы

Мини-кейс: расчёт конверсии прохождения курса

Чек-лист главы

8.1 Цикл `for`: обход списков и последовательностей

8.3 Функция `range()` и итерирование по индексам

8.4 Прерывание и пропуск: `break` и `continue`

8.5 Цикл `while`: обработка условий и интерактивный ввод