Удалить дубликаты в списке в Python

У меня есть список диктов, и я хотел бы удалить диктанты с одинаковыми парами ключ и значение.

Для этого списка: [{'a': 123}, {'b': 123}, {'a': 123}]

Я хотел бы это вернуть: [{'a': 123}, {'b': 123}]

Другой пример:

Для этого списка: [{'a': 123, 'b': 1234}, {'a': 3222, 'b': 1234}, {'a': 123, 'b': 1234}]

Я хотел бы это вернуть: [{'a': 123, 'b': 1234}, {'a': 3222, 'b': 1234}]

Попробуй это:

[dict(t) for t in {tuple(d.items()) for d in l}]

Стратегия заключается в преобразовании списка словарей в список кортежей, в которых кортежи содержат элементы словаря. Так как кортежи можно хэшировать, вы можете удалить дубликаты, используя set(используя здесь понимание набора , более старая альтернатива Python set(tuple(d.items()) for d in l)), и после этого заново создать словари из кортежей с помощью dict.

где:

• l это оригинальный список
• d является одним из словарей в списке
• t является одним из кортежей, созданных из словаря

Редактировать: Если вы хотите сохранить порядок, строка выше не будет работать, так setкак не будет делать это. Однако, с помощью нескольких строк кода, вы также можете сделать это:

l = [{'a': 123, 'b': 1234},
        {'a': 3222, 'b': 1234},
        {'a': 123, 'b': 1234}]

seen = set()
new_l = []
for d in l:
    t = tuple(d.items())
    if t not in seen:
        seen.add(t)
        new_l.append(d)

print new_l

Пример вывода:

[{'a': 123, 'b': 1234}, {'a': 3222, 'b': 1234}]

Примечание: как указывает @alexis, может случиться так, что два словаря с одинаковыми ключами и значениями не приведут к одному и тому же кортежу. Это может произойти, если они пройдут через другую историю добавления / удаления ключей. Если это относится к вашей проблеме, то рассмотрите сортировку, d.items()как он предлагает.

Еще одна строка, основанная на списках:

>>> d = [{'a': 123}, {'b': 123}, {'a': 123}]
>>> [i for n, i in enumerate(d) if i not in d[n + 1:]]
[{'b': 123}, {'a': 123}]

Здесь, поскольку мы можем использовать dictсравнение, мы сохраняем только те элементы, которых нет в остальной части начального списка (это понятие доступно только через индекс n, отсюда и использование enumerate).

Другие ответы не будут работать, если вы работаете с вложенными словарями, такими как десериализованные объекты JSON. Для этого случая вы можете использовать:

import json
set_of_jsons = {json.dumps(d, sort_keys=True) for d in X}
X = [json.loads(t) for t in set_of_jsons]

Если вы можете использовать сторонний пакет, то вы можете использовать iteration_utilities.unique_everseen:

>>> from iteration_utilities import unique_everseen
>>> l = [{'a': 123}, {'b': 123}, {'a': 123}]
>>> list(unique_everseen(l))
[{'a': 123}, {'b': 123}]

Он сохраняет порядок исходного списка и может также обрабатывать не подлежащие изменению элементы, такие как словари, используя более медленный алгоритм ( O(n*m)где вместо nэлементов находятся элементы в исходном списке и mуникальные элементы в исходном списке O(n)). Если ключи и значения являются хэшируемыми, вы можете использовать keyаргумент этой функции для создания хэшируемых элементов для «теста уникальности» (чтобы он работал O(n)).

В случае словаря (который сравнивается независимо от порядка) вам необходимо сопоставить его с другой структурой данных, которая сравнивается следующим образом, например frozenset:

>>> list(unique_everseen(l, key=lambda item: frozenset(item.items())))
[{'a': 123}, {'b': 123}]

Обратите внимание, что вы не должны использовать простой tupleподход (без сортировки), потому что равные словари не обязательно имеют одинаковый порядок (даже в Python 3.7, где порядок вставки - не абсолютный порядок - гарантирован):

>>> d1 = {1: 1, 9: 9}
>>> d2 = {9: 9, 1: 1}
>>> d1 == d2
True
>>> tuple(d1.items()) == tuple(d2.items())
False

И даже сортировка кортежа может не работать, если ключи не сортируются:

>>> d3 = {1: 1, 'a': 'a'}
>>> tuple(sorted(d3.items()))
TypeError: '<' not supported between instances of 'str' and 'int'

эталонный тест

Я подумал, что было бы полезно увидеть сравнение этих подходов, поэтому я сделал небольшой тест. Графики сравнения времени и размера списка основаны на списке, не содержащем дубликатов (который был выбран произвольно, время выполнения существенно не изменится, если я добавлю несколько или много дубликатов). Это логарифмический сюжет, поэтому весь ассортимент покрыт.

Абсолютные времена:

Сроки относительно самого быстрого подхода:

Второй подход из четвертого здесь самый быстрый. unique_everseenПодход с keyфункцией находится на втором месте, однако это самый быстрый подход , который сохраняет заказ. Другие подходы от jcollado и thefourtheye почти такие же быстрые. Подход с использованием unique_everseenбез ключа и решений из Эммануэля и Scorpil очень медленно для длинных списков и ведут себя гораздо хуже , O(n*n)а O(n). Подход stpk с jsonне является, O(n*n)но он намного медленнее, чем аналогичные O(n)подходы.

Код для воспроизведения тестов:

from simple_benchmark import benchmark
import json
from collections import OrderedDict
from iteration_utilities import unique_everseen

def jcollado_1(l):
    return [dict(t) for t in {tuple(d.items()) for d in l}]

def jcollado_2(l):
    seen = set()
    new_l = []
    for d in l:
        t = tuple(d.items())
        if t not in seen:
            seen.add(t)
            new_l.append(d)
    return new_l

def Emmanuel(d):
    return [i for n, i in enumerate(d) if i not in d[n + 1:]]

def Scorpil(a):
    b = []
    for i in range(0, len(a)):
        if a[i] not in a[i+1:]:
            b.append(a[i])

def stpk(X):
    set_of_jsons = {json.dumps(d, sort_keys=True) for d in X}
    return [json.loads(t) for t in set_of_jsons]

def thefourtheye_1(data):
    return OrderedDict((frozenset(item.items()),item) for item in data).values()

def thefourtheye_2(data):
    return {frozenset(item.items()):item for item in data}.values()

def iu_1(l):
    return list(unique_everseen(l))

def iu_2(l):
    return list(unique_everseen(l, key=lambda inner_dict: frozenset(inner_dict.items())))

funcs = (jcollado_1, Emmanuel, stpk, Scorpil, thefourtheye_1, thefourtheye_2, iu_1, jcollado_2, iu_2)
arguments = {2**i: [{'a': j} for j in range(2**i)] for i in range(2, 12)}
b = benchmark(funcs, arguments, 'list size')

%matplotlib widget
import matplotlib as mpl
import matplotlib.pyplot as plt
plt.style.use('ggplot')
mpl.rcParams['figure.figsize'] = '8, 6'

b.plot(relative_to=thefourtheye_2)

Для полноты здесь приведено время для списка, содержащего только дубликаты:

# this is the only change for the benchmark
arguments = {2**i: [{'a': 1} for j in range(2**i)] for i in range(2, 12)}

Времена не меняются значительно, за исключением unique_everseenбез keyфункции, которая в этом случае является самым быстрым решением. Тем не менее, это просто лучший случай (поэтому не репрезентативный) для этой функции с непредсказуемыми значениями, потому что время ее выполнения зависит от количества уникальных значений в списке: O(n*m)в данном случае это всего 1, и, следовательно, он выполняется O(n).

Отказ от ответственности: я автор iteration_utilities.

Иногда петли старого стиля все еще полезны. Этот код немного длиннее, чем у jcollado, но очень легко читается:

a = [{'a': 123}, {'b': 123}, {'a': 123}]
b = []
for i in range(0, len(a)):
    if a[i] not in a[i+1:]:
        b.append(a[i])

Если вы хотите сохранить заказ, то вы можете сделать

from collections import OrderedDict
print OrderedDict((frozenset(item.items()),item) for item in data).values()
# [{'a': 123, 'b': 1234}, {'a': 3222, 'b': 1234}]

Если порядок не имеет значения, то вы можете сделать

print {frozenset(item.items()):item for item in data}.values()
# [{'a': 3222, 'b': 1234}, {'a': 123, 'b': 1234}]

Если вы используете Pandas в своем рабочем процессе, одним из вариантов является передача списка словарей непосредственно в pd.DataFrameконструктор. Затем используйте drop_duplicatesи to_dictметоды для получения требуемого результата.

import pandas as pd

d = [{'a': 123, 'b': 1234}, {'a': 3222, 'b': 1234}, {'a': 123, 'b': 1234}]

d_unique = pd.DataFrame(d).drop_duplicates().to_dict('records')

print(d_unique)

[{'a': 123, 'b': 1234}, {'a': 3222, 'b': 1234}]

Не универсальный ответ , но если ваш список отсортирован по некоторому ключу, например так:

l=[{'a': {'b': 31}, 't': 1},
   {'a': {'b': 31}, 't': 1},
 {'a': {'b': 145}, 't': 2},
 {'a': {'b': 25231}, 't': 2},
 {'a': {'b': 25231}, 't': 2}, 
 {'a': {'b': 25231}, 't': 2}, 
 {'a': {'b': 112}, 't': 3}]

тогда решение так же просто, как:

import itertools
result = [a[0] for a in itertools.groupby(l)]

Результат:

[{'a': {'b': 31}, 't': 1},
{'a': {'b': 145}, 't': 2},
{'a': {'b': 25231}, 't': 2},
{'a': {'b': 112}, 't': 3}]

Работает с вложенными словарями и (очевидно) сохраняет порядок.

Вы можете использовать набор, но вам нужно превратить дикты в тип hashable.

seq = [{'a': 123, 'b': 1234}, {'a': 3222, 'b': 1234}, {'a': 123, 'b': 1234}]
unique = set()
for d in seq:
    t = tuple(d.iteritems())
    unique.add(t)

Уникальный сейчас равен

set([(('a', 3222), ('b', 1234)), (('a', 123), ('b', 1234))])

Чтобы вернуть слова:

[dict(x) for x in unique]

Вот быстрое однострочное решение с вдвойне понятным списком (основанное на решении @Emmanuel).

При этом используется один ключ (например, a) в каждом диктовке в качестве первичного ключа, а не проверка соответствия всего диктовки.

[i for n, i in enumerate(list_of_dicts) if i.get(primary_key) not in [y.get(primary_key) for y in list_of_dicts[n + 1:]]]

Это не то, о чем просил OP, но это то, что привело меня в эту ветку, поэтому я решил опубликовать решение, с которым у меня получилось

Не такой короткий, но легко читаемый:

list_of_data = [{'a': 123}, {'b': 123}, {'a': 123}]

list_of_data_uniq = []
for data in list_of_data:
    if data not in list_of_data_uniq:
        list_of_data_uniq.append(data)

Теперь список list_of_data_uniqбудет иметь уникальные диктанты.