*args и **kwargs: две звёздочки, которые стоят по-разному — и одна из них делает неизвестные имена допустимыми

strict(a=1, unknown=9)                         TypeError
loose(a=1, unknown=9)                          a=1 b=2 kwargs={'unknown': 9}
loose()                                        TypeError        ← обязательный параметр
loose(1, a=2)                                  TypeError        ← дважды переданный
positional_only_loose(a=1, b=2, c=3)           TypeError        ← имя вместо позиции

База: звёздочка на двух сторонах вызова

У звёздочки в Python несколько ролей, и все они пишутся одинаково — одним и тем же символом. Пока роли не разведены, разговор про *args и **kwargs ходит по кругу; разведём их сразу.

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

В объявлении звёздочка собирает. Она берёт то, чему не нашлось отдельного параметра, и кладёт под одно имя:

• одна звёздочка собирает лишние позиционные аргументы — те, что переданы по порядку;
• две звёздочки собирают лишние именованные — те, что переданы по имени.

В вызове звёздочка раскладывает. Она берёт готовый контейнер и подставляет его содержимое как отдельные аргументы:

• одна раскладывает последовательность в позиционные аргументы: f(*seq) — это то же самое, что f(seq[0], seq[1], …);
• две раскладывают словарь в именованные: f(**mapping) — это f(имя=значение, …) по каждой паре.

Вот те же роли рядом, а последней строкой — запись, которая звёздочку использует совсем иначе:

Четыре разные операции, и путаница между первой и второй — самая частая: f(*args) внутри обёртки не создаёт кортеж, а разбирает уже созданный. Последняя строка к сборке отношения не имеет вовсе, и до неё мы дойдём отдельно.

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

Этого уже достаточно, чтобы ответить на базовый вопрос собеседования. Всё дальнейшее — про то, что собранное приходит кортежем и словарём, а не чем попало; что две звёздочки на передаче стоят вчетверо дороже одной; и что имя, которого у функции нет, перестаёт быть ошибкой, как только в объявлении появились две звёздочки.

Механизм 1: что это за объекты

Начнём с того, что проверяется одной функцией.

def collect(*args, **kwargs):
    return type(args).__name__, type(kwargs).__name__

collect(1, 2, x=3) возвращает ('tuple', 'dict'). Не список — кортеж, и это проверяется одной строкой: args.append(3) даёт AttributeError: 'tuple' object has no attribute 'append'. Изменяемого контейнера здесь не будет, сколько бы аргументов ни пришло.

Второе и менее очевидное: объекты создаются даже когда передавать нечего.

def probe(*args, **kwargs):
    return args, kwargs
 
probe()   # -> ((), {})

Не None, а пустой кортеж и пустой словарь. Справочник языка говорит именно так: *identifier is initialized to a tuple receiving any excess positional parameters, defaulting to the empty tuple (инициализируется кортежем, принимающим все лишние позиционные параметры, по умолчанию пустым кортежем). Поэтому if args: — правильная проверка, а if args is not None: — всегда истина.

Что о звёздочках знает сам код функции

def full(a, b=2, *args, c, d=4, **kwargs):
    pass

Объявление выглядит запутанным, но интерпретатор раскладывает его на три независимых числа и два флага:

Отсюда простое следствие, которое снимает главную путаницу: c и d стали только-именованными не потому, что у них есть значения по умолчанию, а потому что они стоят после *args. Это правило из PEP 3102, и голая * в объявлении делает то же самое без сбора кортежа.

Порядок именованных аргументов сохраняется: order(z=1, a=2, m=3) даёт ключи в порядке ['z', 'a', 'm'], а не отсортированные.

Механизм 2: ошибка, которая не падает

Функция подключения. Три понятных параметра, и кто-то дописал четвёртый — «мало ли что понадобится прокинуть в драйвер».

def connect(host, port=5432, timeout=30, **options):
    ...

Через полгода в другом файле пишут вызов:

connect("db", timeuot=5)

Ошибки не будет. timeuot — законный ключ для **options, и функция получит timeout = 30, а пятёрка ляжет в options, куда никто не смотрит. Соединение установится, программа продолжит работу, и разница проявится однажды под нагрузкой — таймаутом, которого не ждали.

Без **options тот же вызов падает сразу, и падает информативно.

Почему это стало хуже, а не лучше

В 3.13 интерпретатор научился подсказывать правильное имя. «Что нового» говорит: The error message now tries to suggest the correct keyword argument when an incorrect keyword argument is passed to a function (Сообщение об ошибке теперь пытается подсказать правильный именованный аргумент, если в функцию передали неверный). Проверено на всех четырёх версиях:

То есть язык стал ловить ровно эту опечатку лучше — а функция, объявленная с **kwargs, эту помощь выбрасывает. С ней 3.14 ведёт себя так же, как 3.11: молчит.

Чем это лечится

Не внимательностью. Если **kwargs действительно нужен — проверкой неизвестных ключей там же, где они принимаются:

KNOWN = {"sslmode", "application_name"}
 
def connect(host, port=5432, timeout=30, **options):
    unknown = set(options) - KNOWN
    if unknown:
        raise TypeError(f"неизвестные параметры: {', '.join(sorted(unknown))}")

Четыре строки возвращают отказ по неизвестному имени — тот самый, который перестал возникать сам, как только имена стали допустимыми. А если **kwargs нужен не был — его отсутствие и есть проверка, причём бесплатная.

Механизм 3: / и голая * — зачем занимать имена

Две вещи из PEP 570 и PEP 3102, у которых есть измеримое следствие, а не только косметическое.

Голая * запрещает передавать всё, что после неё, позиционно:

def open_conn(host, *, timeout=30, retries=3):
    ...

Теперь open_conn("db", 5) — ошибка, а не таймаут в пять секунд, попавший в timeout по счёту. Порядок параметров перестаёт быть частью договора, и его можно менять, не ломая вызывающих.

Слеш / делает обратное — запрещает передавать по имени. И нужен он не для симметрии, а по причине, которую видно только на запуске:

def name_taken(name, **kwargs):
    return name, kwargs
 
def name_free(name, /, **kwargs):
    return name, kwargs

Пока параметр можно передать по имени, это имя занято: ключ с таким же названием в **kwargs попасть не может. PEP 570 называет ровно этот случай: A key scenario is when a function accepts any keyword argument but can also accepts a positional one (Ключевой случай — когда функция принимает любой именованный аргумент, но при этом принимает и позиционный).

Так объявлен и сам dict. Его сигнатура видна прямо из интерпретатора:

dict.__init__.__text_signature__   # ($self, /, *args, **kwargs)
dict(self="x")                     # {'self': 'x'}

Слеш освобождает имя self — без него dict(self="x") давало бы got multiple values for argument 'self'.

Механизм 4: что обёртка делает с сигнатурой

У *args, **kwargs в декораторе есть побочный эффект, которого не видно в коде обёртки.

def wrap(fn):
    def inner(*args, **kwargs):
        return fn(*args, **kwargs)
    return inner

Здесь wrap — декоратор, а inner — обёртка, которую он возвращает и которая встаёт на место исходной функции. Сигнатуру теряет именно обёртка: у декоратора wrap она своя и никуда не девается.

inspect.signature у такой обёртки показывает (*args, **kwargs) — имена параметров исчезли, а вместе с ними подсказки редактора и половина пользы от проверки типов. Лечится это @functools.wraps(fn), и после него сигнатура показывается исходная: (host, port=5432, timeout=30).

Но она не описывает то, что обёртка готова принять. Проверено: обёртка пропускает и пять позиционных аргументов, и любое имя — не проверив ничего. Падает вызов уже внутри: connect() takes from 1 to 3 positional arguments but 5 were given. @wraps возвращает сигнатуру для инструментов, но не заставляет обёртку ей следовать.

Видно это и в трассировке: кадров на один больше, чем слоёв, — свой кадр вызова плюс по кадру на каждую обёртку.

Само сообщение всегда называет внутреннюю функцию — @wraps скопировал ей имя, и различить их по тексту нельзя. Различаются кадры: без @wraps в трассировке подряд стоят три inner, и до строки с опечаткой читать три чужих кадра.

Механизм 5: типизация — чем вернуть стёртые имена

Это единственный автоматический способ вернуть то, что **kwargs стирает.

До 3.12 аннотировать **kwargs можно было только одним типом на все значения. PEP 692 называет это ограничение прямо: Currently **kwargs can be type hinted as long as all of the keyword arguments specified by them are of the same type. However, that behaviour can be very limiting (Сейчас **kwargs можно аннотировать, только если все передаваемые через них именованные аргументы одного типа. Но такое поведение может сильно ограничивать). С 3.12 появился Unpack[TypedDict]:

class Options(TypedDict, total=False):
    sslmode: str
    application_name: str
 
def connect(host: str, **options: Unpack[Options]) -> None:
    ...

Теперь проверяющий типы — mypy, pyright — снова видит имена и ловит timeuot=5 до запуска: error: Unexpected keyword argument "timeuot". На сам вызов это не влияет: интерпретатор по-прежнему принимает его молча — для него это имя допустимо. Отказ по неизвестному имени возвращается снаружи, до запуска, раз внутри вызова его больше нет.

Глубже: сколько стоят звёздочки

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

Главное здесь — асимметрия. Две звёздочки пишутся рядом, называются одним дыханием и стоят совершенно по-разному:

• plain(*args) — ×1,1–1,3 от прямого позиционного вызова. Практически бесплатно.
• plain(**kwargs) — ×4,0–5,2. Вчетверо и больше.

Причина видна в байт-коде, и она конкретнее, чем «словарь сложнее кортежа». Одинаково на всех четырёх версиях:

plain(*ARGS)      LOAD_GLOBAL LOAD_GLOBAL CALL_FUNCTION_EX
plain(**KWARGS)   LOAD_GLOBAL LOAD_CONST BUILD_MAP LOAD_GLOBAL DICT_MERGE CALL_FUNCTION_EX

На стороне вызова кортеж уходит как есть: CALL_FUNCTION_EX получает готовый объект. Внутри функция с *args соберёт уже свой кортеж — g(*T) is T даёт False, — но это происходит и при обычном вызове. А перед вызовом со словарём интерпретатор создаёт новый словарь (BUILD_MAP) и копирует в него переданный (DICT_MERGE) — то есть словарь копируется на каждом вызове, ещё до того, как начнётся сопоставление имён с параметрами. Отсюда и четырёхкратная разница.

Именованная передача устроена иначе и стоит дешевле: она компилируется не в CALL_FUNCTION_EX, а в CALL_KW с готовым кортежем имён в константах — словаря не создаётся вовсе. Отсюда и разрыв: ×1,3–1,9 против ×4 с лишним у plain(**kwargs). Это не довод против именованных аргументов — читаемость дороже десятка наносекунд (на 3.13.7 разница вышла 11,3 нс), — но довод против того, чтобы считать их бесплатными в горячем цикле.

Обёртки складываются

Декоратор на *args, **kwargs делает обе работы сразу: принимает звёздочками (собирает кортеж и словарь) и передаёт звёздочками (разбирает их обратно).

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

История версий

Как отвечать на собеседовании

Короткий ответ: звёздочка в объявлении собирает, звёздочка в вызове раскладывает. Одна собирает лишние позиционные аргументы в кортеж args, две — лишние именованные в словарь kwargs; в вызове одна раскладывает последовательность в позиционные аргументы, две — словарь в именованные. И оба объекта создаются даже когда передавать нечего: приходят () и {}, а не None.

Этого достаточно, чтобы ответить верно. Дальше — то, что добавляют, если собеседник копает.

Если интервьюер копает глубже

Первое — цена, и она у двух звёздочек разная: plain(*args) почти бесплатен, а plain(**kwargs) дороже прямого вызова вчетверо и больше, устойчиво на всех четырёх версиях.

Что отличает хороший ответ: назвать не цену, а то, что **kwargs, дописанный «для гибкости», делает неизвестные имена именованных аргументов допустимыми для этой функции. Вызов connect("db", timeuot=5) перестаёт быть TypeError и молча уходит в options, а timeout остаётся равным 30. Хуже того, с 3.13 интерпретатор умеет подсказывать правильное имя — и функция с **kwargs эту помощь выбрасывает, ведя себя на 3.14 так же, как на 3.11.

Дальше спросят

Частые заблуждения

Практика

Две задачи. Сначала ответьте, потом сверьтесь с настоящим выводом: в обеих правильный ответ взят из прогона скрипта, а не назначен.

def connect(dsn, timeout=30, **options):
  return timeout, options


print(connect("db", timeout=5))
print(connect("db", timeuot=5))

(5, {})
(30, {'timeuot': 5})

(5, {})
(5, {})

(5, {})
(30, {})

(5, {})
Traceback (most recent call last):
TypeError: connect() got an unexpected keyword argument 'timeuot'

Проверка знаний