3

我需要在 Python 中对以下元组列表进行排序：

ListOfTuples = [('10', '2010 Jan 1;', 'Rapoport AM', 'Role of antiepileptic drugs as preventive agents for migraine', '20030417'), ('21', '2009 Nov;', 'Johannessen SI', 'Antiepilepticdrugs in epilepsy and other disorders--a population-based study of prescriptions', '19679449'),...]

我的目的是按降序年份（listOfTuples[2]）和升序作者（listOfTuples[2]）排序：

sorted(result, key = lambda item: (item[1], item[2]))

但它不起作用。我怎样才能获得排序稳定性？

4

5 回答 5

4 
def descyear_ascauth(atup):
  datestr = atup[1]
  authstr = atup[2]
  year = int(datestr.split(None, 1)[0])
  return -year, authstr

... sorted(result, key=descyear_ascauth) ...

注意：您需要将年份提取为整数（而不是字符串），以便您可以更改其符号——后者是满足规范的“降序”部分的关键技巧。将所有内容都压缩在 alambda中是可能的，但是绝对没有理由这样做并牺牲更多的可读性，当 adef也可以正常工作（并且更具可读性）时。

于 2010-07-24T15:07:52.413 回答
2

最简单的方法是分别对每个键值进行排序。从最不重要的键开始，一直到最重要的键。

所以在这种情况下：

import operator
ListOfTuples.sort(key=operator.itemgetter(2))
ListOfTuples.sort(key=lambda x: x[1][:4], reverse=True)

这是有效的，因为即使您使用 reverse 标志，Python 的排序始终是稳定的：即 reverse 不只是排序然后反转（这会失去稳定性，它会在反转后保持稳定性。

当然，如果您有很多关键列，这可能会效率低下，因为它会进行多次完整排序。

您不必以这种方式将年份转换为数字，因为它是真正的反向排序，但如果您愿意，您可以这样做。

于 2010-07-24T15:43:31.087 回答
0

这是一个适用于所有事物的成语，即使是您无法否定的事物，例如字符串：

data = [ ('a', 'a'), ('a', 'b'), ('b','a') ]

def sort_func( a, b ):
    # compare tuples with the 2nd entry switched
    # this inverts the sorting on the 2nd entry
    return cmp( (a[0], b[1]), (b[0], a[1]) ) 

print sorted( data )                    # [('a', 'a'), ('a', 'b'), ('b', 'a')]
print sorted( data, cmp=sort_func )     # [('a', 'b'), ('a', 'a'), ('b', 'a')]
于 2010-07-24T15:42:36.000 回答
0

这是一个粗略的解决方案，需要考虑月份缩写和日期（如果找到）：

import time
import operator

def sortkey(seq):
    strdate, author = seq[1], seq[2]
    spdate = strdate[:-1].split()
    month = time.strptime(spdate[1], "%b").tm_mon
    date = [int(spdate[0]), month] + map(int, spdate[2:])
    return map(operator.neg, date), author  

print sorted(result, key=sortkey)

"%b" 是语言环境的月份缩写名称，如果您不想处理语言环境，可以使用字典。

于 2010-07-24T15:50:33.970 回答
0

这是亚历克斯答案的 lambda 版本。我认为它现在看起来比邓肯的答案更紧凑，但显然亚历克斯的答案的很多可读性已经丢失。

sorted(ListOfTuples, key=lambda atup: (-int(atup[1].split(None, 1)[0]), atup[2]))

可读性和效率通常应该优先于紧凑性。

于 2010-07-25T10:07:38.493 回答