使用’key’和lambda表达式的python max函数


python max function using 'key' and lambda expression

我来自OOP背景，尝试学习Python。我使用的是max函数，该函数使用lambda表达式返回Player类型的实例，其中players列表中的totalScore最大。

1
2
def winner():
    w = max(players, key=lambda p: p.totalScore)

函数正确返回具有最大totalScore的Player类型的实例。我对以下三件事感到困惑：

  • max功能如何工作？它的论点是什么？我看了文件，但不明白。
  • 关键字key在max函数中的用途是什么？我知道它也用于sort函数的上下文中。
  • lambda表达式的含义？如何阅读？它们是如何工作的？

    • 这些都是非常不寻常的概念性问题，但会帮助我理解语言。如果你能举出一些例子来解释，那会有帮助的。谢谢

    相关讨论

    lambda是一个匿名函数，相当于：

    1
    2
    def func(p):
       return p.totalScore

    现在，max变为：

    1
    max(players, key=func)

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

    注意，lambda相当于你在def的返回声明中所做的。因此，不能在lambda中使用语句，只允许使用表达式。

    max是做什么的？

    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是如何工作的？

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

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

    例1：

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

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

    这里，max使用其原始值比较项目(按字典方式比较字符串，这样您将得到'2'作为输出)：

    1
    2
    >>> max(lis)
    '2'

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

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

    例2：将max应用于列表。

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

    默认情况下，max将按第一个索引比较项目。如果第一个索引相同，那么它将比较第二个索引。在我的示例中，所有项都有一个唯一的第一个索引，因此您将得到以下答案：

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

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

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

    比较包含不同类型对象的iterable中的项：

    混合项目列表：

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

    在Python2中，可以比较两种不同类型的项：

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

    但在Python3中，您不能再这样做了：

    1
    2
    3
    4
    5
    6
    >>> 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()

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

    1
    2
    >>> max(lis, key=lambda x: int(x))  # or simply `max(lis, key=int)`
    '111'
    相关讨论

    How does the max function work?

    它在iterable中查找"最大"项。我假设你可以查到那是什么，但如果不是，那是你可以循环的东西，即列表或字符串。

    What is use of the keyword key in max function? I know it is also used in context of sort function

    Key是一个lambda函数，它将告诉max在iterable中哪些对象比其他对象大。比如说，如果你在排序你自己创建的对象，而不是一些明显的东西，比如整数。

    Meaning of the lambda expression? How to read them? How do they work?

    这是一个更大的问题。简单来说，lambda是一个可以传递的函数，其他代码也可以使用它。例如：

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

    这需要两个对象：a和b，以及一个函数f。它在每个对象上调用f()，然后将它们相加。所以看看这个电话：

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

    sum()接受2并在其上调用lambda表达式。因此，f(a)变成2 * 2，变成4。然后，它对b执行此操作，并将两者相加。

    用不那么简单的术语来说，lambda来自lambda演算，它是一个返回函数的函数的概念；一个表示计算的非常酷的数学概念。你可以在这里读到，然后真正理解它。

    更多地阅读这篇文章可能会更好，因为lambda可能会让人困惑，而且它们的用处并不是很明显。请在这里查一下。

    max的强简化版本：

    1
    2
    3
    4
    5
    6
    def max(items, key=lambda x: x):
        current = item[0]
        for item in items:
            if key(item) > key(current):
                current = item
        return current

    关于lambda：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    >>> ident = lambda x: x
    >>> ident(3)
    3
    >>> ident(5)
    5

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

    max函数用于获取iterable的最大值。

    迭代器可以是列表、元组、dict对象等，甚至是您提供的示例中的自定义对象。

    1
    2
    3
    4
    5
    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关键字。所以，当你通过player号反对时，它会返回player.totalScore号。因此，传递给函数max的iterable将根据给定的player对象的Key总分进行排序&；将返回具有最大totalScore的player。

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

    实例-

    1
    2
    3
    4
    5
    6
    7
    8
    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(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)).

    这是说，在您的案例中，您提供了一个列表，在本例中是players。然后，max函数将遍历列表中的所有项，并相互比较，得到一个"最大值"。

    正如您所能想象的那样，对于一个复杂的对象，如player，确定它的比较值是很困难的，所以您可以使用key参数来确定max函数将如何决定每个player的值。在这种情况下，您使用lambda函数来表示"对于EDOCX1中的每个p，获取p.totalscore，并将其用作比较的值"。

    max是内置函数，它接受第一个参数iterable(如list或tuple)

    关键字参数Key有它的默认值None但是它接受函数来评估，把它当作包装器，根据函数来评估它是可评估的。

    考虑这个示例字典：

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

    前任：

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

    如您所见，如果只传递不带Kwarg的iterable(Key的函数)，则返回键的最大值(按字母顺序)。

    前任。您可能需要按键的长度查找最大键，而不是按字母顺序查找键的最大值：

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

    在本例中，lambda函数返回键的长度，该键将被迭代，因此在计算值时，它将跟踪键的最大长度，并返回键的最大长度。

    前任。

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

    在此示例中，lambda函数返回具有最大值的相应字典键的值