key 是一个函数，将调用该函数在比较集合的项之前对其进行转换。传递给的参数 key 一定是可以调用的东西。
使用 lambda 创建一个匿名函数（可调用）。就 sorted 可调用函数只接受一个参数。Python的 lambda 这很简单。它只能做和回报一件事真的。
的语法 lambda 这个词是什么 lambda 然后是参数名列表，然后是一个代码块。参数列表和代码块用冒号表示。这与python中的其他构造类似，例如 while , for , if 等等它们都是通常具有代码块的语句。lambda只是带有代码块的语句的另一个示例。
我们可以比较lambda和def的使用来创建函数。

adder_lambda = lambda parameter1,parameter2: parameter1+parameter2
def adder_regular(parameter1, parameter2): return parameter1+parameter2

lambda只是给了我们一种不指定名称的方法。这使得它非常适合用作函数的参数。 variable 在这里使用两次，因为在冒号的左侧是参数的名称，而在代码块的右侧是用来计算某些内容的。

我认为这里的所有答案都很好地涵盖了lambda函数在sorted（）上下文中的核心功能，但是我仍然觉得缺少一个能够导致直观理解的描述，所以这里是我的两分钱。
为了完整起见，我将首先声明一个明显的事实：sorted（）返回一个已排序元素的列表，如果我们想以特定的方式排序，或者如果我们想对一个复杂的元素列表（例如嵌套列表或元组列表）排序，我们可以调用key参数。
对我来说，对关键参数的直观理解，为什么它必须是可调用的，以及使用lambda作为（匿名）可调用函数来实现这一点分为两部分。
使用lamba最终意味着您不必编写（定义）整个函数，就像sblom提供的示例一样。lambda函数会被创建、使用并立即销毁，因此它们不会让您的代码陷入只会使用一次的代码中。据我所知，这是lambda函数的核心实用程序，它在此类角色中的应用非常广泛。它的语法纯粹是一种约定，本质上是编程语法的本质。学习语法并完成它。
lambda语法如下所示：

lambda input_variable(s): tasty one liner

哪里 lambda 是一个python关键字。
例如

In [1]: f00 = lambda x: x/2

In [2]: f00(10)
Out[2]: 5.0

In [3]: (lambda x: x/2)(10)
Out[3]: 5.0

In [4]: (lambda x, y: x / y)(10, 2)
Out[4]: 5.0

In [5]: (lambda: 'amazing lambda')() # func with no args!
Out[5]: 'amazing lambda'

背后的想法 key 参数是它应该接受一组指令，这些指令本质上将“sorted（）”函数指向那些应该用于排序的列表元素。当它说 key= ，它真正的意思是：当我遍历列表时，一次遍历一个元素（即。 for e in some_list )，我将把当前元素传递给键参数指定的函数，并使用它创建一个转换列表，它将通知我最终排序列表的顺序。
过来看：

In [6]: mylist = [3, 6, 3, 2, 4, 8, 23]  # an example list

# sorted(mylist, key=HowToSort)  # what we will be doing

基本示例：

# mylist = [3, 6, 3, 2, 4, 8, 23]

In [7]: sorted(mylist)
Out[7]: [2, 3, 3, 4, 6, 8, 23]  

# all numbers are in ascending order (i.e.from low to high).

例1：

# mylist = [3, 6, 3, 2, 4, 8, 23]

In [8]: sorted(mylist, key=lambda x: x % 2 == 0)

# Quick Tip: The % operator returns the *remainder* of a division

# operation. So the key lambda function here is saying "return True

# if x divided by 2 leaves a remainer of 0, else False". This is a

# typical way to check if a number is even or odd.

Out[8]: [3, 3, 23, 6, 2, 4, 8]  

# Does this sorted result make intuitive sense to you?

注意，我的lambda函数 sorted 检查每个元素 e 排序前为偶数或奇数。
但是等等！你可能（或者应该）想知道两件事。
首先，为什么奇数先于偶数？毕竟，关键价值似乎在告诉我们 sorted 函数通过使用 mod 接线员 x % 2 == 0 .
第二，为什么偶数仍然是无序的？2先于6，对吗？
通过分析这个结果，我们将更深入地了解“key”参数是如何工作的，特别是与匿名lambda函数结合使用时。
首先，你会注意到，虽然胜算在均线之前，但均线本身并没有被排序。这是为什么？？让我们读一下文档：
从python 2.4开始的键函数，list.sort（）和sorted（）都添加了一个键参数，以指定在进行比较之前对每个列表元素调用的函数。
我们必须在这两行之间做一些阅读，但这告诉我们sort函数只被调用一次，如果我们指定key参数，那么我们就按照key函数指向的值进行排序。
那么，使用模返回的示例是什么呢？布尔值： True == 1 , False == 0 . 那么排序如何处理这个键呢？它基本上将原始列表转换为1和0的序列。 [3, 6, 3, 2, 4, 8, 23] 变成 [0, 1, 0, 1, 1, 1, 0] 现在我们有进展了。对转换后的列表进行排序时会得到什么？ [0, 0, 0, 1, 1, 1, 1] 好了，现在我们知道为什么胜算会在最后一刻到来。但下一个问题是：为什么在我的最终列表中，6仍然排在2之前？这很容易，因为排序只发生一次！这些1仍然表示原始列表值，它们彼此之间处于原始位置。由于排序只发生一次，并且我们不调用任何类型的排序函数来将原始偶数从低到高排序，因此这些值保持其相对于彼此的原始顺序。
最后一个问题是：在打印最终排序列表时，我如何从概念上考虑布尔值的顺序如何转换回原始值？
sorted（）是一个内置方法，它（有趣的事实）使用了一个名为timsort的混合排序算法，该算法结合了合并排序和插入排序的各个方面。我很清楚，当你调用它时，有一种机制将这些值保存在内存中，并将它们与由（…！）确定的布尔标识（掩码）捆绑在一起lambda函数。顺序由lambda函数计算出的布尔标识确定，但请记住，这些子列表（1和0）本身并不是按其原始值排序的。因此，最终列表虽然按赔率和偶数排列，但不按子列表排序（本例中的偶数是无序的）。事实上，赔率是有序的，因为它们在最初的列表中已经是巧合。所有这些的好处是，当lambda进行转换时，子列表的原始顺序将保留。
那么，这一切与最初的问题有什么关系呢？更重要的是，我们的直觉告诉我们应该如何使用sorted（）的关键参数和lambda实现sorted（）？
lambda函数可以被认为是一个指针，指向我们需要排序的值，无论它是一个指针，将值Map到lambda函数转换的布尔值，还是它是嵌套列表、元组、dict等中的一个特定元素，同样由lambda函数确定。
让我们试着预测当我运行下面的代码时会发生什么。

In [9]: mylist = [(3, 5, 8), (6, 2, 8), (2, 9, 4), (6, 8, 5)]
In[10]: sorted(mylist, key=lambda x: x[1])

我的 sorted 电话显然是说，“请把这个列表分类”。关键论点通过说‘对于每个元素’，使这一点更加具体 x 在里面 mylist ，返回该元素的第二个索引，然后对原始列表中的所有元素进行排序 mylist 由lambda函数计算的列表的排序顺序。因为我们有一个元组列表，所以可以使用lambda函数从该元组返回一个索引元素。
用于排序的指针为：

[5, 2, 9, 8] # the second element of each tuple

对该指针列表排序将返回：

[2, 5, 8, 9]

将此应用于 mylist ，我们得到：

Out[10]: [(6, 2, 8), (3, 5, 8), (6, 8, 5), (2, 9, 4)]

# Notice the sorted pointer list is the same as the second index of each tuple in this final list

运行该代码，您会发现这就是顺序。尝试使用此键函数对整数列表进行排序，您会发现代码中断（为什么？因为你不能索引一个整数（当然）。
这是一个冗长的解释，但我希望这有助于 sort 你对语言使用的直觉 lambda 函数-作为sorted（）中的关键参数，以及更高的值。

lambda 是用于生成匿名函数的python关键字。

>>> (lambda x: x+2)(3)
5

这个 variable 左边 : 是一个参数名。使用 variable 右边是使用参数。
意思几乎与以下内容完全相同：

def some_method(variable):
  return variable[0]

键为lambda的sorted（）函数用法的另一个示例。让我们考虑你有一个元组列表。在每个元组中，您都有一个汽车的品牌、型号和重量，您希望按品牌、型号或重量对这个元组列表进行排序。你可以用lambda来做。

cars = [('citroen', 'xsara', 1100), ('lincoln', 'navigator', 2000), ('bmw', 'x5', 1700)]

print(sorted(cars, key=lambda car: car[0]))
print(sorted(cars, key=lambda car: car[1]))
print(sorted(cars, key=lambda car: car[2]))

结果：

[('bmw', 'x5', '1700'), ('citroen', 'xsara', 1100), ('lincoln', 'navigator', 2000)]
[('lincoln', 'navigator', 2000), ('bmw', 'x5', '1700'), ('citroen', 'xsara', 1100)]
[('citroen', 'xsara', 1100), ('bmw', 'x5', 1700), ('lincoln', 'navigator', 2000)]

lambda 是一个匿名函数，而不是任意函数。接受的参数是您正在使用的变量，以及您正在对其进行排序的列。

简单且不耗时的回答，并提供与所问问题相关的示例，请遵循以下示例：

user = [{"name": "Dough", "age": 55}, 
            {"name": "Ben", "age": 44}, 
            {"name": "Citrus", "age": 33},
            {"name": "Abdullah", "age":22},
            ]
    print(sorted(user, key=lambda el: el["name"]))
    print(sorted(user, key= lambda y: y["age"]))

看看列表中的名字，它们以d、b、c和a开头。如果你注意到年龄，他们是55岁，44岁，33岁和22岁

print(sorted(user, key=lambda el: el["name"]))

结果致：

[{'name': 'Abdullah', 'age': 22}, 
{'name': 'Ben', 'age': 44}, 
{'name': 'Citrus', 'age': 33}, 
{'name': 'Dough', 'age': 55}]

对名称进行排序，因为我们按key=lambda el:el[“name”]对名称进行排序，然后名称按字母顺序返回。
第二个打印代码

print(sorted(user, key= lambda y: y["age"]))

结果:

[{'name': 'Abdullah', 'age': 22},
 {'name': 'Citrus', 'age': 33},
 {'name': 'Ben', 'age': 44}, 
 {'name': 'Dough', 'age': 55}]

按年龄排序，因此列表按年龄升序返回。
请尝试此代码以更好地理解。

因为lambda的用法是在 sorted() ，再看看这个https://wiki.python.org/moin/howto/sorting/#key_functions

换言之，键（可选）。要执行以决定顺序的函数。默认值为“无”），在排序函数中，需要一个函数，而您使用lambda。
要定义lambda，需要指定要排序的对象属性，python内置的排序函数将自动处理该属性。
如果要按多个属性进行排序，请指定key=lambda x:（property1，property2）。
要指定order by，请将pass reverse=true作为第三个参数（可选）。布尔值。false将按升序排序，true将按降序排序。排序函数的默认值为false）。

另一种用法 lambda 及 sorted