Обернуть функцию без затирания аргументов по умолчанию

Обычный способ определить, пропущен ли параметр, — использовать None по умолчанию. Маловероятно, что вы будете вызывать функцию с None, так что это полезный маркер.

def func2(b=None):
    if b is None:
        return func1()
    else:
        return func1(b)

Я подозреваю, что правильный способ сделать это состоит в том, чтобы ваша функция func2 использовала дозорное значение в качестве аргумента по умолчанию, чтобы вы могли легко его распознать. Если вы получите этот часовой, вы можете настроить аргументы, которые вы передадите func1, как хотите (например, не передавая никаких аргументов). Вы можете использовать распаковку аргументов для обработки передачи переменного количества аргументов (например, 0-1).

Обычным дозорным является None, хотя, если это может быть значимым значением для передачи вызывающей стороны, вы можете использовать что-то еще (экземпляр object является распространенным выбором). Вот пример:

def func1(a="default value"): # lets assume we don't know what this default is
    # do stuff with a

# later, perhaps in a different module

_sentinel = object()    # our sentinel object

def func2(b=_sentinel):
    if b is _sentinel:  # test for the sentinel
        b = "some useful value"
        a_args = ()     # arguments to func1 is an empty tuple
    else:
        a_args = (b,)   # pack b into a 1-tuple

    # do stuff with b perhaps

    func1(*a_args)      # call func1 with appropriate arguments (either b or nothing)

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

Смотрите этот ответ:

https://stackoverflow.com/a/2088101/933416

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

def func2(*args, **kwargs):
    if len(args) == 0 and "b" not in kwargs:
        b = y
        return func1()
    else:
        return func1(b)

Теперь с первой проверки мы гарантируем, что был вызван func2(), а не func2(y) или func2(b=y). Почти в каждом случае метка уникального объекта достаточно хороша, чтобы избежать необходимости действительно гарантировать, как она была вызвана, но это можно сделать.

Но, судя по тому, что вы немедленно возвращаете результат func1, я не вижу причин, по которым func2 вообще имеет аргументы по умолчанию. В вызове по умолчанию (func2()) этот y никогда не используется. Так почему же это там? Почему бы вам просто не использовать define func2(*a, **k) и не передать их напрямую func1?

Пересылка аргументов должна выполняться с вариативными аргументами:

def func2(*args, **kwargs):
    func1(*args, **kwargs)

Все просто будет работать, хотя самоанализ может немного пострадать.

Если вам нужно иногда не передавать аргумент, вы можете удалить аргумент всякий раз, когда:

del kwargs["name"]

Пример:

def print_wrapper(*args, extrabig=False, **kwargs):
    if extrabig:
        args = [arg*2 for arg in args]
        kwargs["sep"] = kwargs.get("sep", " ") * 2

    print(*args, **kwargs)

print_wrapper(2, 4, 8, end="!!!\n")
#>>> 2 4 8!!!

print_wrapper(2, 4, 8, sep=", ", end="!!!\n")
#>>> 2, 4, 8!!!

print_wrapper(2, 4, 8, extrabig=True, end="!!!\n")
#>>> 4  8  16!!!

Если вы действительно не хотите этого делать (хотя вы ошибаетесь), вы можете использовать object для создания уникального часового.

# Bad! Won't let you print None
def optionally_print_one_thing(thing=None):
    if thing is not None:
        print(thing)

# Better
_no_argument = object()
def optionally_print_one_thing(thing=_no_argument):
    if thing is not _no_argument:
        print(thing)

Каков ваш точный вариант использования? func2 должен быть достаточно умен, чтобы передавать только соответствующие параметры func1, и это должно полагаться на значения по умолчанию любых параметров.

Единственный раз, когда я счел необходимым изменить то, как func2 вызывает func1, это когда func1 является функцией c со странной подписью:

def func2(this, that, those=None):
    if those is None:
        return func1(this, that)
    else:
        return func1(this, that, those)