Как я могу обозначить неиспользуемые аргументы функции?

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

>>> a,_,_ = (1,2,3)
>>> a
1

Используя Python 2.x, как я могу выразить то же самое с аргументами функции? Я попытался использовать символы подчеркивания:

>>> def f(a,_,_): return a
...
  File "<stdin>", line 1
SyntaxError: duplicate argument '_' in function definition

Я также попытался просто полностью опустить аргумент:

>>> def f(a,,): return a
  File "<stdin>", line 1
    def f(a,,): return a
        ^
SyntaxError: invalid syntax

Есть ли другой способ добиться того же?

Ответ 1

Вот что я делаю с неиспользуемыми аргументами:

def f(a, *unused):
    return a

Ответ 2

Смешной способ, о котором я только думал, состоит в том, чтобы удалить переменную:

def f(foo, unused1, unused2, unused3):
    del unused1, unused2, unused3
    return foo

Это имеет множество преимуществ:

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

Ответ 3

Подчеркивание используется для вещей, которые нам не нужны, а * in * args обозначает список аргументов. Поэтому мы можем использовать * _ для обозначения списка вещей, которые нам не нужны:

def foo(bar, *_):
    return bar

Он даже передает проверки PyCharm.

Ответ 4

Если у вас есть как args, так и ключевое слово arg, вы должны использовать

def f(a, *args, **kwargs):
    return a

Ответ 5

Я думаю, что принятый ответ плох, но он все равно может работать, если вы используете то, что я должен назвать "способом Perl" для работы с аргументами (я не знаю Perl на самом деле, но я перестаю пытаться изучить его после просмотра синтаксис sub с ручной распаковкой аргументов):

У вашей функции есть 3 аргумента - это то, с чем она вызвана (утиная печать, помните?). Итак, вы получаете:

def funfun(a, b, c):
    return b * 2

2 неиспользуемых параметра. Но теперь введите улучшенный подход к лерам:

def funfun(*args):
    return args[1] * 2

И вот идут предупреждения...

Тем не менее, мне по-прежнему нравится больше в коробке:

def funfun(a, b, c):
    del a, c
    return b * 2

Сохраняет самоидентификационное качество имен параметров. Это особенность, а не ошибка.

Но сам язык не заставляет вас туда - вы также можете пойти наоборот, и просто пусть у вашей функции есть подпись (*args, **kwargs), и каждый раз анализируйте аргумент вручную. Представьте себе уровень контроля, который дает вам. И больше никаких исключений при вызове устаревшим способом после изменения вашей "подписи" (количество аргументов и значение). Это стоит рассмотреть;)