Python - Daftar kamus unik

Katakanlah saya punya daftar kamus:

[
    {'id': 1, 'name': 'john', 'age': 34},
    {'id': 1, 'name': 'john', 'age': 34},
    {'id': 2, 'name': 'hanna', 'age': 30},
]

dan saya perlu mendapatkan daftar kamus unik (menghapus duplikat):

[
    {'id': 1, 'name': 'john', 'age': 34},
    {'id': 2, 'name': 'hanna', 'age': 30},
]

Adakah yang bisa membantu saya dengan cara paling efisien untuk mencapai ini dengan Python?

Jadi buat dikt sementara dengan kuncinya adalah id. Ini memfilter duplikat. The values()dict akan daftar

Dalam Python2.7

>>> L=[
... {'id':1,'name':'john', 'age':34},
... {'id':1,'name':'john', 'age':34},
... {'id':2,'name':'hanna', 'age':30},
... ]
>>> {v['id']:v for v in L}.values()
[{'age': 34, 'id': 1, 'name': 'john'}, {'age': 30, 'id': 2, 'name': 'hanna'}]

Dalam Python3

>>> L=[
... {'id':1,'name':'john', 'age':34},
... {'id':1,'name':'john', 'age':34},
... {'id':2,'name':'hanna', 'age':30},
... ] 
>>> list({v['id']:v for v in L}.values())
[{'age': 34, 'id': 1, 'name': 'john'}, {'age': 30, 'id': 2, 'name': 'hanna'}]

Dalam Python2.5 / 2.6

>>> L=[
... {'id':1,'name':'john', 'age':34},
... {'id':1,'name':'john', 'age':34},
... {'id':2,'name':'hanna', 'age':30},
... ] 
>>> dict((v['id'],v) for v in L).values()
[{'age': 34, 'id': 1, 'name': 'john'}, {'age': 30, 'id': 2, 'name': 'hanna'}]

Cara biasa untuk menemukan hanya elemen-elemen umum dalam set adalah dengan menggunakan setkelas Python . Cukup tambahkan semua elemen ke set, lalu konversikan set ke list, dan bam duplikatnya hilang.

Masalahnya, tentu saja, adalah bahwa set()hanya dapat berisi entri hashable, dan a dicttidak hashable.

Jika saya memiliki masalah ini, solusi saya adalah untuk mengkonversi masing dict- masing menjadi string yang mewakili dict, kemudian menambahkan semua string ke set()kemudian membaca nilai-nilai string sebagai list()dan dikonversi kembali ke dict.

Representasi yang baik dari dictdalam bentuk string adalah format JSON. Dan Python memiliki modul bawaan untuk JSON (disebut jsontentu saja).

Masalah yang tersisa adalah bahwa elemen-elemen dalam a dicttidak diurutkan, dan ketika Python mengonversinya dictmenjadi string JSON, Anda mungkin mendapatkan dua string JSON yang mewakili kamus yang setara tetapi bukan string yang identik. Solusi mudahnya adalah meneruskan argumen sort_keys=Truesaat Anda menelepon json.dumps().

EDIT: Solusi ini mengasumsikan bahwa yang diberikan dictdapat memiliki bagian yang berbeda. Jika kita dapat berasumsi bahwa setiap dictdengan nilai yang sama "id"akan cocok dictsatu sama lain dengan nilai yang sama "id", maka ini berlebihan; Solusi @ gnibbler akan lebih cepat dan mudah.

EDIT: Sekarang ada komentar dari André Lima secara eksplisit mengatakan bahwa jika ID adalah duplikat, aman untuk menganggap bahwa keseluruhan dictadalah duplikat. Jadi jawaban ini berlebihan dan saya merekomendasikan jawaban @ gnibbler.

Jika kamus hanya diidentifikasi secara unik oleh semua item (ID tidak tersedia) Anda dapat menggunakan jawabannya menggunakan JSON. Berikut ini adalah alternatif yang tidak menggunakan JSON, dan akan berfungsi selama semua nilai kamus tidak dapat diubah

[dict(s) for s in set(frozenset(d.items()) for d in L)]

Anda dapat menggunakan library numpy (hanya berfungsi untuk Python2.x):

   import numpy as np 

   list_of_unique_dicts=list(np.unique(np.array(list_of_dicts)))

Untuk membuatnya bekerja dengan Python 3.x (dan versi numpy terbaru), Anda perlu mengubah array dicts menjadi array string numpy, misalnya

list_of_unique_dicts=list(np.unique(np.array(list_of_dicts).astype(str)))

Berikut ini adalah solusi yang cukup kompak, meskipun saya kira tidak terlalu efisien (secara sederhana):

>>> ds = [{'id':1,'name':'john', 'age':34},
...       {'id':1,'name':'john', 'age':34},
...       {'id':2,'name':'hanna', 'age':30}
...       ]
>>> map(dict, set(tuple(sorted(d.items())) for d in ds))
[{'age': 30, 'id': 2, 'name': 'hanna'}, {'age': 34, 'id': 1, 'name': 'john'}]

Karena idcukup untuk mendeteksi duplikat, dan idhashable: jalankan melalui kamus yang memiliki idsebagai kunci. Nilai untuk setiap tombol adalah kamus asli.

deduped_dicts = dict((item["id"], item) for item in list_of_dicts).values()

Dalam Python 3, values()tidak mengembalikan daftar; Anda harus membungkus seluruh sisi kanan ekspresi itu list(), dan Anda dapat menulis daging ekspresi lebih ekonomis sebagai pemahaman dict:

deduped_dicts = list({item["id"]: item for item in list_of_dicts}.values())

Perhatikan bahwa hasilnya kemungkinan tidak akan berada dalam urutan yang sama seperti aslinya. Jika itu persyaratan, Anda bisa menggunakan Collections.OrderedDicta dict.

Sebagai tambahan, mungkin cukup masuk akal untuk menyimpan data dalam kamus yang menggunakan idkunci as untuk memulai.

a = [
{'id':1,'name':'john', 'age':34},
{'id':1,'name':'john', 'age':34},
{'id':2,'name':'hanna', 'age':30},
]

b = {x['id']:x for x in a}.values()

print(b)

output:

[{'age': 34, 'id': 1, 'name': 'john'}, {'age': 30, 'id': 2, 'name': 'hanna'}]

Memperluas jawaban John La Rooy ( Python - Daftar kamus unik ), membuatnya sedikit lebih fleksibel:

def dedup_dict_list(list_of_dicts: list, columns: list) -> list:
    return list({''.join(row[column] for column in columns): row
                for row in list_of_dicts}.values())

Fungsi Panggilan:

sorted_list_of_dicts = dedup_dict_list(
    unsorted_list_of_dicts, ['id', 'name'])

Kita bisa melakukannya pandas

import pandas as pd
yourdict=pd.DataFrame(L).drop_duplicates().to_dict('r')
Out[293]: [{'age': 34, 'id': 1, 'name': 'john'}, {'age': 30, 'id': 2, 'name': 'hanna'}]

Perhatikan sedikit berbeda dari jawaban terima.

drop_duplicates akan memeriksa semua kolom dalam panda, jika semuanya sama maka baris akan dijatuhkan.

Sebagai contoh :

Jika kita mengubah dictnama ke-2 dari john ke peter

L=[
    {'id': 1, 'name': 'john', 'age': 34},
    {'id': 1, 'name': 'peter', 'age': 34},
    {'id': 2, 'name': 'hanna', 'age': 30},
]
pd.DataFrame(L).drop_duplicates().to_dict('r')
Out[295]: 
[{'age': 34, 'id': 1, 'name': 'john'},
 {'age': 34, 'id': 1, 'name': 'peter'},# here will still keeping the dict in the out put 
 {'age': 30, 'id': 2, 'name': 'hanna'}]

Dalam python 3.6+ (apa yang telah saya uji), cukup gunakan:

import json

#Toy example, but will also work for your case 
myListOfDicts = [{'a':1,'b':2},{'a':1,'b':2},{'a':1,'b':3}]
#Start by sorting each dictionary by keys
myListOfDictsSorted = [sorted(d.items()) for d in myListOfDicts]

#Using json methods with set() to get unique dict
myListOfUniqueDicts = list(map(json.loads,set(map(json.dumps, myListOfDictsSorted))))

print(myListOfUniqueDicts)

Penjelasan: kami memetakan json.dumpsuntuk menyandikan kamus sebagai objek json, yang tidak dapat diubah. setkemudian dapat digunakan untuk menghasilkan iterable dari kekekalan yang unik . Akhirnya, kami mengonversi kembali ke representasi kamus menggunakan json.loads. Perhatikan bahwa pada awalnya, seseorang harus mengurutkan berdasarkan kunci untuk mengatur kamus dalam bentuk yang unik. Ini berlaku untuk Python 3.6+ karena kamus dipesan secara default.

Saya telah merangkum favorit saya untuk dicoba:

https://repl.it/@SmaMa/Python-List-of-unique-dictionaries

# ----------------------------------------------
# Setup
# ----------------------------------------------

myList = [
  {"id":"1", "lala": "value_1"},
  {"id": "2", "lala": "value_2"}, 
  {"id": "2", "lala": "value_2"}, 
  {"id": "3", "lala": "value_3"}
]
print("myList:", myList)

# -----------------------------------------------
# Option 1 if objects has an unique identifier
# -----------------------------------------------

myUniqueList = list({myObject['id']:myObject for myObject in myList}.values())
print("myUniqueList:", myUniqueList)

# -----------------------------------------------
# Option 2 if uniquely identified by whole object
# -----------------------------------------------

myUniqueSet = [dict(s) for s in set(frozenset(myObject.items()) for myObject in myList)]
print("myUniqueSet:", myUniqueSet)

# -----------------------------------------------
# Option 3 for hashable objects (not dicts)
# -----------------------------------------------

myHashableObjects = list(set(["1", "2", "2", "3"]))
print("myHashAbleList:", myHashableObjects)

Solusi cepat dan kotor hanya dengan membuat daftar baru.

sortedlist = []

for item in listwhichneedssorting:
    if item not in sortedlist:
        sortedlist.append(item)

Saya tidak tahu apakah Anda hanya ingin id dicts Anda dalam daftar menjadi unik, tetapi jika tujuannya adalah untuk memiliki satu set dict di mana unicity ada pada semua nilai kunci .. Anda harus menggunakan kunci tuple seperti ini dalam pemahaman Anda:

>>> L=[
...     {'id':1,'name':'john', 'age':34},
...    {'id':1,'name':'john', 'age':34}, 
...    {'id':2,'name':'hanna', 'age':30},
...    {'id':2,'name':'hanna', 'age':50}
...    ]
>>> len(L)
4
>>> L=list({(v['id'], v['age'], v['name']):v for v in L}.values())
>>>L
[{'id': 1, 'name': 'john', 'age': 34}, {'id': 2, 'name': 'hanna', 'age': 30}, {'id': 2, 'name': 'hanna', 'age': 50}]
>>>len(L)
3

Semoga ini bisa membantu Anda atau orang lain yang memiliki kekhawatiran ....

Ada banyak jawaban di sini, jadi izinkan saya menambahkan yang lain:

import json
from typing import List

def dedup_dicts(items: List[dict]):
    dedupped = [ json.loads(i) for i in set(json.dumps(item, sort_keys=True) for item in items)]
    return dedupped

items = [
    {'id': 1, 'name': 'john', 'age': 34},
    {'id': 1, 'name': 'john', 'age': 34},
    {'id': 2, 'name': 'hanna', 'age': 30},
]
dedup_dicts(items)

Opsi yang cukup mudah:

L = [
    {'id':1,'name':'john', 'age':34},
    {'id':1,'name':'john', 'age':34},
    {'id':2,'name':'hanna', 'age':30},
    ]


D = dict()
for l in L: D[l['id']] = l
output = list(D.values())
print output

Baiklah semua jawaban yang disebutkan di sini bagus, tetapi dalam beberapa jawaban orang dapat menghadapi kesalahan jika item kamus memiliki daftar atau kamus bersarang, jadi saya mengusulkan jawaban sederhana

a = [str(i) for i in a]
a = list(set(a))
a = [eval(i) for i in a]

Inilah implementasi dengan overhead memori yang kecil dengan biaya tidak sekompak yang lainnya.

values = [ {'id':2,'name':'hanna', 'age':30},
           {'id':1,'name':'john', 'age':34},
           {'id':1,'name':'john', 'age':34},
           {'id':2,'name':'hanna', 'age':30},
           {'id':1,'name':'john', 'age':34},]
count = {}
index = 0
while index < len(values):
    if values[index]['id'] in count:
        del values[index]
    else:
        count[values[index]['id']] = 1
        index += 1

keluaran:

[{'age': 30, 'id': 2, 'name': 'hanna'}, {'age': 34, 'id': 1, 'name': 'john'}]

Ini adalah solusi yang saya temukan:

usedID = []

x = [
{'id':1,'name':'john', 'age':34},
{'id':1,'name':'john', 'age':34},
{'id':2,'name':'hanna', 'age':30},
]

for each in x:
    if each['id'] in usedID:
        x.remove(each)
    else:
        usedID.append(each['id'])

print x

Pada dasarnya Anda memeriksa apakah ID ada dalam daftar, jika ada, hapus kamus, jika tidak, tambahkan ID ke daftar