Python - Danh sách từ điển độc đáo

Hãy nói rằng tôi có một danh sách từ điển:

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

và tôi cần có được một danh sách các từ điển duy nhất (loại bỏ các bản sao):

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

Ai đó có thể giúp tôi cách hiệu quả nhất để đạt được điều này trong Python không?

Vì vậy, thực hiện một lệnh tạm thời với chìa khóa là id. Điều này lọc ra các bản sao. Các values()của dict sẽ danh sách

Trong 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'}]

Trong 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'}]

Trong 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'}]

Cách thông thường để chỉ tìm các phần tử phổ biến trong một tập hợp là sử dụng setlớp của Python . Chỉ cần thêm tất cả các yếu tố vào tập hợp, sau đó chuyển đổi tập hợp thành a listvà bam các bản sao đã biến mất.

Tất nhiên, vấn đề là một set()chỉ có thể chứa các mục có thể băm và một dictkhông thể băm.

Nếu tôi gặp vấn đề này, giải pháp của tôi sẽ là chuyển đổi từng dictchuỗi thành một chuỗi đại diện cho chuỗi dict, sau đó thêm tất cả các chuỗi vào set()sau đó đọc các giá trị chuỗi dưới dạng a list()và chuyển đổi trở lại dict.

Một đại diện tốt của một dictdạng chuỗi là định dạng JSON. Và Python có một mô-đun tích hợp cho JSON ( jsontất nhiên được gọi là ).

Vấn đề còn lại là các phần tử trong một dictkhông được sắp xếp theo thứ tự và khi Python chuyển đổi thành dictchuỗi JSON, bạn có thể nhận được hai chuỗi JSON đại diện cho các từ điển tương đương nhưng không phải là các chuỗi giống hệt nhau. Giải pháp dễ dàng là vượt qua đối số sort_keys=Truekhi bạn gọi json.dumps().

EDIT: Giải pháp này đã giả định rằng một cái nhất định dictcó thể có bất kỳ phần nào khác nhau. Nếu chúng ta có thể giả định rằng mọi thứ dictcó cùng "id"giá trị sẽ khớp với nhau dictvới cùng một "id"giá trị, thì điều này là quá mức cần thiết; Giải pháp @ gnibbler's sẽ nhanh hơn và dễ dàng hơn.

EDIT: Bây giờ có một nhận xét từ André Lima nói rõ ràng rằng nếu ID là một bản sao, sẽ an toàn khi cho rằng toàn bộ dictlà một bản sao. Vì vậy, câu trả lời này là quá mức cần thiết và tôi khuyên bạn nên trả lời @ gnibbler's.

Trong trường hợp từ điển chỉ được xác định duy nhất bởi tất cả các mục (ID không có sẵn), bạn có thể sử dụng câu trả lời bằng JSON. Sau đây là một thay thế không sử dụng JSON và sẽ hoạt động miễn là tất cả các giá trị từ điển là bất biến

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

Bạn có thể sử dụng thư viện numpy (chỉ hoạt động cho Python2.x):

   import numpy as np 

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

Để làm cho nó hoạt động với Python 3.x (và các phiên bản gần đây của numpy), bạn cần chuyển đổi mảng dicts thành mảng chuỗi numpy, ví dụ:

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

Đây là một giải pháp hợp lý nhỏ gọn, mặc dù tôi nghi ngờ không đặc biệt hiệu quả (nói một cách nhẹ nhàng):

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

Vì điều idnày là đủ để phát hiện các bản sao và idcó thể băm: chạy chúng thông qua một từ điển có idkhóa. Giá trị cho mỗi khóa là từ điển gốc.

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

Trong Python 3, values()không trả về danh sách; bạn sẽ cần phải bao bọc toàn bộ phía bên phải của biểu thức đó list()và bạn có thể viết phần thịt của biểu thức một cách kinh tế hơn như một cách hiểu chính tả:

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

Lưu ý rằng kết quả có thể sẽ không theo thứ tự như ban đầu. Nếu đó là một yêu cầu, bạn có thể sử dụng Collections.OrderedDictthay vì mộtdict .

Bên cạnh đó, có thể có ý nghĩa tốt khi chỉ giữ dữ liệu trong một từ điển sử dụng idkhóa làm khóa để bắt đầu.

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)

đầu ra:

[{'Tuổi': 34, 'id': 1, 'tên': 'john'}, {'tuổi': 30, 'id': 2, 'tên': 'hanna'}]

Mở rộng trên câu trả lời của John La Rooy ( Python - Danh sách từ điển duy nhất ), làm cho nó linh hoạt hơn một chút:

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

Chức năng gọi:

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

Chúng ta có thể làm với 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'}]

Thông báo hơi khác với câu trả lời chấp nhận.

drop_duplicates sẽ kiểm tra tất cả các cột trong gấu trúc, nếu tất cả giống nhau thì hàng sẽ bị loại bỏ.

Ví dụ :

Nếu chúng ta thay đổi dicttên thứ 2 từ john thành 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'}]

Trong python 3.6+ (những gì tôi đã thử nghiệm), chỉ cần sử dụng:

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)

Giải thích: chúng tôi đang lập bản đồ json.dumpsđể mã hóa từ điển dưới dạng đối tượng json, là bất biến. setsau đó có thể được sử dụng để tạo ra một lần lặp các bất biến duy nhất . Cuối cùng, chúng tôi chuyển đổi trở lại đại diện từ điển của chúng tôi bằng cách sử dụng json.loads. Lưu ý rằng ban đầu, người ta phải sắp xếp theo các phím để sắp xếp từ điển theo một hình thức duy nhất. Điều này hợp lệ với Python 3.6+ vì từ điển được sắp xếp theo mặc định.

Tôi đã tóm tắt các mục yêu thích của tôi để thử:

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)

Một giải pháp nhanh và bẩn chỉ bằng cách tạo một danh sách mới.

sortedlist = []

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

Tôi không biết nếu bạn chỉ muốn id của các ký tự của bạn trong danh sách là duy nhất, nhưng nếu mục tiêu là có một bộ lệnh trong đó tính đơn nhất trên tất cả các giá trị của khóa .. bạn nên sử dụng khóa tuples như thế này trong sự hiểu biết của bạn:

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

Hy vọng nó sẽ giúp bạn hoặc người khác có mối quan tâm ....

Có rất nhiều câu trả lời ở đây, vì vậy hãy để tôi thêm một câu trả lời khác:

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)

Tùy chọn khá đơn giản:

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

Vâng tất cả các câu trả lời được đề cập ở đây đều tốt, nhưng trong một số câu trả lời người ta có thể gặp lỗi nếu các mục từ điển có danh sách hoặc từ điển lồng nhau, vì vậy tôi đề xuất câu trả lời đơn giản

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

Đây là một triển khai với ít bộ nhớ trên đầu với chi phí không nhỏ gọn như phần còn lại.

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

đầu ra:

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

Đây là giải pháp tôi tìm thấy:

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

Về cơ bản, bạn kiểm tra xem ID có trong danh sách hay không, nếu có, hãy xóa từ điển, nếu không, hãy thêm ID vào danh sách