什么'；如果其中一个值不是唯一的，那么从dict列表中删除元素的python方法是什么？

对于某些键，删除非唯一性元素的pythonic方法是什么

假设一个人有一个口述清单，例如：

[
    {'a': 1, 'b': 'j'},
    {'a': 2, 'b': 'j'},
    {'a': 3, 'b': 'i'}
]

预期输出将删除第二个元素，因为键

b

在多个元素中等于

j

。因此：

[
    {'a': 1, 'b': 'j'},
    {'a': 3, 'b': 'i'}
]

这就是我尝试过的：

input = [
    {'a': 1, 'b': 'j'},
    {'a': 2, 'b': 'j'},
    {'a': 3, 'b': 'i'}
]

output = []
for input_element in input:
    if not output:
        output.append(input_element)
    else:
        for output_element in output:
            if input_element['b'] != output_element['b']:
                output.append(input_element)

---

如果是元组列表，解决方案会更简单吗，例如：

[(1, 'j'), (2, 'j'), (3, 'i')]

# to produce
[(1, 'j'), (3, 'i')]

---

下面是一种使用

any（）

和列表理解的方法：

代码：

l=[
    {'a': 1, 'b': 'j'},
    {'a': 2, 'b': 'j'},
    {'a': 3, 'b': 'i'}
]

new_l = []

for d in l:
    if any([d['b'] == x['b'] for x in new_l]):
        continue
    new_l.append(d)

print(new_l)

[{'a': 1, 'b': 'j'}, {'a': 3, 'b': 'i'}]

输出：

l=[
    {'a': 1, 'b': 'j'},
    {'a': 2, 'b': 'j'},
    {'a': 3, 'b': 'i'}
]

new_l = []

for d in l:
    if any([d['b'] == x['b'] for x in new_l]):
        continue
    new_l.append(d)

print(new_l)

[{'a': 1, 'b': 'j'}, {'a': 3, 'b': 'i'}]

像这样使用它：

drop_dup_key(in_list, lambda d: return d.get('b'))

---

元组与字典的比较并不十分准确，因为元组只包含字典值，而不包含键，而且我相信您询问的是重复的键：值对

这里有一个解决方案，我相信它解决了你的问题，但可能并没有像python一样好

seen=set（）
保留=[]
对于x中的d：
保持不变
对于d.项（）中的k，v：
如果（k，v）处于可见状态：
保留=错误
打破
见.添加（（k，v））
如果保留：
保留。附加（d）
打印（保留）

输出：

[{'a': 1, 'b': 'j'}, {'a': 3, 'b': 'i'}]

{MyTuple(a=3, b='i'), MyTuple(a=1, b='j')}
>>> 

---

您可以定义一个自定义容器类，该类实现了

\uuuueq\uuuuu

和

\uuuuuuuuuuuu散列\uuuuuu

魔术方法。这样，您可以使用

集
删除“重复项”（根据您的条件）。这不一定能维持秩序

from itertools import starmap
from typing import NamedTuple

class MyTuple(NamedTuple):
    a: int
    b: str

    def __eq__(self, other):
        return self.b == other.b

    def __hash__(self):
        return ord(self.b)


print(set(starmap(MyTuple, [(1, 'j'), (2, 'j'), (3, 'i')])))

输出：

[{'a': 1, 'b': 'j'}, {'a': 3, 'b': 'i'}]

{MyTuple(a=3, b='i'), MyTuple(a=1, b='j')}
>>> 

我建议采取以下措施：

_missing = object()
def dedupe(iterable, selector=_missing):
    "De-duplicate a sequence based on a selector"
    keys = set()
    if selector is _missing: selector = lambda e: e
    for e in iterable:
        if selector(e) in keys: continue
        keys.add(selector(e))
        yield e


优点：


返回一个生成器：

它只是懒洋洋地迭代原始集合一次。这可能是有用的
和/或在某些情况下执行，特别是如果您将
其他查询操作

input = [{'a': 1, 'b': 'j'}, {'a': 2, 'b': 'j'}, {'a': 3, 'b': 'i'}]
s = dedupe(input, lambda x: x['b'])
s = map(lambda e: e['a'], s)
sum(s) # Only now the list is iterated. Result: 4


接受任何类型的iterable:

它可以是列表、集合、字典或自定义iterable类。您可以从中构造任何集合类型，而无需多次迭代

d = {'a': 1, 'b': 1, 'c': 2}

{k: v for k, v in dedupe(d.items(), lambda e: e[1])}
# Result (dict): {'a': 1, 'c': 2}

{*dedupe(d.items(), lambda e: e[1])}
# Result (set of tuples): {('a', 1), ('c', 2)}


接受可选的选择器函数（或任何可调用的函数）：

这使您能够灵活地在许多不同的上下文中使用此函数，并使用任何自定义逻辑或类型。如果缺少选择器，它将比较整个元素

# de-duping based on absolute value:
(*dedupe([-3, -2, -2, -1, 0, 1, 1, 2, 3, 3], abs),)
# Result: (-3, -2, -1, 0)

# de-duping without selector:
(*dedupe([-3, -2, -2, -1, 0, 1, 1, 2, 3, 3]),)
# Result: (-3, -2, -1, 0, 1, 2, 3)


工作代码比不存在的代码更像Python。你试过什么？我的回答是使用熊猫图书馆。查找非唯一值将很容易，特别是当您的键每次都相同时：我将它们称为特性或列。使用熊猫。请重复并从中选择。“演示如何解决此编码问题”不是堆栈溢出问题。我们希望您做出诚实的尝试，然后就您的算法或技术提出具体问题。堆栈溢出不是为了替换现有的文档和教程。请使用我当前的atempt编辑答案