Python：包含元组的排序列表

我仍在学习Python，数小时来我一直在尝试解决这个问题，但不知何故无法让它正常工作： 假设我们有一个包含名称和等级的元组列表：

[("Mark", [5,4,1,2,4,3]), ("John", [1,2,3,1,2,1]), ("Patrick", [1,3,5,1,2,4])]

我们想要得到这个输出：

[("John", [1,2,3,1,2,1]), ("Patrick", [1,3,5,1,2,4]), ("Mark", [5,4,1,2,4,3])]

，其中原始列表按学生分数的升序排序，假设我们通过丢弃最高分数并将所有剩余分数相加得到分数。 也就是说，John有标记1,2,3,1,2,1，所以我们放弃标记3，将1+2+1+2+1加在一起，得到7

如果我不需要得到他们所有原始标记的输出，这个任务就不会有任何问题。我写了这个函数：

def sortedFinalRes(input):
finalRes = 0
sortedRes = []
b = []
for i in range(0, len(input)):
    total = 0
    a = sorted(input[i][1], key = lambda x: x)
    a.pop()
    sortedRes += input[i][0], a
    total = sum(sortedRes[i*2+1])
    b += (sortedRes[i*2], total)
    c = sorted(b, key = lambda x: str(x))
print(sortedRes)
print(b)

，我基本上是首先对每个学生的分数进行排序，这样我就可以通过使用pop丢弃最高的一个，然后我将所有剩余的分数相加，从而得到分数。然后我根据分数对它进行排序，但是输出需要排序，但是使用原始分数，而不是分数。

---

任何想法都值得赞赏！干杯

我们可以定义这样的评分函数：

def score(x): sum(x) - max(x)       

这会计算出你所谓的分数，把分数加起来，去掉最大分数。然后，我们将使用它作为排序键，确保为其指定元组的第二个元素：

In [4]: sorted(d, key=lambda x: score(x[1]))                                                                                                                 
Out[4]: 
[('John', [1, 2, 3, 1, 2, 1]),
 ('Patrick', [1, 3, 5, 1, 2, 4]),
 ('Mark', [5, 4, 1, 2, 4, 3])]

---

我们可以定义如下的评分函数：

def score(x): sum(x) - max(x)       

这会计算出你所谓的分数，把分数加起来，去掉最大分数。然后，我们将使用它作为排序键，确保为其指定元组的第二个元素：

In [4]: sorted(d, key=lambda x: score(x[1]))                                                                                                                 
Out[4]: 
[('John', [1, 2, 3, 1, 2, 1]),
 ('Patrick', [1, 3, 5, 1, 2, 4]),
 ('Mark', [5, 4, 1, 2, 4, 3])]

您可以很容易地用一个lambda完成它，如下所示。。。我这样做只是为了增加冗长

---

您可以很容易地用一个lambda完成它，如下所示。。。我这样做只是为了增加详细性

您可以通过sortedx[1][：-1]从最大值拒绝，它首先对列表进行排序，并从开始到最高进行切片：

>>> sorted (l,key=lambda x : sum(sorted(x[1])[:-1]))
[('John', [1, 2, 3, 1, 2, 1]), ('Patrick', [1, 3, 5, 1, 2, 4]), ('Mark', [5, 4, 1, 2, 4, 3])]

答案基准：

>>> s="""l=[("Mark", [5,4,1,2,4,3]), ("John", [1,2,3,1,2,1]), ("Patrick", [1,3,5,1,2,4])]
... sorted (l,key=lambda x : sum(sorted(x[1])[:-1]))"""
>>> timeit.timeit(stmt=s, number=100000)
0.407818078994751

>>> s="""l=[("Mark", [5,4,1,2,4,3]), ("John", [1,2,3,1,2,1]), ("Patrick", [1,3,5,1,2,4])]
... sorted(l, key=lambda x: sum(x[1]) - max(x[1]))"""
>>> timeit.timeit(stmt=s, number=100000)
0.3033828830718994

>>> s="""l=[("Mark", [5,4,1,2,4,3]), ("John", [1,2,3,1,2,1]), ("Patrick", [1,3,5,1,2,4])]
... def sort_key(item):
...     name,scores = item
...     return sum(scores)-max(scores)
... sorted(l,key=sort_key)"""
>>> timeit.timeit(stmt=s, number=100000)
0.2999439334869385

---

正如你所看到的，所有答案之间没有太大区别，无论如何，乔兰·比斯利的答案是最好的

您可以通过sortedx[1][：-1]拒绝从最大值开始，该命令首先对列表进行排序，并从开始到最高进行切片：

>>> sorted (l,key=lambda x : sum(sorted(x[1])[:-1]))
[('John', [1, 2, 3, 1, 2, 1]), ('Patrick', [1, 3, 5, 1, 2, 4]), ('Mark', [5, 4, 1, 2, 4, 3])]

答案基准：

>>> s="""l=[("Mark", [5,4,1,2,4,3]), ("John", [1,2,3,1,2,1]), ("Patrick", [1,3,5,1,2,4])]
... sorted (l,key=lambda x : sum(sorted(x[1])[:-1]))"""
>>> timeit.timeit(stmt=s, number=100000)
0.407818078994751

>>> s="""l=[("Mark", [5,4,1,2,4,3]), ("John", [1,2,3,1,2,1]), ("Patrick", [1,3,5,1,2,4])]
... sorted(l, key=lambda x: sum(x[1]) - max(x[1]))"""
>>> timeit.timeit(stmt=s, number=100000)
0.3033828830718994

>>> s="""l=[("Mark", [5,4,1,2,4,3]), ("John", [1,2,3,1,2,1]), ("Patrick", [1,3,5,1,2,4])]
... def sort_key(item):
...     name,scores = item
...     return sum(scores)-max(scores)
... sorted(l,key=sort_key)"""
>>> timeit.timeit(stmt=s, number=100000)
0.2999439334869385

---

正如你所看到的，所有答案之间没有太大区别，无论如何，乔兰·比斯利的答案是最好的

回答得很好，就在我面前偷偷地说：为什么是双羔羊？不应将lambda分配给变量，因为它忽略了要点。sortedd，key=lambda x:sumx-maxx如何？@tdelaney-sortedd，key=lambda x:sumx[1]-maxx[1]。x将是列表中的元组。但总的来说这是个好主意。@JoranBeasley-哎呀，我应该仔细看看！回答得很好，就在我面前偷偷地说：为什么是双羔羊？不应将lambda分配给变量，因为它忽略了要点。sortedd，key=lambda x:sumx-maxx如何？@tdelaney-sortedd，key=lambda x:sumx[1]-maxx[1]。x将是列表中的元组。但总的来说这是个好主意。@JoranBeasley-哎呀，我应该仔细看看！这实际上是nlogn，而另一种解决方案是nlognn@1_CR你认为使用max-inside排序有n个顺序吗？实际上，如果n是外部列表的大小，m是内部列表的大小，那么这个解决方案是在m log m+n log n上，而使用max的解决方案是Onm+n log n，我相信。@PadraicCunningham实际上是指它的键！但无论如何，我相信秩序是不正确的n@PadraicCunningham关键函数sumx-maxx需要时间Om，其中m是分数列表的大小。我们必须为n个条目中的每个条目评估键函数，给出Omn。然后我们需要对n个键进行排序，添加登录n。这实际上是nlogn，而另一个解决方案是n@1_CR你怎么认为使用max-inside-sorted有n个顺序？实际上，如果n是外部列表的大小，m是内部列表的大小，这个解决方案在m log m+n log n上，而使用max的解决方案是Onm+n log n，我相信。@PadraicCunningham实际上我指的是它的钥匙！但无论如何，我相信秩序是不正确的n@PadraicCunningham关键函数sumx-maxx需要时间Om，其中m是分数列表的大小。我们必须为n个条目中的每个条目评估键函数，给出Omn。然后我们需要对n个键进行排序，在日志n上添加。