Процедуры и функции с параметрами

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

Подпрограмма — это отдельный, заранее описанный алгоритм с собственным именем, который можно вызвать из основного алгоритма по этому имени. Процедура выполняет действия, функция вдобавок возвращает результат.

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

Зачем выносить часть алгоритма

Есть три практические причины, и все они проверяются на экзамене и в реальном коде.

Повторное использование. Один и тот же кусок (площадь, факториал, проверка на простоту) нужен в разных местах — пишем его раз.
Читаемость. Главный алгоритм превращается в короткий список понятных вызовов: ввод_данных, обработать, вывод. Детали спрятаны внутри.
Поиск ошибок. Если что-то считается неверно, ошибку ищут в одной маленькой подпрограмме, а не во всей простыне кода.

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

Параметры и возвращаемое значение

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

Параметры — вход

Параметры — это «дырки» в подпрограмме, куда при вызове подставляются конкретные значения. У функции площади два параметра: длина и ширина. При вызове площадь(5, 3) внутрь подставятся 5 и 3.

Возврат — выход

Функция отдаёт результат назад в основной алгоритм через возвращаемое значение. Это позволяет использовать функцию прямо в выражении: s = площадь(5, 3) + площадь(2, 4). Процедура же ничего не возвращает — она просто что-то делает (например, печатает строку или рисует фигуру).

Площадь прямоугольника считается по формуле

$$ S = a \cdot b, $$

где $a$ — длина, $b$ — ширина. Опишем это как функцию на Python и вызовем трижды.

def ploshchad(a, b):
    return a * b

s1 = ploshchad(5, 3)
s2 = ploshchad(2, 4)
s3 = ploshchad(6, 6)

print("Площади:", s1, s2, s3)
print("Сумма:", s1 + s2 + s3)

Вывод:

Площади: 15 8 36
Сумма: 59

Обрати внимание: тело функции (формула) написано один раз, а вызовов — три, с разными числами. Изменись формула — правка только в одном месте.

Блок-схема вызова подпрограммы

В блок-схемах по ГОСТ для вызова подпрограммы есть особая фигура — прямоугольник с двойными боковыми линиями (его называют «предопределённый процесс»). Внутри пишут имя вызываемой подпрограммы. Это сигнал: «здесь выполняется отдельный, описанный в другом месте алгоритм».

Схема состоит из двух частей. Сама подпрограмма рисуется отдельной блок-схемой со своими Начало и Конец (или Возврат):

Подпрограмма ploshchad(a, b):
   ( начало )
       |
   [ S := a * b ]
       |
   ( возврат S )

Главный алгоритм:
   ( начало )
       |
   [ ввод a, b ]
       |
  ||  ploshchad(a, b)  ||   <-- вызов: двойные боковые линии
       |
   [ вывод результата ]
       |
   ( конец )

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

Как это работает

Под капотом происходит четыре шага, и понимание их спасает от типичных ошибок.

Передача аргументов. Значения из вызова (5 и 3) копируются в параметры подпрограммы (a и b).
Локальная работа. Внутри подпрограммы переменные «свои»: a, b, любые промежуточные. Снаружи их не видно. Это называется локальной областью видимости.
Возврат значения. Функция вычисляет результат и отдаёт его наружу.
Возврат управления. Программа продолжается со следующей за вызовом команды.

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

Частые ошибки

Путают процедуру и функцию. Если подпрограмма должна вернуть число для дальнейших вычислений — это функция с return. Если она просто печатает или рисует — процедура. Попытка написать x = print(...) положит в x пустоту (None).
Забывают return. Функция без явного возврата отдаёт None, и дальнейшие вычисления ломаются.
Путают параметр и аргумент. Параметр — имя в описании функции (def f(a, b)), аргумент — конкретное значение в вызове (f(5, 3)). На экзамене формулировка «формальный параметр» = имя в заголовке, «фактический» = значение при вызове.
Лезут к локальным переменным снаружи. Переменная, объявленная внутри подпрограммы, после выхода из неё исчезает — снаружи к ней обратиться нельзя.

Итоги

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