【Python 每日一技】元素去重并保证去重前后元素相对顺序不变

文章目录

• • 1 问题
  • 2. 解决方案
  • 3. 讨论

1 问题

你希望对序列中的元素进行去重，同时保证去重后的元素之间相对顺序不变。

2. 解决方案

如果序列中的元素是可哈希的（在 Python 中像字符串、整型、元组等不可变类型都是可哈希的），那么可以通过使用集合以及生成器来方便地实现该需求。例如：

>>> def dedupe(items):
...    seen = set()
...    for item in items:
...        if item not in seen:
...            yield item
...            seen.add(item)
            
>>> a = [1, 5, 2, 1, 9, 1, 5, 10]
>>> list(dedupe(a))
[1, 5, 2, 9, 10]

然而，上述解决方案只适用于序列中元素可哈希的情况，如果序列中的元素是不可哈希的，例如序列中的元素为字典，你只需要对上述解决方案稍加修改就可以实现相同的效果，即：

>>> def dedupe(items, key=None):
...    seen = set()
...    for item in items:
...        val = item if key is None else key(item)
...        if val not in seen:
...            yield item
...            seen.add(val)
            
>>> a = [
...    {
...        'x': 1,
...        'y': 2,
...    },
...    {
...        'x': 1,
...        'y': 3,
...    },
...    {
...        'x': 1,
...        'y': 2,
...    },
...    {
...        'x': 2,
...        'y': 4,
...    }
...]

>>>a
[{'x': 1, 'y': 2}, {'x': 1, 'y': 3}, {'x': 1, 'y': 2}, {'x': 2, 'y': 4}]

这里，形参 key 用于指定一个函数，该函数可以将序列中的元素转化为可哈希对象然后进行满足要求的去重操作，下面是上述解决方案的用法：

>>> list(dedupe(a, key=lambda d: (d['x'], d['y'])))
[{'x': 1, 'y': 2}, {'x': 1, 'y': 3}, {'x': 2, 'y': 4}]
>>> list(dedupe(a, key=lambda d: d['x']))
[{'x': 1, 'y': 2}, {'x': 2, 'y': 4}]

上述解决方案还可以实现基于单个数据域或者属性或者更多数据域进行满足要求的去重操作。

3. 讨论

实际上，如果你只是单单想实现元素去重，对于不可变元素，你可以直接使用集合，例如：

>>> a = [1, 5, 2, 1, 9, 1, 5, 10]
>>> set(a)
{1, 2, 5, 9, 10}

然而，如上所述，去重结果并不能保证元素之间相对顺序不变。

最后

以上就是疯狂啤酒最近收集整理的关于【Python 每日一技】元素去重并保证去重前后元素相对顺序不变的全部内容，更多相关【Python内容请搜索靠谱客的其他文章。