Je voudrais signaler une fonction qui ne fait rien:

def identity(*args)
    return args

mon cas d'utilisation est quelque chose comme ça

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

Bien sûr, je pourrais utiliser la identitydéfinition ci-dessus, mais un intégré fonctionnerait certainement plus rapidement (et éviterait les bogues introduits par moi-même).

Apparemment, mapet à filterutiliser Nonepour l'identité, mais cela est spécifique à leurs implémentations.

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

Pour faire plus de recherche, il n'y en a pas, une fonctionnalité a été posée dans le numéro 1673203 Et de Raymond Hettinger a déclaré qu'il n'y en aurait pas :

Mieux vaut laisser les gens écrire leurs propres pass-through triviaux et réfléchir aux coûts de signature et de temps.

Donc, une meilleure façon de le faire est en fait (un lambda évite de nommer la fonction):

_ = lambda *args: args

• avantage: prend n'importe quel nombre de paramètres
• inconvénient: le résultat est une version en boîte des paramètres

OU

_ = lambda x: x

• avantage: ne change pas le type du paramètre
• inconvénient: prend exactement 1 paramètre de position

Une fonction d'identité, telle que définie dans https://en.wikipedia.org/wiki/Identity_function , prend un seul argument et le renvoie inchangé:

def identity(x):
    return x

Ce que vous demandez lorsque vous dites que vous voulez la signature def identity(*args)n'est pas strictement une fonction d'identité, car vous voulez qu'elle prenne plusieurs arguments. C'est bien, mais vous rencontrez un problème car les fonctions Python ne renvoient pas plusieurs résultats, vous devez donc trouver un moyen de regrouper tous ces arguments dans une seule valeur de retour.

La manière habituelle de renvoyer des "valeurs multiples" en Python est de renvoyer un tuple des valeurs - techniquement, c'est une valeur de retour mais elle peut être utilisée dans la plupart des contextes comme s'il s'agissait de plusieurs valeurs. Mais faire cela ici signifie que vous obtenez

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

Et résoudre ce problème donne rapidement d'autres problèmes, comme l'ont montré les différentes réponses ici.

Donc, en résumé, il n'y a pas de fonction d'identité définie dans Python car:

1. La définition formelle (une fonction à un seul argument) n'est pas si utile et est simple à écrire.
2. Étendre la définition à plusieurs arguments n'est pas bien défini en général, et il vaut mieux définir votre propre version qui fonctionne comme vous en avez besoin pour votre situation particulière.

Pour votre cas précis,

def dummy_gettext(message):
    return message

est presque certainement ce que vous voulez - une fonction qui a la même convention d'appel et le même retour que gettext.gettext, qui retourne son argument inchangé, et est clairement nommée pour décrire ce qu'elle fait et où elle est destinée à être utilisée. Je serais assez choqué si la performance était une considération cruciale ici.

le vôtre fonctionnera bien. Lorsque le nombre de paramètres est fixe, vous pouvez utiliser une fonction anonyme comme celle-ci:

lambda x: x

Il n'y a pas de fonction d'identité intégrée dans Python. Une imitation de la fonction de Haskellid serait:

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

Exemple d'utilisation:

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

Puisqu'il identityne fait rien d'autre que renvoyer les arguments donnés, je ne pense pas que ce soit plus lent qu'une implémentation native ne le serait.

Non, il n'y en a pas.

Notez que votre identity:

1. équivaut à lambda * args: args

2. Va boxer ses arguments - ie

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

Donc, vous pouvez utiliser lambda arg: arg si vous voulez une véritable fonction d'identité.

NB: Cet exemple va masquer la idfonction intégrée (que vous n'utiliserez probablement jamais).

Si la vitesse n'a pas d'importance, cela devrait gérer tous les cas:

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

Exemples d'utilisation:

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 d'une fonction à un seul argument

gettext.gettext(l'exemple de cas d' utilisation OP) accepte un seul argument, message. Si on a besoin d'un stub pour cela, il n'y a aucune raison de revenir [message]au lieu de message( def identity(*args): return args). Ainsi les deux

_ = lambda message: message

def _(message):
    return message

s'adapter parfaitement.

... mais un intégré fonctionnerait certainement plus rapidement (et éviterait les bogues introduits par moi-même).

Les bogues dans un cas aussi trivial sont à peine pertinents. Pour un argument de type prédéfini, disons str, nous pouvons nous utiliser str()comme fonction d'identité (en raison de la chaîne interne, il conserve même l'identité de l'objet, voir la idnote ci-dessous) et comparer ses performances avec la solution 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

Une micro-optimisation est possible. Par exemple, le code Cython suivant:

test.pyx

cpdef str f(str message):
    return message

Ensuite:

$ 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

Fonction d'identité d'objet intégrée

Ne confondez pas une fonction d'identité avec la idfonction intégrée qui renvoie `` l'identité '' d'un objet (c'est-à-dire un identifiant unique pour cet objet particulier plutôt que la valeur de cet objet, par rapport à l' ==opérateur), son adresse mémoire en CPython.

Le fil est assez vieux. Mais je voulais toujours publier ceci.

Il est possible de créer une méthode d'identité pour les arguments et les objets. Dans l'exemple ci-dessous, ObjOut est une identité pour ObjIn. Tous les autres exemples ci-dessus n'ont pas traité de 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}