Ich möchte auf eine Funktion verweisen, die nichts bewirkt:

def identity(*args)
    return args

Mein Anwendungsfall ist so etwas

try:
    gettext.find(...)
    ...
    _ = gettext.gettext
else:
    _ = identity

Natürlich könnte ich das identityoben definierte verwenden, aber ein eingebautes würde sicherlich schneller laufen (und Fehler vermeiden, die von mir selbst verursacht wurden).

Anscheinend mapund filterVerwendung Nonefür die Identität, aber dies ist spezifisch für ihre Implementierungen.

>>> _=None
>>> _("hello")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'NoneType' object is not callable

Bei weiteren Nachforschungen gibt es keine, ein Feature wurde in Ausgabe 1673203 gefragt. Und von Raymond Hettinger sagte, es werde keine geben :

Es ist besser, die Leute ihre eigenen trivialen Pass-Throughs schreiben zu lassen und über die Unterschrift und die Zeitkosten nachzudenken.

Ein besserer Weg, dies zu tun, ist tatsächlich (ein Lambda vermeidet es, die Funktion zu benennen):

_ = lambda *args: args

• Vorteil: Nimmt eine beliebige Anzahl von Parametern
• Nachteil: Das Ergebnis ist eine Box-Version der Parameter

ODER

_ = lambda x: x

• Vorteil: Ändert den Typ des Parameters nicht
• Nachteil: Nimmt genau 1 Positionsparameter

Eine Identitätsfunktion, wie sie in https://en.wikipedia.org/wiki/Identity_function definiert ist , nimmt ein einzelnes Argument und gibt es unverändert zurück:

def identity(x):
    return x

Was Sie verlangen, wenn Sie sagen, dass Sie die Signatur möchten, def identity(*args)ist keine reine Identitätsfunktion, da Sie möchten, dass mehrere Argumente verwendet werden. Das ist in Ordnung, aber dann stoßen Sie auf ein Problem, da Python-Funktionen nicht mehrere Ergebnisse zurückgeben. Sie müssen also einen Weg finden, alle diese Argumente in einen Rückgabewert zu packen.

Die übliche Methode zum Zurückgeben von "mehreren Werten" in Python besteht darin, ein Tupel der Werte zurückzugeben - technisch gesehen ist dies ein Rückgabewert, der jedoch in den meisten Kontexten verwendet werden kann, als wären es mehrere Werte. Aber das hier zu tun bedeutet, dass Sie bekommen

>>> def mv_identity(*args):
...     return args
...
>>> mv_identity(1,2,3)
(1, 2, 3)
>>> # So far, so good. But what happens now with single arguments?
>>> mv_identity(1)
(1,)

Und die schnelle Behebung dieses Problems führt zu anderen Problemen, wie die verschiedenen Antworten hier gezeigt haben.

Zusammenfassend ist in Python keine Identitätsfunktion definiert, weil:

1. Die formale Definition (eine einzelne Argumentfunktion) ist nicht so nützlich und trivial zu schreiben.
2. Das Erweitern der Definition auf mehrere Argumente ist im Allgemeinen nicht genau definiert, und Sie sollten Ihre eigene Version besser definieren, die so funktioniert, wie Sie es für Ihre spezielle Situation benötigen.

Für Ihren genauen Fall,

def dummy_gettext(message):
    return message

ist mit ziemlicher Sicherheit das, was Sie wollen - eine Funktion, die dieselbe Aufrufkonvention und Rückgabe wie hat gettext.gettext, die ihr Argument unverändert zurückgibt und eindeutig benannt ist, um zu beschreiben, was sie tut und wo sie verwendet werden soll. Ich wäre ziemlich schockiert, wenn die Leistung hier eine entscheidende Rolle spielen würde.

Ihre wird gut funktionieren. Wenn die Anzahl der Parameter festgelegt ist, können Sie eine anonyme Funktion wie die folgende verwenden:

lambda x: x

In Python ist keine Identitätsfunktion integriert. Eine Nachahmung der Haskell- idFunktion wäre:

identity = lambda x, *args: (x,) + args if args else x

Anwendungsbeispiel:

identity(1)
1
identity(1,2)
(1, 2)

Da identitynichts anderes tut, als die angegebenen Argumente zurückzugeben, denke ich nicht, dass es langsamer ist als eine native Implementierung.

Nein, gibt es nicht.

Beachten Sie, dass Ihre identity:

1. entspricht lambda * args: args

2. Wird seine Argumente boxen - dh

   In [6]: id = lambda *args: args
   
   In [7]: id(3)
   Out[7]: (3,)

Daher möchten Sie möglicherweise verwenden, lambda arg: argwenn Sie eine echte Identitätsfunktion wünschen.

NB: In diesem Beispiel wird die integrierte idFunktion (die Sie wahrscheinlich nie verwenden werden) beschattet .

Wenn die Geschwindigkeit keine Rolle spielt, sollte dies alle Fälle behandeln:

def identity(*args, **kwargs):
    if not args:
        if not kwargs:
            return None
        elif len(kwargs) == 1:
            return  next(iter(kwargs.values()))
        else:
            return (*kwargs.values(),)
    elif not kwargs:
        if len(args) == 1:
            return args[0]
        else:
            return args
    else:
        return (*args, *kwargs.values())

Anwendungsbeispiele:

print(identity())
None
$identity(1)
1
$ identity(1, 2)
(1, 2)
$ identity(1, b=2)
(1, 2)
$ identity(a=1, b=2)
(1, 2)
$ identity(1, 2, c=3)
(1, 2, 3)

Stub einer Einzelargumentfunktion

gettext.gettext(der Anwendungsfall des OP) akzeptiert ein einzelnes Argument message. Wenn man dafür einen Stub braucht, gibt es keinen Grund, [message]statt message( def identity(*args): return args) zurückzukehren. Also beides

_ = lambda message: message

def _(message):
    return message

passt perfekt.

... aber ein eingebautes würde sicherlich schneller laufen (und Fehler vermeiden, die von mir selbst verursacht wurden).

Fehler in einem so trivialen Fall sind kaum relevant. Für ein Argument vom vordefinierten Typ können wir struns str()beispielsweise als Identitätsfunktion verwenden (da die Zeichenfolge interniert , behält es sogar die Objektidentität bei, siehe idHinweis unten) und seine Leistung mit der Lambda-Lösung vergleichen:

$ python3 -m timeit -s "f = lambda m: m" "f('foo')"
10000000 loops, best of 3: 0.0852 usec per loop
$ python3 -m timeit "str('foo')"
10000000 loops, best of 3: 0.107 usec per loop

Eine Mikrooptimierung ist möglich. Zum Beispiel der folgende Cython- Code:

test.pyx

cpdef str f(str message):
    return message

Dann:

$ pip install runcython3
$ makecython3 test.pyx
$ python3 -m timeit -s "from test import f" "f('foo')"
10000000 loops, best of 3: 0.0317 usec per loop

Integrierte Objektidentitätsfunktion

Verwechseln Sie eine Identitätsfunktion nicht mit der idintegrierten Funktion, die die 'Identität' eines Objekts (dh eine eindeutige Kennung für dieses bestimmte Objekt und nicht den Wert dieses Objekts im Vergleich zum ==Operator), seine Speicheradresse in CPython, zurückgibt.

Der Thread ist ziemlich alt. Wollte das aber trotzdem posten.

Es ist möglich, eine Identitätsmethode sowohl für Argumente als auch für Objekte zu erstellen. Im folgenden Beispiel ist ObjOut eine Identität für ObjIn. Alle anderen obigen Beispiele haben sich nicht mit diktierten ** kwargs befasst.

class test(object):
    def __init__(self,*args,**kwargs):
        self.args = args
        self.kwargs = kwargs
    def identity (self):
        return self

objIn=test('arg-1','arg-2','arg-3','arg-n',key1=1,key2=2,key3=3,keyn='n')
objOut=objIn.identity()
print('args=',objOut.args,'kwargs=',objOut.kwargs)

#If you want just the arguments to be printed...
print(test('arg-1','arg-2','arg-3','arg-n',key1=1,key2=2,key3=3,keyn='n').identity().args)
print(test('arg-1','arg-2','arg-3','arg-n',key1=1,key2=2,key3=3,keyn='n').identity().kwargs)

$ py test.py
args= ('arg-1', 'arg-2', 'arg-3', 'arg-n') kwargs= {'key1': 1, 'keyn': 'n', 'key2': 2, 'key3': 3}
('arg-1', 'arg-2', 'arg-3', 'arg-n')
{'key1': 1, 'keyn': 'n', 'key2': 2, 'key3': 3}