Me gustaría señalar una función que no hace nada:

def identity(*args)
    return args

mi caso de uso es algo como esto

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

Por supuesto, podría usar lo identitydefinido anteriormente, pero un dispositivo incorporado ciertamente funcionaría más rápido (y evitaría errores introducidos por mí mismo).

Aparentemente, mapy se filterusa Nonepara la identidad, pero esto es específico para sus implementaciones.

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

Investigando un poco más, no hay ninguno, se solicitó una característica en el número 1673203 y Raymond Hettinger dijo que no habrá :

Es mejor dejar que las personas escriban sus propios pases triviales y piensen en los costos de firma y tiempo.

Entonces, una mejor manera de hacerlo es en realidad (una lambda evita nombrar la función):

_ = lambda *args: args

• ventaja: toma cualquier número de parámetros
• desventaja: el resultado es una versión en caja de los parámetros

O

_ = lambda x: x

• ventaja: no cambia el tipo del parámetro
• desventaja: toma exactamente 1 parámetro posicional

Una función de identidad, como se define en https://en.wikipedia.org/wiki/Identity_function , toma un solo argumento y lo devuelve sin cambios:

def identity(x):
    return x

Lo que están pidiendo para cuando usted dice que quiere la firma def identity(*args)es no estrictamente una función de identidad, ya que desea que se lleve varios argumentos. Está bien, pero luego se encuentra con un problema, ya que las funciones de Python no devuelven múltiples resultados, por lo que debe encontrar una manera de agrupar todos esos argumentos en un valor de retorno.

La forma habitual de devolver "valores múltiples" en Python es devolver una tupla de los valores, técnicamente ese es un valor de retorno, pero puede usarse en la mayoría de los contextos como si fueran valores múltiples. Pero hacer eso aquí significa que obtienes

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

Y solucionar ese problema rápidamente genera otros problemas, como lo han demostrado las diversas respuestas aquí.

Entonces, en resumen, no hay una función de identidad definida en Python porque:

1. La definición formal (una función de argumento único) no es tan útil, y es trivial de escribir.
2. En general, extender la definición a múltiples argumentos no está bien definido, y es mucho mejor definir su propia versión que funcione de la manera que lo necesita para su situación particular.

Para su caso preciso,

def dummy_gettext(message):
    return message

es casi seguro lo que desea: una función que tiene la misma convención de llamada y retorno que gettext.gettext, que devuelve su argumento sin cambios, y está claramente nombrada para describir lo que hace y dónde está destinado a ser utilizado. Me sorprendería mucho si el rendimiento fuera una consideración crucial aquí.

el tuyo funcionará bien. Cuando se arregla el número de parámetros, puede usar una función anónima como esta:

lambda x: x

No hay una función de identidad incorporada en Python. Una imitación de la función de Haskellid sería:

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

Ejemplo de uso:

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

Como identityno hace nada excepto devolver los argumentos dados, no creo que sea más lento de lo que sería una implementación nativa.

No, no hay

Tenga en cuenta que su identity:

1. es equivalente a lambda * args: args

2. Encajonará sus args, es decir

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

Por lo tanto, es posible que desee utilizar lambda arg: arg si desea una verdadera función de identidad.

Nota: Este ejemplo sombreará la idfunción incorporada (que probablemente nunca usará).

Si la velocidad no importa, esto debería manejar todos los casos:

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

Ejemplos de uso:

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)

Trozo de una función de argumento único

gettext.gettext(caso de ejemplo el uso de la OP) acepta un solo argumento, message. Si uno necesita un trozo, no hay razón para regresar en [message]lugar de message( def identity(*args): return args). Así ambos

_ = lambda message: message

def _(message):
    return message

encaja perfectamente.

... pero un incorporado ciertamente correría más rápido (y evitaría errores introducidos por el mío).

Los errores en un caso tan trivial apenas son relevantes. Para un argumento de tipo predefinido, digamos str, podemos str()usarnos como una función de identidad (debido a la cadena interna , incluso conserva la identidad del objeto, vea la idnota a continuación) y compare su rendimiento con la solución 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

Una micro optimización es posible. Por ejemplo, el siguiente código de Cython :

test.pyx

cpdef str f(str message):
    return message

Luego:

$ 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

Función de identidad de objeto incorporada

No confunda una función de identidad con la idfunción incorporada que devuelve la 'identidad' de un objeto (es decir, un identificador único para ese objeto en particular en lugar del valor de ese objeto, en comparación con el ==operador), su dirección de memoria en CPython.

El hilo es bastante viejo. Pero todavía quería publicar esto.

Es posible construir un método de identidad tanto para argumentos como para objetos. En el siguiente ejemplo, ObjOut es una identidad para ObjIn. Todos los otros ejemplos anteriores no han tratado con 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}