Question

我是Python的新手，我目前正在解决问题，以提高我的编码技能。我遇到了一个问题，即我在List中找到最大值，而在其他List中的值与最大值的index相同。

例如：我有两个Lists，其值L1 = [9, 12, 9 ,6]和L2 = [2, 3, 4, 5] 我必须在List L1中找到最大值，并且应在List L2中使用最大值的索引来查找它的相应值。

Max value in List L1 - 12
Index of the max value - 1
print L2[1] -> 3

为了实现上述逻辑，我重新搜索了一个方法并获得了它。但我无法理解逻辑是如何工作的。

import operator   
index, value = max(enumerate(l1), key=operator.itemgetter(1))
print value, 
print l2[index]

输出：12 3

为了理解上述功能是如何工作的，我尝试分别打印每个部分，但仍然无法理解逻辑是如何工作的。

print l1 - [9, 12, 9 , 6]
print l2 - [2, 3, 4, 5]
print list(enumerate(l1)) - [<0, 9>, <1, 12>, <2, 9>, <3, 6>]
print list(enumerate(l2)) - [<0, 2>, <1, 3>, <2, 4>, <3, 5>]
print max(enumerate(l1)) - <3, 6>
print max(enumerate(l2)) - <3, 5>

请帮助我了解enumerate函数和key=operator.itemgetter(1))[0]在上述逻辑中的工作原理。提前致谢。非常感谢您的帮助。

Answer 1

对于输入可迭代中的每个项，

enumerate()只生成具有原始值加索引的元组，顺序为(index, item)。请参阅 What does enumerate mean?

给定一个键，

max()从序列中选出最大值。默认关键是使用值本身，但使用operator.itemgetter(1)时，您告诉max()仅关注每个输入项的第二个值。

您可以轻松地使用此选项来查看max()始终从列表中返回原始值，但会更改使用key函数时返回的值。您可以使用任何功能，包括使用lambda创建的功能：

>>> L1 = [9, 12, 9, 6]
>>> max(L1)  # straight up, biggest value in the list
12
>>> max(L1, key=lambda v: len(str(v)))  # value with the most digits, 12 has two digits
12
>>> max(L1, key=lambda v: abs(v - 10))  # value furthest from 10; 6 is the furthest
6

当您使用至少一个参数调用operator.itemgetter()时，它将生成一个在使用序列调用时的对象，将使用参数作为索引序列。 operator.itemgetter(1)创建一个总是选择 second 元素的对象（Python从0开始计数），operator.itemgetter(2)每次调用它时都会返回第3个元素：< / p>

>>> from operator import itemgetter
>>> ig2 = itemgetter(2)
>>> ig2
operator.itemgetter(2)
>>> ig2(L1)  # the 3rd element in L1 is 9
9

鉴于enumerate()将原始值放在它产生的每个元组的第二个位置，max()根据原始输入列表中的值从元组序列中选择最大值。它会保持enumerate()生成的元组完整无缺。

如果您省略key，则会获得最大的＆＃39;元组＆＃39 ;;元组由包含的第一个元素进行比较，这是不同的。因此，(1, 2)大于(1, 0)，因为第二个元素2大于0。但(2, 1)大于(1, 1)，因为第一个元素不同，2更大。由于enumerate()添加了越来越多的索引（从0开始），这意味着max()没有key将始终选择 last 元素：

>>> max(enumerate(l1))  # last element is (3, 6)
(3, 6)

选择该元素是因为3是最高指数。

请注意，使用enumerate()在此处过度。您可以使用zip() function配对L1和L2代替：

l1max, corresponding_l2 = max(zip(L1, L2))

zip()将L1和L2的元素配对，生成(9, 2)，(12, 3)等元组。max()选择最大的元组该序列中的元组，首先查看第一个元素（取自L1）。

Answer 2

enumerate创建一个生成器函数，可以有效地将值列表转换为元组列表。

L1 = [9, 12, 9, 6]

变为

[(0, 9), (1, 12), (2, 9), (3, 6)]

max函数查找该列表中的最大值。如果没有向max提供其他参数，则会将tuples与其他参数进行比较，此项目将是最大值 - (3, 6)。但这不是我们想要的。我们不希望它在比较中使用enumerate号码。

max接受一个key参数，该参数应该是一个带有一个参数的函数，该参数将是列表中的值，并且应该返回一个值，该值将用于对列表进行排序，选择最大值。在这种情况下，我们希望根据每个元组中的第二个数字（即6中的(3, 6)）对列表进行排序。

operator.itemgetter是一个函数，它返回一个函数，该函数将返回它所调用的事物的索引项。例如：

L1 = [3, 4, 6, 2]
f = operator.itemgetter(0)
f(L1)
# 3

f = operator.itemgetter(2)
f(L1)
# 6

在这种情况下，它使用operator.itemgetter(1)，它将返回6中的(3, 6)

因此，我们从max(enumerate(l1), key=operator.itemgetter(1))获得的结果是tuple，其中包含最大值的索引和L1中的最大值。

Answer 3

来自帮助：

有关内置模块内置函数max的帮助：

MAX（...）       max（iterable，* [，default = obj，key = func]） - ＆gt;值       max（arg1，arg2，* args，* [，key = func]） - ＆gt;值
#include <stdio.h>

static int* createData() 
{
    int test[4];
    int c;
    int *ptr;

    printf("Indtast 4 tal, 1 af gangen");
    for (c = 0; c < 4; c++)
    {
        scanf("%d", &test[c]);     
    }

    ptr=&test;
    return (ptr);
}

static void udskriv(int* ptr)
{
    int i;
    for (i=0;i<4;i++)
    {
        printf("%d\n",*ptr++);
    }   
}

int main(void)
{
    udskriv(createData());
}

和

模块运算符中类itemgetter的帮助：

class itemgetter（builtins.object）| itemgetter（item，...） - ＆gt;   itemgetter对象| |返回一个可获取的可调用对象   从其操作数给出项目。 |在f = itemgetter（2）之后，调用   f（r）返回r [2]。 |在g = itemgetter（2,5,3）之后，调用g（r）   返回（r [2]，r [5]，r [3]）

因此，itemgetter执行其名称所说的内容：它从中获取指定的项目列表的元素。在这种情况下，第二个元素（索引为1的那些元素）。这就是你要做的：

您在枚举时生成的输出上调用max：

With a single iterable argument, return its biggest item. The
default keyword-only argument specifies an object to return if
the provided iterable is empty.
With two or more arguments, return the largest argument.

并告诉它根据以下定义的键确定最大值：

[<0, 9>, <1, 12>, <2, 9>, <3, 6>]

即列表中每个元素的第二个值。然后最大值返回它找到的元素，其形式（索引，值）。

Answer 4

@Dev：Enumerate函数只打印列表及其索引值和键是你想要操作的数据结构，请找到下面的代码

index, value = min(enumerate(l1), key=operator.itemgetter(1))
print value
6
print index
3
index, value = max(enumerate(l1), key=operator.itemgetter(1))
print index
1
print value
12
sorted(enumerate(l1), key=operator.itemgetter(1))
[(3, 6), (0, 9), (2, 9), (1, 12)]
sorted(enumerate(l1), key=operator.itemgetter(0))
[(0, 9), (1, 12), (2, 9), (3, 6)]

在Python中使用枚举工作

4 个答案: