Vorrei indicare una funzione che non fa nulla:

def identity(*args)
    return args

il mio caso d'uso è qualcosa del genere

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

Certo, potrei usare il identitysopra definito, ma un built-in sarebbe sicuramente più veloce (ed eviterebbe i bug introdotti dal mio).

Apparentemente, mape filterusare Noneper l'identità, ma questo è specifico per le loro implementazioni.

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

Facendo qualche ricerca in più, non c'è nessuno, una funzione è stata chiesta nel numero 1673203 E da Raymond Hettinger ha detto che non ci saranno :

Meglio lasciare che le persone scrivano i loro pass-through banali e pensare alla firma e ai costi del tempo.

Quindi un modo migliore per farlo è in realtà (un lambda evita di nominare la funzione):

_ = lambda *args: args

• vantaggio: accetta qualsiasi numero di parametri
• svantaggio: il risultato è una versione in box dei parametri

O

_ = lambda x: x

• vantaggio: non cambia il tipo di parametro
• svantaggio: accetta esattamente 1 parametro posizionale

Una funzione di identità, come definita in https://en.wikipedia.org/wiki/Identity_function , accetta un singolo argomento e lo restituisce invariato:

def identity(x):
    return x

Quello che stai chiedendo quando dici che vuoi la firma non lodef identity(*args) è strettamente una funzione di identità, poiché vuoi che prenda più argomenti. Va bene, ma poi si verifica un problema poiché le funzioni Python non restituiscono più risultati, quindi è necessario trovare un modo per stipare tutti questi argomenti in un valore restituito.

Il solito modo di restituire "valori multipli" in Python è di restituire una tupla di valori: tecnicamente si tratta di un valore di ritorno, ma può essere utilizzato nella maggior parte dei contesti come se fosse più valori. Ma farlo qui significa che ottieni

>>> 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,)

E risolvere questo problema rapidamente dà altri problemi, come hanno dimostrato le varie risposte qui.

Quindi, in sintesi, non esiste una funzione di identità definita in Python perché:

1. La definizione formale (una funzione a argomento singolo) non è così utile ed è banale da scrivere.
2. L'estensione della definizione a più argomenti non è ben definita in generale e è molto meglio definire la propria versione che funziona come serve per la propria situazione particolare.

Per il tuo caso preciso,

def dummy_gettext(message):
    return message

è quasi certamente quello che vuoi - una funzione che ha la stessa convenzione di richiamo e il ritorno gettext.gettext, che restituisce il suo argomento invariato e che è chiaramente chiamato per descrivere ciò che fa e dove è destinato a essere utilizzato. Sarei piuttosto scioccato se la performance fosse una considerazione cruciale qui.

il tuo funzionerà benissimo. Quando il numero di parametri è fisso puoi usare una funzione anonima come questa:

lambda x: x

Non esiste una funzione di identità integrata in Python. Un'imitazione della funzione di Haskellid sarebbe:

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

Esempio di utilizzo:

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

Dal momento identityche non fa altro che restituire gli argomenti forniti, non penso che sia più lento di un'implementazione nativa.

No, non c'è.

Si noti che il tuo identity:

1. è equivalente a lambda * args: args

2. Inscatolerà i suoi argomenti - cioè

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

Quindi, potresti voler usare lambda arg: argse vuoi una vera funzione d'identità.

NB: Questo esempio oscurerà la idfunzione integrata (che probabilmente non userai mai).

Se la velocità non ha importanza, questo dovrebbe gestire tutti i casi:

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())

Esempi di utilizzo:

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 di una funzione a argomento singolo

gettext.gettext(caso esempio uso del PO) accetta un singolo argomento, message. Se uno ha bisogno di uno stub per questo, non c'è motivo di tornare al [message]posto di message( def identity(*args): return args). Quindi entrambi

_ = lambda message: message

def _(message):
    return message

si adatta perfettamente.

... ma un built-in sarebbe sicuramente più veloce (ed eviterebbe i bug introdotti dal mio).

I bug in un caso così banale sono appena rilevanti. Per un argomento di tipo predefinito, diciamo str, possiamo usare str()se stesso come una funzione di identità (a causa della stringa interna mantiene anche l'identità dell'oggetto, vedi idnota sotto) e confronta le sue prestazioni con la soluzione lambda:

$ 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

È possibile una micro-ottimizzazione. Ad esempio, il seguente codice Cython :

test.pyx

cpdef str f(str message):
    return message

Poi:

$ 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

Funzione di identità dell'oggetto incorporata

Non confondere una funzione di identità con la idfunzione integrata che restituisce l '"identità" di un oggetto (che significa un identificatore univoco per quel particolare oggetto piuttosto che il valore di quell'oggetto, rispetto ==all'operatore), il suo indirizzo di memoria in CPython.

Il thread è piuttosto vecchio. Ma volevo ancora pubblicare questo.

È possibile creare un metodo di identità per argomenti e oggetti. Nell'esempio seguente, ObjOut è un'identità per ObjIn. Tutti gli altri esempi precedenti non hanno trattato i dict ** kwargs.

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}