python中有内置的身份函数吗？

Question

我想指出一个什么都不做的函数：

def identity(*args)
    return args

我的用例是这样的

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

当然，我可以使用上面定义的identity，但是内置的肯定会运行得更快（并且避免我自己引入的错误）​​。

显然，map 和 filter 使用 None 作为标识，但这是特定于它们的实现的。

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

Answer 1

做一些更多的研究，没有，在issue 1673203 和Raymond Hettinger said there won't be 中询问了一个功能：

最好让人们编写自己的琐碎传递 并考虑签名和时间成本。

所以实际上更好的方法是（lambda 避免命名函数）：

_ = lambda *args: args

• 优点：接受任意数量的参数
• 缺点：结果是参数的盒装版本

或

_ = lambda x: x

• 优点：不改变参数的类型
• 缺点：只需要 1 个位置参数

Answer 2

https://en.wikipedia.org/wiki/Identity_function 中定义的标识函数接受一个参数并原样返回：

def identity(x):
    return x

当你说你想要签名 def identity(*args) 时，你所要求的是 不是严格的身份函数，因为你希望它接受多个参数。这很好，但是你遇到了一个问题，因为 Python 函数不会返回多个结果，所以你必须找到一种将所有这些参数塞进一个返回值的方法。

在 Python 中返回“多个值”的常用方法是返回值的元组 - 从技术上讲，这是一个返回值，但它可以在大多数情况下使用，就好像它是多个值一样。但在这里这样做意味着你得到了

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

并且快速修复那个问题会带来其他问题，正如这里的各种答案所示。

所以，总而言之，Python 中没有定义恒等函数，因为：

1. 正式定义（单参数函数）没有那么有用，而且写起来很简单。
2. 一般来说，将定义扩展到多个参数并没有很好的定义，您最好定义自己的版本，以根据您的特定情况使用它。

对于您的具体情况，

def dummy_gettext(message):
    return message

几乎肯定是你想要的——一个与gettext.gettext 具有相同调用约定和返回的函数，它返回它的参数不变，并且清楚地命名以描述它的作用以及它打算在哪里使用。如果性能是这里的关键考虑因素，我会感到非常震惊。

Answer 3

你的会很好用。当参数数量固定后，您可以使用这样的匿名函数：

lambda x: x

Answer 4

Python 中没有内置的标识函数。 Haskell's id function 的模仿是：

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

示例用法：

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

由于identity 除了返回给定的参数之外什么都不做，我认为它不会比原生实现慢。

Answer 5

不，没有。

注意你的identity:

1. 等价于 lambda *args: args

2. 将其 args 装箱 - 即

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

所以，如果你想要一个真实的身份功能，你可能想使用lambda arg: arg。

注意：此示例将隐藏内置的 id 函数（您可能永远不会使用）。

Answer 6

如果速度无关紧要，这应该可以处理所有情况：

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

使用示例：

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)

Answer 7

单参数函数的存根

gettext.gettext（OP 的示例用例）接受单个参数 message。如果需要一个存根，没有理由返回[message] 而不是message (def identity(*args): return args)。因此两者都

_ = lambda message: message

def _(message):
    return message

完美契合。

...但是内置的肯定会运行得更快（并避免我自己引入的错误）​​。

这种微不足道的情况下的错误几乎无关紧要。对于预定义类型的参数，比如str，我们可以将str() 本身用作标识函数（因为string interning 它甚至保留了对象标识，请参见下面的id 注意）并将其性能与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

可以进行微优化。比如下面的Cython代码：

test.pyx

cpdef str f(str message):
    return message

然后：

$ 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

内置对象标识函数

不要将标识函数与返回对象的“标识”的id 内置函数混淆（意味着该特定对象的唯一标识符，而不是该对象的值，与==运算符相比），它在CPython中的内存地址。

Answer 8

添加到所有答案：

请注意，Python stdlib 中有一个隐式约定，其中 HOF 将其 key 参数函数默认为标识函数，将 None 解释为这样。

例如sorted、heapq.merge、max、min等

因此，考虑您的 HOF 期望 key 遵循相同的模式是不错的主意。

也就是说，而不是：

def my_hof(x, key=lambda _: _):
   ...

（这是完全正确的）

你可以写：

def my_hof(x, key=None):
    key = lambda _: _ if key is None
    ...

如果你愿意。

Answer 9

线程很旧。但还是想发这个。

可以为参数和对象构建一个标识方法。在下面的示例中，ObjOut 是 ObjIn 的标识。上面所有其他示例都没有处理 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}