你知道嗎？如果數(shù)組是字典組成的，直接對數(shù)組內(nèi)的字典采用set的方式進行去重，會報錯：

test = [{"a": 1}, {"a": 1}, {"a": 3}, {"b": 4}]
test = list(set(test))
> >>TypeError: unhashable type: 'dict'

因為使用set去重的前提是該對象為不可變對象，而字典是可變對象，因此無法直接使用該方法去重。

那么怎么解決這個問題呢？有三個辦法。

1.使用reduce方法

reduce() 函數(shù)會對參數(shù)序列中元素進行累積。

比如：

from functools import reduce
> >>def add(x, y) :            # 兩數(shù)相加
...    return x + y
...
> >>reduce(add, [1,2,3,4,5]) # 計算列表和：1+2+3+4+5
15

上述寫法也能用lambda函數(shù)簡化為：

from functools import reduce
 >> > reduce(lambda x, y: x+y, [1,2,3,4,5]) # 使用 lambda 匿名函數(shù)
15

因此，我們自己編寫一個函數(shù)進行數(shù)組內(nèi)的字典去重：

from functools import reduce

data = [{"a": 1}, {"a": 1}, {"a": 3}, {"b": 4}]
result = []
def unduplicate(result, data):
    if data not in result:
        result = result + [data]
    return result

for i in data:
    result = unduplicate(result, i)

> >> result
> >> [{'a': 1}, {'a': 3}, {'b': 4}]

稍顯復雜，如果使用reduce函數(shù)和lambda函數(shù)，代碼能簡化很多：

def delete_duplicate(data):
    func = lambda x, y: x + [y] if y not in x else x
    data = reduce(func, [[], ] + data)
    return data

> >> delete_duplicate(data)
> >> [{'a': 1}, {'a': 3}, {'b': 4}]

當然， 我也能一行寫完這個功能：

data = reduce(lambda x, y: x + [y] if y not in x else x, [[], ] + data)

只不過有可能會被打死在工位上，所以不建議這么干。

2.奇怪的技巧

就如文章開頭提到的，字典之所以不能用set去重，是因為它是可變對象。

但是...如果我們把它變成不可變對象呢？

data = [{"a": 1}, {"a": 1}, {"a": 3}, {"b": 4}]
def delete_duplicate(data):
    immutable_dict = set([str(item) for item in data])
    data = [eval(i) for i in immutable_dict]
    return data
> >> delete_duplicate(data)
> >> [{'a': 1}, {'a': 3}, {'b': 4}]

沒錯，這能成。

1.遍歷字典，將每個子項變成字符串存放到數(shù)組中，再通過set函數(shù)去重。

2.通過eval函數(shù)，將去重后的數(shù)組里的每個子項重新轉(zhuǎn)化回字典。

如此Python，怎能不好玩？

3.高效的方式

上面講了兩種騷操作，其實都不太建議在實際工作中使用。

一個原因是真的太騷了，怕被打趴在工位上。

另一個原因是，它們在應對較大數(shù)據(jù)量的時候，性能不太行。

下面是最正統(tǒng)的方式：

data = [dict(t) for t in set([tuple(d.items()) for d in data])]
> >>data
> >>[{'a': 1}, {'b': 2}]

其實和第二種方式一樣，是將數(shù)組內(nèi)的每個字典轉(zhuǎn)成元組，也就是不可變對象，再使用set進行去重。去重完畢后再使用dict函數(shù)將元組重新組成字典對。

但是，這種方法對于字典內(nèi)還有字典的數(shù)據(jù)結構是不適用的，因此對于字典對里還有字典情況的去重，比如：

data2 = [{"a": {"b": "c"}}, {"a": {"b": "c"}}]

這種情況我建議使用第二種方式去重：

data2 = [{"a": {"b": "c"}}, {"a": {"b": "c"}}]
def delete_duplicate_str(data):
    immutable_dict = set([str(item) for item in data])
    data = [eval(i) for i in immutable_dict]
    return data
print(delete_duplicate_str(data2))

 >> > [{'a': {'b': 'c'}}]

怎么樣，這三種方式你都學會了嗎？

如果覺得有收獲的話記得收藏一下。以后遇到類似的去重場景時可以拿出閱讀一下。