Изменяемый аргумент по умолчанию: значение лежит в поле функции, и оно одно на все вызовы

База: функция помнит то, чего помнить не должна

Начать стоит с ошибки, которую все узнают в лицо. Функция кладёт переданное в список и возвращает его:

def acc(item, into=[]):
    into.append(item)
    return into
 
print(acc(1))       # [1]
print(acc(2))       # [1, 2] — а ждали [2]

Второй вызов вернул список из двух элементов, хотя ему передали один. Отсюда и правило, которое запоминают все: не пиши список в аргумент по умолчанию.

Но в таком виде правилу нечем помочь: оно выглядит произвольным запретом, поэтому его и нарушают. Вопрос, на который отвечает урок, — не «что нельзя», а когда вычисляется то, что стоит после знака равенства. Если при каждом вызове, то поведение выше необъяснимо. Если один раз, при выполнении def, — то объяснимо всё, включая случаи, где никаких списков нет вовсе.

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

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

Механизм 1: где лежит значение по умолчанию

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

«Предвычисленное значение» — не абстракция, его можно взять руками:

def acc(item, into=[]):
    into.append(item)
    return into
 
print(acc.__defaults__)     # ([],)
acc(1)
acc(2)
print(acc.__defaults__)     # ([1, 2],)

Поле функции растёт вместе со списком. Никакой особой магии в поломке нет: список создан один раз, положен в поле и оттуда достаётся каждому вызову, в котором этот аргумент не передан явно. Вызов acc(3, []) в этой картине не участвует вовсе — он работает со своим списком, а поле остаётся прежним.

Механизм 2: тот же механизм, вторая ловушка

Про изменяемость помнят чаще, чем про момент вычисления. А он тот же самый.

TIMEOUT = 5
 
def fetch(url, timeout=TIMEOUT):
    ...
 
TIMEOUT = 30        # fetch по-прежнему возьмёт 5

И самое дорогое проявление:

import time
 
def log(message, at=time.time()):
    ...            # at — момент импорта модуля, навсегда

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

Механизм 3: починка и когда None не годится

Справочник предлагает решение сразу же:

def acc(item, into=None):
    if into is None:
        into = []
    into.append(item)
    return into

Поле функции при этом остаётся (None,) навсегда — None неизменяем, портить в нём нечего.

Но None годится не всегда. Если None — допустимое значение аргумента, проверка не может отличить «не передали» от «передали None»:

MISSING = object()
store = {"k": None}          # словарь, в котором ищем
 
def get(key, default=MISSING):
    value = store.get(key, MISSING)
    if value is MISSING:
        if default is MISSING:
            raise KeyError(key)
        return default
    return value

Здесь get("k", None) обязан вернуть None, а get("k") — возбудить KeyError, и различить их можно только своим объектом-меткой. Метка дороже None на 8,07 нс — не из-за сравнения, а из-за загрузки: None компилируется в константу, а метка лежит в глобальных именах модуля. Выбирают её, разумеется, не из-за этих восьми наносекунд, а потому что None в такой функции занят.

Механизм 4: когда так делают нарочно

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

def fib(n, _cache={0: 0, 1: 1}):
    if n not in _cache:
        _cache[n] = fib(n - 1) + fib(n - 2)
    return _cache[n]

Работает. Но у этого решения три беды, и третья оказалась неожиданной.

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

Третья — скорость, и ожидание здесь было обратным. Казалось, что самодельный кеш быстрее functools.lru_cache: у того есть обёртка, а у этого нет. На прогретом кеше вышло наоборот:

lru_cache быстрее в 1,43 раза. Причина в том, что его обёртка написана на C и делает один поиск в словаре, а тело на Python делает два — проверку not in и чтение — плюс сам вызов функции. Обёртка на C обошлась дешевле, чем лишний поиск и вызов функции на Python.

Механизм 5: то же самое в классах

Механизм тот же, и документация датаклассов начинает объяснение именно с него: Python stores default member variable values in class attributes (Python хранит значения по умолчанию для переменных-членов в атрибутах класса).

class C:
    items = []          # один список на все экземпляры
 
o1, o2 = C(), C()
o1.items.append(1)
print(o2.items)         # [1]

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

@dataclass
class Bad:
    items: list = []
# ValueError: mutable default <class 'list'> for field items
#             is not allowed: use default_factory

Проверка стоит в самом декораторе и срабатывает при объявлении класса. Идёт она по хешируемости, а не по изменяемости. list, dict и set запрещены, а собственный класс с изменяемым состоянием проходит молча — и экземпляры разделят один объект. В обычной функции такой проверки нет вовсе: её делают только линтеры.

Глубже: что это стоит

Остался последний довод в защиту изменяемого значения по умолчанию — «зато без проверки быстрее». Довод верен: 32,67 нс против 48,78, то есть на 49 % дороже. Разложение показывает, за что именно платят:

• 11,37 нс — создание нового списка. Это не накладной расход, а работа, ради которой правильный вариант и пишется: сломанный дешевле ровно потому, что списка не создаёт.
• 4,74 нс — сама проверка is None.

То есть настоящая цена самой проверки — пять наносекунд на вызов. Остальные одиннадцать — новый список, которого сломанный вариант просто не создаёт.

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

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

Короткий ответ: выражение после = вычисляется один раз, при выполнении def, и получившийся объект достаётся каждому вызову, в котором этот аргумент не передан. Поэтому изменяемое значение по умолчанию накапливает изменения между вызовами. Чинится проверкой на None; своя метка нужна только там, где None — допустимое значение аргумента.

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

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

Что отличает хороший ответ: показать f.__defaults__ — это превращает правило в следствие. Значение лежит в поле функции, поле видно снаружи, и список в нём растёт от вызова к вызову; правило после этого не надо помнить — оно выводится.

И назвать вторую половину механизма: значение вычисляется в момент def, поэтому def log(at=time.time()) ломается по той же причине, хотя изменяемых объектов там нет вовсе.

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

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

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

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

Практика

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

def add(item, bucket=[]):
  bucket.append(item)
  return bucket


print(add(1))
print(add(2))
print(add.__defaults__)

[1]
[1, 2]
([1, 2],)

[1]
[2]
([],)

[1]
[1, 2]
([],)

[1]
[2]
([1, 2],)

Проверьте себя

Чем измерено

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

• bench/defaults/cost.py
• bench/defaults/where.py