在Python 2.2中对列表进行重复数据消除和排序

在Python2.2（不要问）中，排序列表并删除重复项的最简洁方法是什么

显然，我可以编写一个函数，该函数将

sort（）

然后进行迭代，但我想知道是否有一个惯用的单行程序

>>> 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]

---

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

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

# 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)

#让yield在Python 2.2中工作
从未来导入生成器
类树节点（对象）：
定义初始值（自身，值）：
self.left=无
self.right=无
自我价值=价值
def添加（自身、价值）：
如果value==self.value：
返回
如果值

---

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

对于旧的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代码片段线程：

列表理解的简短方式：

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（）

没有副作用，我们就只有一行了

习惯用语和一行吗？没有

这是一个非惯用的屁股丑陋的一行

>>> 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()

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

给予

最后，一个半蟒蛇式的一行：

x = [4, 3, 3, 2, 4, 1]
x.sort() or [s for s, t in zip(x, x[1:] + [None]) if s != t]

---

作为记录，Python 2.2确实有集合，但在“集合”模块下，这将为您带来很多好处：

from sets import Set
myList = list(Set(myList))
# now we're duplicate-free, a standard sorting might be enough
myList.sort()

---

我记不起

set

模块是否在2.2中。如果是，

set（myList）

将删除所有重复项。@g.d.d.c:已选中，

set

为2.3+。啊。有没有可能它会出现在那个版本的

\uuuuuuuuuuuuuuuuuuuuuuuuuuu

中？这些值是可散列的吗？未来的回答者可能会发现，检查他们的解决方案所依赖的语言功能是否实际存在是有用的。下面是python 2.2的集合配方。这也是我提出的。我一直在想一个聪明的方法来将它封装为一行程序，但是我不能。我不想成为一个麻烦，但是

sorted（）

是Python2.4+。很容易替换为

sort（）

。@aix-是的，我想知道

sorted

是否在2.2中，但文档没有这样说-切换到调用

table.keys（）

。在第二个版本中，您可以不用引用中间dict，而使用

mod_list=dictalist（zip（alist，alist））.keys（）

@birryrree:我非常喜欢它，所以在我的答案中添加了一个修改过的版本。我喜欢新的函数，使代码可以很容易地放入较新版本的python中。+1因为这与较新版本的python的内置功能非常接近：

list（set（myList））

--如果出于某种奇怪的原因，您想，您可以使其与“从集合导入集合为集合”中的“代码”相同

from sets import Set
myList = list(Set(myList))
# now we're duplicate-free, a standard sorting might be enough
myList.sort()