max的强简化版本:

def max(items, key=lambda x: x):
    current = item[0]
    for item in items:
        if key(item) > key(current):
            current = item
    return current

关于λ:

>>> ident = lambda x: x
>>> ident(3)
3
>>> ident(5)
5

>>> times_two = lambda x: 2*x
>>> times_two(2)
4

Max是一个内置函数，第一个参数为可迭代对象(如list或tuple)

关键字参数key有它的默认值None，但它接受函数求值，将其视为包装器，基于函数求值iterable

考虑这个例子字典:

d = {'aim':99, 'aid': 45, 'axe': 59, 'big': 9, 'short': 995, 'sin':12, 'sword':1, 'friend':1000, 'artwork':23}

Ex:

>>> max(d.keys())
'sword'

正如你所看到的，如果你只传递可迭代对象而不传递kwarg(key的函数)，它将返回key的最大值(按字母顺序)

前女友。 而不是按字母顺序查找键的最大值，您可能需要根据键的长度查找最大键:

>>>max(d.keys(), key=lambda x: len(x))
'artwork'

在这个例子中，lambda函数返回键的长度，它将被迭代，因此在计算值时，而不是按照字母顺序考虑，它将跟踪键的最大长度，并返回具有最大长度的键

Ex.

>>> max(d.keys(), key=lambda x: d[x])
'friend'

在本例中，lambda函数返回对应的字典键值，该键值最大

max的强简化版本:

def max(items, key=lambda x: x):
    current = item[0]
    for item in items:
        if key(item) > key(current):
            current = item
    return current

关于λ:

>>> ident = lambda x: x
>>> ident(3)
3
>>> ident(5)
5

>>> times_two = lambda x: 2*x
>>> times_two(2)
4

根据文档:

max(iterable[, key]) max(arg1, arg2, *args[, key]) Return the largest item in an iterable or the largest of two or more arguments. If one positional argument is provided, iterable must be a non-empty iterable (such as a non-empty string, tuple or list). The largest item in the iterable is returned. If two or more positional arguments are provided, the largest of the positional arguments is returned. The optional key argument specifies a one-argument ordering function like that used for list.sort(). The key argument, if supplied, must be in keyword form (for example, max(a,b,c,key=func)).

这就是说，在你的例子中，你提供了一个列表，在这个例子中是玩家。然后max函数将遍历列表中的所有项，并将它们相互比较以获得“最大值”。

可以想象，对于像玩家这样的复杂对象，确定其比较值是很棘手的，所以你会得到一个关键参数，以确定max函数如何决定每个玩家的值。在本例中，你使用lambda函数表示“对于每个p名玩家，获取p.totalscore并将其作为其比较值”。

Lambda是一个匿名函数，它相当于:

def func(p):
   return p.totalScore     

现在max变成:

max(players, key=func)

但由于def语句是复合语句，它们不能用于需要表达式的地方，这就是为什么有时会使用lambda的原因。

注意，lambda等价于你在def的return语句中放入的内容。因此，你不能在lambda中使用语句，只允许使用表达式。

---

max是做什么的?

Max (a, b, c，…[， key=func]) ->值 使用单个iterable参数，返回其最大的项。用两个或 更多参数，返回最大的参数。

因此，它只是返回最大的对象。

---

密钥是如何工作的?

在Python 2中，默认情况下，key根据一组基于对象类型的规则来比较项(例如字符串总是大于整数)。

要在比较之前修改对象，或者基于特定的属性/索引进行比较，必须使用key参数。

示例1:

举个简单的例子，假设您有一个字符串形式的数字列表，但是您想通过它们的整数值来比较这些项。

>>> lis = ['1', '100', '111', '2']

这里max使用它们的原始值来比较项目(字符串是按字典顺序进行比较的，所以你会得到'2'作为输出):

>>> max(lis)
'2'

使用key和简单的lambda来比较项目的整数值:

>>> max(lis, key=lambda x:int(x))  # compare `int` version of each item
'111'

例2:对元组列表应用max。

>>> lis = [(1,'a'), (3,'c'), (4,'e'), (-1,'z')]

默认情况下，max将比较第一个索引项。如果第一个索引相同，那么它会比较第二个索引。在我的例子中，所有的项目都有一个唯一的第一个索引，所以你会得到这样的答案:

>>> max(lis)
(4, 'e')

但是，如果你想通过索引1的值来比较每一项呢?简单:使用lambda:

>>> max(lis, key = lambda x: x[1])
(-1, 'z')

---

比较迭代对象中包含不同类型对象的项:

包含混合项目的列表:

lis = ['1','100','111','2', 2, 2.57]

在Python 2中，可以比较两种不同类型的项:

>>> max(lis)  # works in Python 2
'2'
>>> max(lis, key=lambda x: int(x))  # compare integer version of each item
'111'

但在Python 3中，你不能再这样做了:

>>> lis = ['1', '100', '111', '2', 2, 2.57]
>>> max(lis)
Traceback (most recent call last):
  File "<ipython-input-2-0ce0a02693e4>", line 1, in <module>
    max(lis)
TypeError: unorderable types: int() > str()

但这是可行的，因为我们比较的是每个对象的整数版本:

>>> max(lis, key=lambda x: int(x))  # or simply `max(lis, key=int)`
'111'

最大函数是如何工作的?

它查找可迭代对象中“最大”的项。我假设你 可以查一下那是什么，如果没有，你可以循环， 例如，一个列表或字符串。

在max函数中关键字键的使用是什么?我知道它也用在排序函数的上下文中

Key是一个lambda函数，它将告诉max可迭代对象中哪些对象比其他对象大。假设你在对你自己创建的某个对象排序，而不是一些明显的，比如整数。

lambda表达式的含义?如何阅读?它们是如何工作的?

这是个更大的问题。简单来说，lambda是一个可以传递的函数，并让其他代码段使用它。举个例子:

def sum(a, b, f):
    return (f(a) + f(b))

这需要两个对象，a和b，和一个函数f。 它对每个对象调用f()，然后将它们相加。看看这段对话:

>>> sum(2, 2, lambda a:  a * 2)
8

Sum()接受2，并调用其中的lambda表达式。f(a)等于2 * 2，等于4。然后对b做同样的运算，将两者相加。

用不那么简单的术语来说，lambda来自lambda微积分，它是一个函数返回另一个函数的思想;一个用来表达计算的很酷的数学概念。你可以在这里读到，然后在这里真正理解它。

可能最好多读一点这方面的内容，因为lambda可能会令人困惑，而且不能立即看出它们有多有用。检查在这里。