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的强简化版本:

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函数中关键字键的使用是什么?我知道它也用在排序函数的上下文中

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可能会令人困惑，而且不能立即看出它们有多有用。检查在这里。

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函数用于获取可迭代对象的最大值。

迭代器可以是列表、元组、字典对象等。或者甚至像您提供的示例中那样自定义对象。

max(iterable[, key=func]) -> value
max(a, b, c, ...[, key=func]) -> value

With a single iterable argument, return its largest item.
With two or more arguments, return the largest argument.

因此，key=func基本上允许我们将一个可选参数key传递给函数，其基础是给定的迭代器/参数被排序并返回最大值。

Lambda是一个python关键字，充当伪函数。当你传递playerobject给它时，它会返回player。totalscore。因此，传递给max函数的可迭代对象将根据给予它的玩家对象的关键totalScore进行排序&将返回totalScore最大的玩家。

如果没有提供key参数，则根据默认的Python顺序返回最大值。

的例子,

max(1, 3, 5, 7)
>>>7
max([1, 3, 5, 7])
>>>7

people = [('Barack', 'Obama'), ('Oprah', 'Winfrey'), ('Mahatma', 'Gandhi')]
max(people, key=lambda x: x[1])
>>>('Oprah', 'Winfrey')

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函数返回对应的字典键值，该键值最大