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

Функции спасают от копипаста и хаоса

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

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

Польза не только в экономии строк. Хорошее имя работает как подпись: строка calc_order_total(450, 3) сама рассказывает, что происходит, без единого комментария. Программа из таких блоков читается как оглавление книги, а не как сплошная простыня команд. Добавляется и удобство проверки: если расчёт скидки живёт в одном месте, проверить его достаточно один раз, а не десять.

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

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

Объявление через def и вызов функции

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

def greet():
    print("Привет! Рады видеть на курсе.")

greet()
greet()

Программа напечатает приветствие дважды. Здесь принципиально разделить два события. Строка def greet(): только объявляет функцию: описывает её и запоминает под именем, не выполняя ни одной команды из тела. Тело срабатывает лишь при вызове, когда имя пишут со скобками. Скобки обязательны даже без параметров: greet означает "такая функция существует", а greet() означает "выполни её сейчас".

Когда программа встречает вызов, происходит короткое путешествие:

  1. Python запоминает место, откуда функция была вызвана;
  2. выполняет тело функции сверху вниз;
  3. дойдя до return или до конца тела, возвращается в запомненное место;
  4. подставляет возвращённое значение туда, где стоял вызов.

Имена функций принято писать строчными буквами с подчёркиванием между словами: show_menu, calc_price, send_report. Это тот же стиль snake_case, что и у переменных. Имя лучше выбирать глагольное, потому что функция что-то делает: не просто discount, а get_discount.

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

Позиционные параметры и порядок аргументов

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

def greet_user(name, greeting):
    print(f"{greeting}, {name}!")

greet_user("Аня", "Привет")  # Привет, Аня!

Здесь name и greeting - параметры, а "Аня" и "Привет" - аргументы, конкретные значения, переданные при вызове. Слово "позиционные" подчёркивает, что значения распределяются по порядку: первый аргумент попадает в первый параметр, второй во второй. Перепутать порядок легко, и результат выходит комичным:

greet_user("Привет", "Аня")  # Аня, Привет! да, звучит странно

Python не возразит: оба значения строки, типы подходят. Порядок аргументов проверяет не интерпретатор, а внимательность автора. А вот количество он проверяет строго. Меньше аргументов, чем параметров, - вызов упадёт с ошибкой:

greet_user("Аня")
# TypeError: greet_user() missing 1 required positional argument: 'greeting'

Сообщения длинные, но честные: в них прямо названо, какого аргумента не хватило. Лишние аргументы тоже не пройдут - интерпретатор пожалуется на неожиданный позиционный аргумент.

Значения можно передавать и по именам: greet_user(greeting="Привет", name="Аня") сработает, и перепутать порядок уже не получится. У этого приёма есть свои тонкости, и о них, вместе с гибкими наборами аргументов, подробно пойдёт речь в следующем уроке.

Возврат значений через return

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

def get_discount_price(price):
    if price >= 5000:
        return price * 0.9
    return price

total = get_discount_price(6000)
print(total)  # 5400.0

Здесь два return, и это совершенно нормально. Срабатывает первый, до которого дошло выполнение, и он же завершает работу функции: до второй строки дело не доходит. Большая цена превращается в цену со скидкой, остальная возвращается как есть. Такой приём называют ранним выходом, и он спасает от громоздких вложенных условий. Пустой return, без значения, тоже работает и возвращает None: им удобно выйти заранее, если продолжать расчёт бессмысленно.

А что вернёт функция вообще без return? Специальное значение None, то есть "здесь ничего нет":

def say_hello():
    print("Привет")

result = say_hello()
print(result)  # None

Функция добросовестно напечатала приветствие, но вернула None, и переменная result осталась бесполезной. Отсюда частая ошибка новичка: результат вроде выведен, а использовать его нельзя, потому что на самом деле ничего не вернулось.

Несколько значений возвращаются через запятую:

def min_max(numbers):
    return min(numbers), max(numbers)

low, high = min_max([3, 7, 1, 9])
print(low, high)  # 1 9

На самом деле пара упаковывается в один кортеж, о котором будет отдельный разговор позже, но пока достаточно уметь распаковывать его в две переменные, как в примере выше. Кстати, после return допустимо писать и целое выражение, и вызов другой функции: строка return round(total, 2) сначала округлит число, потом сразу его вернёт. Последнее действие функции нередко само оказывается ответом, и отдельная переменная не нужна.

Значения по умолчанию и docstring

Некоторые параметры чаще всего получают одно и то же значение. Чтобы не печатать его при каждом вызове, параметру задают значение по умолчанию:

def make_tea(kind, sugar=0):
    print(f"Чай: {kind}, сахара: {sugar}")

make_tea("чёрный")      # Чай: чёрный, сахара: 0
make_tea("зелёный", 2)  # Чай: зелёный, сахара: 2

Правило простое: параметры со значениями по умолчанию ставят после обязательных. Строка def make_tea(sugar=0, kind) вызовет синтаксическую ошибку, потому что обязательный параметр не может идти после необязательного. И одна ловушка на будущее: списки и словари в качестве значений по умолчанию лучше не ставить, у этого есть неочевидная особенность, к которой курс вернётся при разговоре об изменяемых типах.

Функцию принято снабжать строкой документации, docstring. Это текст в тройных кавычках, который стоит первой строкой внутри тела:

def to_fahrenheit(celsius):
    """Переводит температуру из Цельсия в Фаренгейты."""
    return round(celsius * 9 / 5 + 32, 2)

print(to_fahrenheit(36.6))  # 97.88

Docstring не просто украшение. Вызов help(to_fahrenheit) покажет этот текст прямо в консоли, редакторы кода подставляют его в подсказки, а тот же текст живёт в атрибуте to_fahrenheit.__doc__, откуда его можно достать программно. Через полгода docstring расскажет самому автору, зачем функция была нужна. Длинные описания оформляют так: сначала краткое описание в одну строку, затем пустая строка и подробности о каждом параметре, как будет в примере ниже.

Полный пример расчёта стоимости с доставкой

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

def order_total(price, quantity, delivery=300, discount=0.0):
    """Считает итоговую стоимость заказа.

    price - цена одной единицы товара,
    quantity - количество единиц,
    delivery - стоимость доставки, по умолчанию 300,
    discount - скидка в долях, 0.1 означает десять процентов.
    """
    goods = price * quantity
    total = goods * (1 - discount)
    if goods >= 3000:
        delivery = 0  # крупный заказ, доставка бесплатная
    return round(total + delivery, 2)

print(order_total(450, 3))                # 1650.0
print(order_total(450, 3, delivery=500))  # 1850.0
print(order_total(800, 5, discount=0.1))  # 3600.0

Функция принимает два обязательных параметра и два необязательных. Сначала считается стоимость товаров, затем применяется скидка, затем проверяется порог бесплатной доставки. Значение delivery спокойно меняется внутри тела, и это не портит значение по умолчанию: в следующем вызове Python снова подставит честные 300, потому что значение по умолчанию - это подстановка при каждом вызове, а не общая память на все вызовы. Параметр discount объявлен как 0.0, а не как 0, намеренно: сразу видно, что ожидается доля, число с точкой.

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

Отличие print от return

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

def show_sum(a, b):
    print(a + b)

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

show_sum(2, 3)         # просто покажет 5 и всё

result = get_sum(2, 3)
print(result * 10)     # 50, с числом можно работать дальше

stored = show_sum(2, 3)
print(stored)          # None, функция ничего не вернула

Забавная деталь для полного понимания: сама функция print тоже возвращает None. Она существует только ради текста на экране. Отсюда практичное правило: функция, которая что-то вычисляет, должна возвращать результат через return, а решает, показывать его на экране или нет, тот код, который функцию вызвал. Тогда функции свободно соединяются друг с другом, как детали конструктора: результат одной становится аргументом другой.

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