Глава 9. Функции: свой набор инструментов аналитика

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

9.1 `def`: своя функция расчёта среднего балла

Зачем это нужно. Средний балл в этой книге уже считался вручную десяток раз — через sum() / len() или через накопители из главы Циклы. Если логику расчёта нужно поправить (например, округление), придётся искать все места, где она скопирована. Функция решает это раз и навсегда: логика написана один раз, у неё есть имя, и вызывается она откуда угодно.

// PYTHON_EXECUTOR (Pyodide Wasm)

def calculate_average(scores):          # def <имя>(<параметры>):
  return sum(scores) / len(scores)    # тело — с отступом в 4 пробела

group_scores = [87, 45, 92, 63, 78]
print(calculate_average(group_scores))  # 73.0

// Output:

Строка def calculate_average(scores): только описывает функцию — тело не выполняется, пока функцию не вызовут. scores внутри def — не тот же список, что group_scores снаружи, а параметр: временное имя, в которое при вызове calculate_average(group_scores) подставляется конкретный список. Вызов — это имя(аргументы), круглые скобки обязательны.

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

Первая ловушка — вызов раньше определения. Python выполняет файл построчно сверху вниз: пока def не отработал, имени calculate_average не существует.

// PYTHON_EXECUTOR (Pyodide Wasm)

group_scores = [87, 45, 92]
print(calculate_average(group_scores))   # вызов ДО определения

def calculate_average(scores):
  return sum(scores) / len(scores)

// Output:

Traceback (most recent call last):
  File "report.py", line 2, in <module>
    print(calculate_average(group_scores))
NameError: name 'calculate_average' is not defined

Вторая ловушка — забытые круглые скобки при вызове.

// PYTHON_EXECUTOR (Pyodide Wasm)

def calculate_average(scores):
  return sum(scores) / len(scores)

group_scores = [87, 45, 92]
result = calculate_average          # забыли () — это не вызов
print(result)

// Output:

<function calculate_average at 0x7f8b2c0a1080>

Traceback не появится — Python не считает это ошибкой: без скобок имя функции ведёт себя как любое другое имя переменной и просто ссылается на объект-функцию, а не на результат её работы.

Ошибка	Что значит для Python	Человеческий перевод
`NameError`	«Имя `calculate_average` ещё не определено»	Вызов стоит выше `def` в файле. Все функции нужно определять до первого использования — обычно их собирают в начале скрипта.
— (тихая ошибка)	«Без `()` это ссылка на функцию, а не вызов»	`result = calculate_average` присвоил переменной сам объект-функцию. Дальнейшая арифметика с `result` упадёт с `TypeError`, а до этого момента ошибка никак не проявляется.

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

// PYTHON_EXECUTOR (Pyodide Wasm)

def calculate_average(scores):     # 1. Сначала — определение
  return sum(scores) / len(scores)

group_scores = [87, 45, 92]
average_score = calculate_average(group_scores)   # 2. Потом — вызов со скобками
print(f'Средний балл: {average_score:.1f}')

// Output:

Средний балл: 74.7

Пояснение логики: def собирают в начале файла (или в отдельном модуле — до главы Стандартная библиотека это будет просто верхняя часть скрипта), а вызовы — уже после, там, где нужен результат. Скобки () — это команда «выполни тело функции сейчас и отдай то, что она вернёт»; без них Python отдаёт саму функцию как объект.

9.2 Аргументы: позиционные, именованные, значения по умолчанию

Зачем это нужно. Функции редко работают с одним и тем же порогом всегда: экзамен может требовать 60 баллов для зачёта, а профильный — 75. Аргументы со значением по умолчанию позволяют не передавать порог каждый раз, но оставляют возможность переопределить его для особого случая.

// PYTHON_EXECUTOR (Pyodide Wasm)

def get_status(score, pass_threshold=60):    # pass_threshold=60 — значение по умолчанию
  return 'зачёт' if score >= pass_threshold else 'незачёт'

print(get_status(87))                             # позиционный, порог по умолчанию
print(get_status(87, 90))                         # позиционный порог — профильный экзамен
print(get_status(score=45, pass_threshold=40))    # именованные — порядок аргументов не важен

// Output:

зачёт
незачёт
зачёт

score — обязательный позиционный аргумент, без него будет TypeError. pass_threshold=60 — необязательный: если его не передать, используется 60; если передать вторым позиционным (get_status(87, 90)) или по имени (pass_threshold=90) — используется переданное значение. Именованные аргументы можно передавать в любом порядке — Python сопоставляет их по имени, а не по позиции.

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

Изменяемый объект в значении по умолчанию — та же ловушка, что подстерегала в setdefault() из главы Словари, только там она пряталась в аргументах метода словаря, а здесь — в аргументах собственной функции. Значение по умолчанию вычисляется один раз, в момент определения функции, а не при каждом вызове.

// PYTHON_EXECUTOR (Pyodide Wasm)

def add_score(score, scores=[]):     # список создаётся ОДИН раз — при чтении def
  scores.append(score)
  return scores

print(add_score(87))     # [87]
print(add_score(45))     # ждали [45], получили [87, 45]

// Output:

[87]
[87, 45]

Оба вызова без второго аргумента получают ссылку на один и тот же список — тот, что был создан один раз при определении функции. Второй вызов дописывает в список первого, а не начинает новый.

Ошибка	Что значит для Python	Человеческий перевод
— (тихая ошибка)	«Значение по умолчанию — один объект на все вызовы»	`scores=[]` — не «шаблон нового списка на каждый вызов», а конкретный список, созданный один раз. Между вызовами без явного аргумента он копит данные, как `empty_list`, переданный в `setdefault()` из главы 5.

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

// PYTHON_EXECUTOR (Pyodide Wasm)

def add_score(score, scores=None):     # безопасное значение по умолчанию — None
  if scores is None:                 # None — сигнал «аргумент не передали»
      scores = []                    # новый список создаётся при КАЖДОМ вызове
  scores.append(score)
  return scores

print(add_score(87))     # [87]
print(add_score(45))     # [45] — независимый список

// Output:

[87]
[45]

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

9.3 `return`: возврат значения против `print()` внутри функции

Зачем это нужно. print() показывает значение человеку на экране, а return передаёт значение обратно в код, который вызвал функцию, — чтобы использовать его дальше: сложить, сравнить, подставить в другую функцию. Если функция должна участвовать в дальнейших расчётах, print() внутри неё результат не заменяет.

// PYTHON_EXECUTOR (Pyodide Wasm)

def format_report_line(student_name, score, status):
  return f'{student_name}: {score} б. — {status}'

line = format_report_line('Иванов Иван', 87, 'зачёт')
print(line)

// Output:

Иванов Иван: 87 б. — зачёт

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

Функция без return (или с return без значения) молча отдаёт None — Python не считает это ошибкой на уровне самой функции, но всё ломается там, где None пытаются использовать как число.

// PYTHON_EXECUTOR (Pyodide Wasm)

def calculate_average_broken(scores):
  average = sum(scores) / len(scores)
  print(average)              # напечатали результат человеку, но не вернули

group_scores = [87, 45, 92]
average_score = calculate_average_broken(group_scores)   # result = None
bonus_score = average_score + 5      # хотим прибавить бонус к среднему

// Output:

74.66666666666667
Traceback (most recent call last):
  File "report.py", line 7, in <module>
    bonus_score = average_score + 5
TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'

Ошибка	Что значит для Python	Человеческий перевод
`TypeError`	«Нельзя сложить `NoneType` и `int`»	Функция напечатала результат через `print()`, но не отдала его через `return`. Любая функция без явного `return` возвращает `None` — именно это `None` и попало в `average_score`.

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

// PYTHON_EXECUTOR (Pyodide Wasm)

def calculate_average(scores):
  return sum(scores) / len(scores)     # возвращаем, а не печатаем

group_scores = [87, 45, 92]
average_score = calculate_average(group_scores)
bonus_score = average_score + 5
print(f'Средний балл с бонусом: {bonus_score:.1f}')

// Output:

Средний балл с бонусом: 79.7

Пояснение логики: правило простое — если результат функции нужен где-то ещё в коде, используйте return; если функция — последний шаг и её задача только показать что-то человеку, print() внутри уместен, но тогда результат этой функции никуда дальше не передают. Смешивать оба назначения в одной функции — источник именно этой ловушки.

9.4 Область видимости: локальные и глобальные имена

Зачем это нужно. Переменная, созданная внутри функции, — локальная: она существует только во время вызова и не видна снаружи. Это удобно — функции не мешают друг другу одинаковыми именами параметров. Но у этого правила есть обратная сторона, обещанная ещё в мини-словарике главы Циклы: изменить снаружи заданный накопитель изнутри функции не получится так же просто, как прочитать его.

// PYTHON_EXECUTOR (Pyodide Wasm)

pass_threshold = 60                  # глобальная переменная — задана вне всех функций

def get_status(score):
  return 'зачёт' if score >= pass_threshold else 'незачёт'   # чтение глобальной — работает

print(get_status(87))                # зачёт

// Output:

зачёт

Читать глобальную переменную изнутри функции можно свободно — pass_threshold внутри get_status берётся из внешней области, потому что нигде в теле функции ей ничего не присваивается.

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

Как только внутри функции переменной с тем же именем, что и снаружи, присваивают значение — даже через += — Python на этапе разбора всей функции считает это имя локальным на всё тело целиком, включая строки выше присваивания. Внешнее значение перестаёт быть видно.

// PYTHON_EXECUTOR (Pyodide Wasm)

total_score = 0                     # накопитель заведён снаружи, как в главе 8

def add_to_total(score):
  total_score += score            # хотим прибавить к внешнему накопителю
  return total_score

add_to_total(87)

// Output:

Traceback (most recent call last):
  File "report.py", line 6, in <module>
    add_to_total(87)
  File "report.py", line 4, in add_to_total
    total_score += score
UnboundLocalError: local variable 'total_score' referenced before assignment

Ошибка	Что значит для Python	Человеческий перевод
`UnboundLocalError`	«Локальная переменная использована до присваивания»	`total_score += score` внутри функции — это присваивание, значит Python считает `total_score` локальным именем на всю функцию. Но `+=` сначала пытается прочитать текущее значение, а такой локальной переменной ещё нет — отсюда ошибка. Внешний `total_score` из-за этого правила не виден вовсе, хотя обычное чтение (без присваивания) сработало бы.

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

// PYTHON_EXECUTOR (Pyodide Wasm)

# Вариант А — принять и вернуть значение явно (предпочтительный способ)
def add_to_total(current_total, score):
  return current_total + score

total_score = 0
total_score = add_to_total(total_score, 87)   # накопитель меняется снаружи, явно
total_score = add_to_total(total_score, 45)
print(total_score)      # 132

// Output:

// PYTHON_EXECUTOR (Pyodide Wasm)

# Вариант Б — ключевое слово global (рабочий, но более хрупкий способ)
total_score = 0

def add_to_total_global(score):
  global total_score        # явно предупреждаем: меняем внешнюю переменную
  total_score += score

add_to_total_global(87)
print(total_score)      # 87

// Output:

Пояснение логики: вариант А — данные входят и выходят через аргументы и return, у функции нет скрытых побочных эффектов, её легко проверить отдельно от остального скрипта. Вариант Б работает, но global прячет от читателя код тот факт, что вызов функции меняет что-то за её пределами — в большом скрипте такие скрытые изменения труднее отследить. Предпочтение — вариант А; global держат в уме как исключение для редких случаев.

9.5 Мини-словарик ошибок девятой главы

Ошибка	Что значит для Python	Человеческий перевод
`NameError`	«Имя функции ещё не определено»	Вызов стоит в коде раньше, чем `def`. Все функции определяют до первого вызова.
`TypeError` (арифметика с `None`)	«Нельзя сложить `NoneType` и число»	Функция напечатала результат через `print()`, но не вернула его через `return` — снаружи оказался `None`.
`UnboundLocalError`	«Локальная переменная использована до присваивания»	Внутри функции переменной с именем внешнего накопителя присвоили значение (в том числе через `+=`) — Python сделал имя локальным на всю функцию и потерял доступ к внешнему значению.
— (тихая ошибка)	«Без `()` — это ссылка на функцию, а не вызов»	Забыли скобки при вызове: переменная получила сам объект-функцию, а не результат её работы.
— (тихая ошибка)	«Значение по умолчанию — один объект на все вызовы»	Изменяемый объект (`scores=[]`) в значении по умолчанию создаётся один раз при определении функции и копит данные между вызовами без явного аргумента.

Отдельного разбора заслуживает ошибка при неверном числе аргументов — она встречается на практике едва ли не чаще всех прочих:

// PYTHON_EXECUTOR (Pyodide Wasm)

def get_status(score, pass_threshold):
  return 'зачёт' if score >= pass_threshold else 'незачёт'

print(get_status(87))          # забыли второй обязательный аргумент

// Output:

Traceback (most recent call last):
  File "report.py", line 4, in <module>
    print(get_status(87))
TypeError: get_status() missing 1 required positional argument: 'pass_threshold'

Python точно называет недостающий аргумент по имени — это самая говорящая трассировка в книге на данный момент: достаточно передать pass_threshold вторым аргументом или дать ему значение по умолчанию (pass_threshold=60), как в 9.2, чтобы аргумент стал необязательным.

Мини-кейс: модуль расчётов — набор функций аналитика

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

// PYTHON_EXECUTOR (Pyodide Wasm)

# 1. Сбор данных
students = [
  {'name': 'Иванов Иван', 'scores': [78, 92, 45]},
  {'name': 'Смирнова Ольга', 'scores': [92, 88, 95]},
  {'name': 'Ким Юрий', 'scores': [50, 55, 40]},
]
pass_threshold = 60

# 2. Расчёты — собственный набор функций
def calculate_average(scores):
  return sum(scores) / len(scores)

def get_status(average_score, pass_threshold=60):
  return 'зачёт' if average_score >= pass_threshold else 'незачёт'

def format_report_line(student_name, average_score, status):
  return f'{student_name}: средний балл {average_score:.1f} — {status}'

report_lines = []
passed_count = 0

for student in students:
  average_score = calculate_average(student['scores'])
  status = get_status(average_score, pass_threshold)
  report_lines.append(format_report_line(student['name'], average_score, status))
  if status == 'зачёт':
      passed_count += 1

# 3. Вывод итогового отчёта
print('--- ОТЧЁТ ПО ГРУППЕ ---')
for line in report_lines:
  print(line)
print(f'--- Сдали: {passed_count} из {len(students)} ---')

// Output:

--- ОТЧЁТ ПО ГРУППЕ ---
Иванов Иван: средний балл 71.7 — зачёт
Смирнова Ольга: средний балл 91.7 — зачёт
Ким Юрий: средний балл 48.3 — незачёт
--- Сдали: 2 из 3 ---

Что получилось: каждая функция отвечает ровно за один шаг — расчёт, оценку статуса или сборку строки — и ни одна не печатает результат сама, все возвращают значение через return. Цикл из главы Циклы использует их как готовые инструменты, поэтому логику расчёта достаточно поменять в одном месте (calculate_average), а не искать копии формулы по всему скрипту.

⚠️ Если у ученика в выгрузке окажется пустой список scores (не сдал ни одного модуля), calculate_average() упадёт с ZeroDivisionError — та же защита len(...) > 0, что и в главе 8, здесь просто спрятана внутрь функции. Устойчивая обработка такой строки выгрузки, без остановки всего отчёта, — тема главы Ошибки и исключения.

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

Дальше: Файлы и CSV

Глава 9. Функции: свой набор инструментов аналитика

9.1 def: своя функция расчёта среднего балла

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

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

9.2 Аргументы: позиционные, именованные, значения по умолчанию

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

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

9.3 return: возврат значения против print() внутри функции

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

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

9.4 Область видимости: локальные и глобальные имена

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

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

9.5 Мини-словарик ошибок девятой главы

Мини-кейс: модуль расчётов — набор функций аналитика

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

9.1 `def`: своя функция расчёта среднего балла

9.3 `return`: возврат значения против `print()` внутри функции