6

在 Python 2.2（不要问）中，对列表进行排序和删除重复项的最简洁方法是什么？

我显然可以编写一个sort()然后迭代的函数，但我想知道是否有一个惯用的单线。

编辑：列表很短，所以效率不是问题。此外，元素是不可变的。

4

4 回答 4

7

对于旧的 python 版本，并且由于您使用的是字符串，所以我无法想到单线，但是使用字典的模式可能是这样的：

def sorted_uniq(your_list):
    table = {}
    for s in your_list:
        table[s] = None
    k = table.keys()
    k.sort()
    return k

改编自 Alex Martelli 自己写了几条评论的古老 ActiveState 代码片段线程：http: //code.activestate.com/recipes/52560/

列表推导的更短方法：

def sort_uniq(alist):
   d = {}
   mod_list = [d.setdefault(i,i) for i in alist if i not in d]
   mod_list.sort()
   return mod_list

除了 Steven 的简洁（但有点不吸引人）的一个衬里，我认为这朝着使用 Python 2.2 的最少行和最惯用的方式前进：

感谢评论中的 Steven Rumbalski，第二个版本可以用 python 的zip函数进一步压缩：

def sort_uniq(alist):
   mod_list = dict(zip(alist,alist)).keys()
   mod_list.sort()
   return mod_list

如果list.sort()没有副作用，我们将有一个班轮。;)

于 2011-10-14T17:06:26.210 回答
5

惯用语和单线？不。

这是一个非惯用的对接丑陋的单线。

>>> x = [4, 3, 3, 2, 4, 1]
>>> [y for y in (locals().__setitem__('d',{}) or x.sort() or x) 
        if y not in d and (d.__setitem__(y, None) or True)]
[1, 2, 3, 4]

如果可以接受简单的两线：

x = [4, 3, 3, 2, 4, 1]
x = dict(map(None,x,[])).keys()
x.sort()

或者制作两个小辅助函数（适用于任何序列）：

def unique(it):
    return dict(map(None,it,[])).keys()

def sorted(it):
    alist = [item for item in it]
    alist.sort()
    return alist

print sorted(unique([4, 3, 3, 2, 4, 1]))

给

[1, 2, 3, 4]

最后，一个半蟒蛇式的衬里：

x = [4, 3, 3, 2, 4, 1]
x.sort() or [s for s, t in zip(x, x[1:] + [None]) if s != t]
于 2011-10-14T17:15:12.433 回答
2

作为记录，Python 2.2确实有集合，但在“集合”模块下，所以这会让你走很长一段路：

from sets import Set
myList = list(Set(myList))
# now we're duplicate-free, a standard sorting might be enough
myList.sort()
于 2013-10-20T23:54:14.300 回答
0

可能最好的答案是使用二叉树：

# Make yield work in Python 2.2
from __future__ import generators

class TreeNode(object):
    def __init__(self, value):
        self.left = None
        self.right = None
        self.value = value

    def add(self, value):
        if value == self.value:
            return
        if value < self.value:
            if self.left is None:
                self.left = TreeNode(value)
            else:
                self.left.add(value)
        else:
            if self.right is None:
                self.right = TreeNode(value)
            else:
                self.right.add(value)

    def __iter__(self):
        if self.left is not None:
            for value in self.left:
                yield value
        yield self.value
        if self.right is not None:
            for value in self.right:
                yield value

class DedupeSorter(object):
    def __init__(self):
        self.root = None

    def add(self, value):
        if self.root is None:
            self.root = TreeNode(value)
        else:
            self.root.add(value)

    def __iter__(self):
        if self.root is None:
            return []
        else:
            return self.root.__iter__()

def dedupe_and_sort(l):
    sorter = DedupeSorter()
    for value in l:
        sorter.add(value)
    return list(sorter)

绝对不是惯用的，但应该很快。它基本上创建了一个基于树的集合并对其进行迭代。我没有 Python 2.2，所以希望它可以工作：p

于 2011-10-14T17:01:56.103 回答