我想指向一个什么也不做的函数：
def identity(*args)
return args
我的使用场景类似于这样
try:
gettext.find(...)
...
_ = gettext.gettext
else:
_ = identity
当然，我可以使用上面定义的identity，但内置函数肯定会更快（而且避免了由自己引入的错误）。
显然，map和filter使用None作为identity，但这是特定于它们的实现。
>>> _=None
>>> _("hello")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'NoneType' object is not callable
经过进一步的研究，没有这样的功能。在问题1673203中曾经有人提出过这个功能，但来自Raymond Hettinger的说法是不会添加此功能:
最好让用户自己编写简单的“传递函数”并考虑签名和时间成本。
因此，实际上一个更好的方法是（lambda避免了命名函数）：
_ = lambda *args: args
或者
_ = lambda x: x
lambda x: x 身份函数可以用于一个字符串参数。@Marcin 我希望我能做到 lambda *args: *args :-) - rds身份函数是指按照https://zh.wikipedia.org/wiki/身份函数的定义，接受一个参数并返回未经修改的参数本身：
def identity(x):
return x
def identity(*args)的函数时，你所要求的并不严格属于一个恒等函数，因为你希望它可以接受多个参数。虽然这没问题，但你会遇到一个问题，因为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中没有定义恒等函数的原因是：
对于您的具体情况，
def dummy_gettext(message):
return message
很可能这是您想要的 - 一个具有与gettext.gettext相同的调用约定和返回值的函数，它返回其参数未更改，并且其名称清晰地描述了其功能和使用场景。如果性能在这里是至关重要的考虑因素，我会感到非常震惊。
id = lambda *args：args if len（args）> 1 else args [0]即可。 - Max你的代码可以正常工作。当参数数量是固定的时候，你可以使用如下的匿名函数：
lambda x: x
lambda *args: args。这实际上是一种风格选择。 - user395760lambda和def编写。这就是我的全部观点。 - user395760Python中没有内置的身份函数。一个模仿Haskell的id函数的方法是：
identity = lambda x, *args: (x,) + args if args else x
使用示例：
identity(1)
1
identity(1,2)
(1, 2)
由于identity除了返回给定的参数之外不会执行任何操作，因此我认为它不会比本地实现更慢。
identity() 函数将会失败；以下代码将修复该问题：identity = lambda x=None, *args: (x,) + args if args else x。 - ankostisWill box its args - i.e.
In [6]: id = lambda *args: args
In [7]: id(3)
Out[7]: (3,)
如果您想要一个真正的身份函数，可以使用lambda arg: arg。
注意：这个例子将会覆盖内置的id函数（您可能永远不会使用它）。
id。 - Marcindef 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)
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
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中的内存地址。
这个主题中有很多好的答案和讨论。我只想指出，在 OP 的情况下，如果在 identity 函数中只有一个参数，那么在编译方面，使用 lambda 还是定义函数并没有区别（在这种情况下，你应该定义函数以保持符合 PEP8 的规范）。字节码在功能上是相同的：
import dis
function_method = compile("def identity(x):\n return x\ny=identity(Type('x', (), dict()))", "foo", "exec")
dis.dis(function_method)
1 0 LOAD_CONST 0 (<code object identity at 0x7f52cc30b030, file "foo", line 1>)
2 LOAD_CONST 1 ('identity')
4 MAKE_FUNCTION 0
6 STORE_NAME 0 (identity)
3 8 LOAD_NAME 0 (identity)
10 LOAD_NAME 1 (Type)
12 LOAD_CONST 2 ('x')
14 LOAD_CONST 3 (())
16 LOAD_NAME 2 (dict)
18 CALL_FUNCTION 0
20 CALL_FUNCTION 3
22 CALL_FUNCTION 1
24 STORE_NAME 3 (y)
26 LOAD_CONST 4 (None)
28 RETURN_VALUE
Disassembly of <code object identity at 0x7f52cc30b030, file "foo", line 1>:
2 0 LOAD_FAST 0 (x)
2 RETURN_VALUE
和 lambda
import dis
lambda_method = compile("identity = lambda x: x\ny=identity(Type('x', (), dict()))", "foo", "exec")
dis.dis(lambda_method)
1 0 LOAD_CONST 0 (<code object <lambda> at 0x7f52c9fbbd20, file "foo", line 1>)
2 LOAD_CONST 1 ('<lambda>')
4 MAKE_FUNCTION 0
6 STORE_NAME 0 (identity)
2 8 LOAD_NAME 0 (identity)
10 LOAD_NAME 1 (Type)
12 LOAD_CONST 2 ('x')
14 LOAD_CONST 3 (())
16 LOAD_NAME 2 (dict)
18 CALL_FUNCTION 0
20 CALL_FUNCTION 3
22 CALL_FUNCTION 1
24 STORE_NAME 3 (y)
26 LOAD_CONST 4 (None)
28 RETURN_VALUE
Disassembly of <code object <lambda> at 0x7f52c9fbbd20, file "foo", line 1>:
1 0 LOAD_FAST 0 (x)
2 RETURN_VALUE
补充所有答案：
请注意，在Python stdlib中有一个隐含的约定，其中HOF将其key参数函数默认为恒等函数，将None解释为这样。
例如：sorted、heapq.merge、max、min等。
因此，考虑您的HOF期望key遵循相同的模式并不是坏主意。
也就是说，不要这样做：
def my_hof(x, key=lambda _: _):
...
这是完全正确的。
你可以写：
def my_hof(x, key=None):
if key is None: key = lambda _: _
...
如果你想的话。
key = lambda _: _ if key is None 不是有效的 Python 语法，正确的写法应该是 if key is None: key = lamda _: _。 - Harold Cooperif 后缀时需要一个 else。而且 lambda 表达式本身就包含了所有的 if 语句。另一种方法是 key = (lambda _: _) if key is None else None。但我更喜欢你提出的前缀形式。我正在编辑答案。 - jgomo3这个帖子已经很老了，但我仍然想发表一下我的看法。
可以为参数和对象构建身份方法。在下面的示例中，ObjOut是ObjIn的身份标识。所有其他示例都没有处理字典**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}
map(identity, [1, 2, 3]) 返回 [1, 2, 3]？ - rds.identity()函数与赋值没有任何区别：objOut = objIn.identity()等同于objOut = objIn。这个线程是关于一个返回给定内容的函数：objIn is identity(objIn)——在这种情况下，kwargs毫无意义。 - Ethan Furman
map(None, [1, 2, 3])的翻译是将函数map()应用于参数[1, 2, 3]，其中第一个参数为None。 - Greg Hewgill