Аргументы функции в Python: данные внутрь

Функция из первого урока делала одно и то же: print_line каждый раз рисовала одну и ту же линию. Полезная функция работает с разными данными: одно приветствие — для Анны, Бориса и Веры, одна печать цены — для хлеба и молока. Данные попадают внутрь функции через аргументы — это следующий шаг после def.

Аргументы и параметры: коротко

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

Параметр: переменная в объявлении

Добавим скобкам функции имя-переменную — параметр:

def greet(name):
    print(f'Привет, {name}!')

greet('Анна')
greet('Борис')

Привет, Анна!
Привет, Борис!

Разбираем по частям. В объявлении def greet(name): — name это параметр: переменная, придуманная вами, как переменная цикла. В вызове greet('Анна') — строка 'Анна' это аргумент: конкретное значение, которое функция получает при вызове. Параметр — это имя в объявлении функции, а аргумент — конкретное значение, которое функция получает при вызове. На первом вызове внутри тела name равно 'Анна', на втором — 'Борис'. Тело написано один раз, а работает с любыми данными.

Сколько параметров — столько аргументов

Параметров может быть несколько — они перечисляются в скобках через запятую:

def print_price(item, price):
    print(f'{item}: {price} руб.')

print_price('Хлеб', 45)
print_price('Молоко', 80)

Хлеб: 45 руб.
Молоко: 80 руб.

При вызове значения расходуются по позиции: 'Хлеб' попадает в item, 45 — в price. Такие аргументы называют позиционными: важен не только сам аргумент, но и его место в вызове. Параметров не ограничено два — добавьте третий, четвёртый, сколько нужно данным:

def show_card(title, author, year):
    print(f'«{title}», {author}, {year}')

show_card('Муму', 'Тургенев', 1852)
show_card('Война и мир', 'Толстой', 1869)

«Муму», Тургенев, 1852
«Война и мир», Толстой, 1869

Правило жёсткое: сколько параметров в объявлении — столько аргументов в вызове. Меньше — Python не сможет заполнить параметр, больше — ему некуда деть лишнее. Обе ситуации дают ошибку:

# Так не запускается: price остался без значения
def print_price(item, price):
    print(f'{item}: {price} руб.')

print_price('Хлеб')

# Так не запускается: третьему значению нет места
def print_price(item, price):
    print(f'{item}: {price} руб.')

print_price('Хлеб', 45, 'батон')

Порядок аргументов = порядок параметров

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

def show(date, event):
    print(f'{date}: {event}')

show('12 июня', 'финал')
show('финал', '12 июня')

12 июня: финал
финал: 12 июня

Оба вызова прошли без ошибок: типы подходящие. Но вторая строка вывода бессмысленна — дата и событие поменялись местами. Перепутанный порядок — коварная ошибка: Python её не заметит, если типы совпадают. Спасение — именованные вызовы, им посвящён урок про умолчания и именованные аргументы.

Аргументом может быть что угодно

В скобках вызова можно передать не только строку-константу: подойдёт переменная или выражение — Python вычислит его и передаст в функцию готовый результат:

def shout(word):
    print(word.upper() + '!')

word = 'готово'
shout(word)
shout('давай' + '-' + 'вперед')
shout('го')

ГОТОВО!
ДАВАЙ-ВПЕРЕД!
ГО!

Перед вторым вызовом Python склеил 'давай' + '-' + 'вперед' в одну строку и передал в функцию уже готовый результат. Внутри тела аргумент — обычная переменная: к ней применимы все привычные операции строк.

Функция и цикл: переменная как аргумент

Свяжем это с прошлым разделом: в цикле переменная на каждом шаге получает новое значение — её и передаём в функцию:

def line(name, mark):
    print(f'{name}: {mark}')

grades = {'Анна': 5, 'Борис': 4, 'Вера': 3}
for name, mark in grades.items():
    line(name, mark)

Анна: 5
Борис: 4
Вера: 3

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

Типы аргументов Python не проверяет

Объявление функции — это обещание, а не контракт. Написали print_price(item, price), решили, что price — число в рублях, — и Python молча поверит. Никакой проверки типов при вызове нет: если вместо числа передали строку, функция получит строку и будет работать с ней как умеет. В проекте с чеками это выглядело так: сумма удваивалась для скидки, и вместо 160 печаталось 160160 — нашёлся один переданный по сети аргумент типа строка.

def print_price(item, price):
    total = price * 2
    print(f'{item}: {total} руб.')

print_price('Хлеб', 45)
print_price('Молоко', '80')

Хлеб: 90 руб.
Молоко: 8080 руб.

Строку можно умножать на число — получится та же строка, повторённая дважды. Python не считает это ошибкой, потому что операция для строки осмысленная. Отсюда неприятный вывод: если данные приходят извне (файл, форма, сеть), приводите их к нужному типу сами, на границе входа, а не внутри расчёта. Для чисел это int(value) или float(value), для списков — list(value). Подробнее о типах — урок про аннотации.

Один параметр или список

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

def print_total(name, items):
    total = 0
    for item in items:
        total = total + item
    print(f'{name}: {total} руб.')

print_total('Корзина 1', [120, 80, 45])
print_total('Корзина 2', [30, 15])

Корзина 1: 245 руб.
Корзина 2: 45 руб.

Мы держимся правила: пока полей три и они не меняются — отдельные параметры, читать вызов в глаза приятно. Как только поля начинают прибывать и уезжать (а это происходит с каждым новым требованием заказчика), переходим на словарь — как принимать такие данные, разбирается в уроке про **kwargs.

Список-аргумент меняется в теле функции

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

def add_promo(prices):
    prices.append(0)
    print('внутри:', len(prices))

cart = [120, 80]
add_promo(cart)
print('снаружи:', len(cart))

внутри: 3
снаружи: 3

Практика: чек по списку позиций

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

def print_line(item, price):
    print(f'- {item}: {price} руб.')

cart = [('Хлеб', 45), ('Молоко', 80), ('Сыр', 240)]
for item, price in cart:
    print_line(item, price)

- Хлеб: 45 руб.
- Молоко: 80 руб.
- Сыр: 240 руб.

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

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