Определение и вызов функции

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

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

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

Общая структура выглядит так:

def имя_функции(параметр1, параметр2):
    # тело функции
    ...

Разберём каждую часть по порядку.

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

Имя функции пишется сразу после def через пробел. Правила те же, что для переменных: латинские буквы, цифры (но не в начале), символ подчёркивания. По соглашению используется snake_case.

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

Двоеточие в конце первой строки обязательно. Точно так же, как в if или for, оно открывает блок.

Тело функции — всё, что написано с отступом (обычно 4 пробела) после строки с def. Отступ — единственный способ показать Python, где тело начинается и где заканчивается.

Пример определения функции с двумя параметрами:

def greet(name, greeting):
    message = greeting + ", " + name + "!"

Здесь name и greeting — параметры. Внутри тела они ведут себя как обычные переменные: можно складывать строки, присваивать результат другой переменной, использовать в условиях. Но пока функция только определена — этот код не выполняется. Python просто запоминает: «есть функция с таким именем и такой структурой».

Важно понять разницу: параметр существует только внутри определения функции, это имя-заглушка. Конкретное значение, которое придёт на его место при вызове, называется аргументом — но о вызове поговорим отдельно.

Пока достаточно одного ориентира: если видишь def — перед тобой не исполнение, а объявление. Код в теле запустится только тогда, когда функцию явно вызовут.

Оператор return: возврат значения из функции

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

Когда Python доходит до строки с return, он делает две вещи сразу: немедленно прекращает выполнение функции и передаёт указанное значение наружу. Всё, что написано в теле после return, уже не выполняется.

def square(x):
    return x * x
    print("эта строка никогда не выполнится")

Здесь return x * x вернёт результат умножения и выйдет из функции. Строка с print после return — мёртвый код: Python до неё просто не доберётся.

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

Что происходит, если return нет

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

def add_without_return(a, b):
    result = a + b  # посчитали, но ничего не вернули

value = add_without_return(3, 5)
print(value)  # None

Переменная value получит None, а не 8. Если потом попробовать использовать этот результат в арифметике, Python выбросит TypeError:

total = add_without_return(3, 5) + 10
# TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'

Ошибка звучит непонятно, потому что она указывает не на отсутствующий return, а на попытку сложить None с числом. Это одна из самых частых причин путаницы у начинающих: функция «работала», что-то считала, но результат потерялся внутри, так и не выйдя наружу.

Практическое правило: если функция должна что-то вычислять и отдавать результат — return обязателен. Без него функция выполнит действие и «проглотит» результат.

Вызов функции: аргументы и использование результата

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

def add(a, b):
    return a + b

result = add(3, 5)
print(result)  # 8

Здесь 3 и 5 — это аргументы. Они подставляются на места параметров a и b в том порядке, в котором написаны: первый аргумент идёт к первому параметру, второй — ко второму. Когда Python выполняет add(3, 5), он фактически делает a = 3 и b = 5 внутри функции, затем считает a + b и возвращает 8.

Вот в чём принципиальная разница между параметром и аргументом:

• Параметр (a, b) — имя-заглушка в строке с def. Существует только в момент определения и внутри тела функции.
• Аргумент (3, 5) — конкретное значение, которое передаётся при вызове.

Это то, что реально приходит на место параметра.

Одна и та же функция может быть вызвана сколько угодно раз с разными аргументами:

print(add(10, 20))   # 30
print(add(100, 1))   # 101

Каждый раз Python прогоняет тело функции заново с теми значениями, которые пришли в этом конкретном вызове.

Как использовать результат

Возвращаемое значение — полноценное выражение. Его можно:

• сохранить в переменную: result = add(3, 5)
• передать напрямую в print(): print(add(3, 5))
• использовать в другом выражении: total = add(3, 5) * 2

total = add(3, 5) * 2
print(total)  # 16

Важно не путать два сценария. Если написать просто add(3, 5) без сохранения — функция отработает, вернёт 8, но это значение тут же исчезнет: никто его не подхватил. Чтобы оно осталось доступным, нужно либо сохранить в переменную, либо сразу использовать в выражении или передать в другую функцию.

Пошаговая процедура написания функции от def до вызова

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

Шаг 1. Написать строку с def

Начните с ключевого слова def, затем имя функции, в скобках — параметры, в конце — двоеточие.

def multiply(a, b):

Пока это только заголовок. Ничего не выполняется.

Шаг 2. Написать тело с отступом

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

def multiply(a, b):
    result = a * b

Шаг 3. Завершить тело оператором return

Если функция должна отдать результат, последний значимый шаг внутри тела — return с нужным значением.

def multiply(a, b):
    result = a * b
    return result

Можно короче — return a * b напрямую, без промежуточной переменной. Оба варианта работают одинаково.

Шаг 4. Вызвать функцию с аргументами

После блока def (уже без отступа) пишете вызов: имя функции и конкретные значения в скобках.

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

multiply(4, 7)

Но здесь результат никуда не сохранён — он появится и тут же исчезнет.

Шаг 5. Сохранить результат или передать его дальше

Присвойте возвращённое значение переменной или передайте прямо в print().

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

product = multiply(4, 7)
print(product)       # 28
print(multiply(3, 3))  # 9

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