Wie kann ich nicht verwendete Funktionsargumente bezeichnen?

Wenn ich ein Tupel "dekonstruiere", kann ich damit _Tupelelemente bezeichnen, an denen ich nicht interessiert bin, z

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

Wie kann ich mit Python 2.x dasselbe mit Funktionsargumenten ausdrücken? Ich habe versucht, Unterstriche zu verwenden:

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

Ich habe auch versucht, das Argument ganz wegzulassen:

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

Gibt es einen anderen Weg, um dasselbe zu erreichen?

Folgendes mache ich mit unbenutzten Argumenten:

def f(a, *unused):
    return a

Eine lustige Art, an die ich gerade gedacht habe, ist das Löschen der Variablen:

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

Dies hat zahlreiche Vorteile:

• Die nicht verwendete Variable kann weiterhin verwendet werden, wenn die Funktion sowohl als Positionsargument als auch als Schlüsselwortargument aufgerufen wird.
• Wenn Sie es später verwenden, können Sie es nicht, da es gelöscht wurde, sodass das Risiko von Fehlern geringer ist.
• Es ist die Standard-Python-Syntax.
• PyCharm macht das Richtige! (Ab 2020 macht PyCharm nicht mehr das Richtige :( Verfolgen Sie dies unter https://youtrack.jetbrains.com/issue/PY-39889 )
• PyLint wird sich nicht beschweren und die Verwendung delist die im PyLint-Handbuch empfohlene Lösung .

Der Unterstrich wird für Dinge verwendet, die uns nicht interessieren, und die * in * -Argumente bezeichnen eine Liste von Argumenten. Daher können wir * _ verwenden, um eine Liste von Dingen zu kennzeichnen, die uns nicht interessieren:

def foo(bar, *_):
    return bar

Es besteht sogar die Schecks von PyCharm.

Sie können '_' als Präfix verwenden, damit pylint diese Parameter ignoriert:

def f(a, _b, _c):

Wenn Sie sowohl Argumente als auch Schlüsselwörter haben, sollten Sie diese verwenden

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

Ich denke, die akzeptierte Antwort ist schlecht, aber es kann immer noch funktionieren, wenn Sie das verwenden, was ich als "Perl-Methode" für den Umgang mit Argumenten bezeichnen sollte (ich kenne Perl nicht wirklich, aber ich höre auf, es zu lernen, nachdem ich die subSyntax gesehen habe). mit manuellem Argument entpacken):

Ihre Funktion hat 3 Argumente - so wird sie aufgerufen (Duck tippen, erinnerst du dich?). So bekommen Sie:

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

2 nicht verwendete Parameter. Aber jetzt geben Sie einen verbesserten Larsmans-Ansatz ein:

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

Und da gehen die Warnungen ...

Trotzdem genieße ich den Weg der Box immer noch mehr:

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

Die selbstdokumentierende Qualität der Parameternamen bleibt erhalten. Sie sind eine Funktion, kein Fehler.

Aber die Sprache selbst zwingt Sie nicht dorthin - Sie könnten auch umgekehrt vorgehen und einfach alle Ihre Funktionen mit der Signatur versehen (*args, **kwargs)und das Argument jedes Mal manuell analysieren. Stellen Sie sich vor, wie viel Kontrolle Sie haben. Und keine Ausnahmen mehr, wenn Sie nach dem Ändern Ihrer "Signatur" (Anzahl und Bedeutung der Argumente) veraltet aufgerufen werden. Das ist eine Überlegung wert;)

Um "unbenutzte Variablen" -Inspektionsnachrichten für nicht verwendete * Argumente und / oder ** kwargs zu vermeiden, ersetze ich argsund kwargsdurch _und __:

def f(a, b, *_, **__):
    ...

Neben dem Entfernen von Nachrichten wird deutlich, dass Sie sich nicht für diese Argumente interessieren.

Ich kann nicht sagen, ob es eine wirklich universelle Lösung ist, aber sie hat überall funktioniert, wo ich sie bisher verwendet habe.