Hướng dẫn how do you find the duplicates of a list in python? - làm thế nào để bạn tìm thấy các bản sao của một danh sách trong python?

Bạn có thể sử dụng iteration_utilities.duplicates:

>>> from iteration_utilities import duplicates

>>> list(duplicates([1,1,2,1,2,3,4,2]))
[1, 1, 2, 2]

Hoặc nếu bạn chỉ muốn một trong mỗi bản sao, điều này có thể được kết hợp với iteration_utilities.unique_everseen:

>>> from iteration_utilities import unique_everseen

>>> list(unique_everseen(duplicates([1,1,2,1,2,3,4,2])))
[1, 2]

Nó cũng có thể xử lý các yếu tố không thể đo lường được (tuy nhiên với chi phí hiệu suất):

>>> list(duplicates([[1], [2], [1], [3], [1]]))
[[1], [1]]

>>> list(unique_everseen(duplicates([[1], [2], [1], [3], [1]])))
[[1]]

Đó là điều mà chỉ một vài cách tiếp cận khác ở đây có thể xử lý.

Điểm chuẩn

Tôi đã làm một điểm chuẩn nhanh chóng chứa hầu hết (nhưng không phải tất cả) các phương pháp được đề cập ở đây.

Điểm chuẩn đầu tiên chỉ bao gồm một phạm vi nhỏ các độ dài danh sách vì một số phương pháp có hành vi O(n**2).

Trong các biểu đồ, trục y biểu thị thời gian, do đó giá trị thấp hơn có nghĩa là tốt hơn. Nó cũng được vẽ log-log để phạm vi rộng của các giá trị có thể được hiển thị tốt hơn:

Loại bỏ các phương pháp O(n**2) Tôi đã thực hiện một điểm chuẩn khác lên đến nửa triệu yếu tố trong danh sách:

Như bạn có thể thấy phương pháp iteration_utilities.duplicates nhanh hơn bất kỳ phương pháp nào khác và thậm chí chuỗi

>>> from iteration_utilities import unique_everseen

>>> list(unique_everseen(duplicates([1,1,2,1,2,3,4,2])))
[1, 2]

Một điều thú vị khác cần lưu ý ở đây là các phương pháp Pandas rất chậm đối với các danh sách nhỏ nhưng có thể dễ dàng cạnh tranh cho các danh sách dài hơn.

Tuy nhiên, vì các điểm chuẩn này cho thấy hầu hết các phương pháp thực hiện gần như như nhau, do đó, không quan trọng là loại nào được sử dụng (ngoại trừ 3 lần chạy O(n**2)).

from iteration_utilities import duplicates, unique_everseen
from collections import Counter
import pandas as pd
import itertools

def georg_counter(it):
    return [item for item, count in Counter(it).items() if count > 1]

def georg_set(it):
    seen = set()
    uniq = []
    for x in it:
        if x not in seen:
            uniq.append(x)
            seen.add(x)

def georg_set2(it):
    seen = set()
    return [x for x in it if x not in seen and not seen.add(x)]   

def georg_set3(it):
    seen = {}
    dupes = []

    for x in it:
        if x not in seen:
            seen[x] = 1
        else:
            if seen[x] == 1:
                dupes.append(x)
            seen[x] += 1

def RiteshKumar_count(l):
    return set([x for x in l if l.count(x) > 1])

def moooeeeep(seq):
    seen = set()
    seen_add = seen.add
    # adds all elements it doesn't know yet to seen and all other to seen_twice
    seen_twice = set( x for x in seq if x in seen or seen_add(x) )
    # turn the set into a list (as requested)
    return list( seen_twice )

def F1Rumors_implementation(c):
    a, b = itertools.tee(sorted(c))
    next(b, None)
    r = None
    for k, g in zip(a, b):
        if k != g: continue
        if k != r:
            yield k
            r = k

def F1Rumors(c):
    return list(F1Rumors_implementation(c))

def Edward(a):
    d = {}
    for elem in a:
        if elem in d:
            d[elem] += 1
        else:
            d[elem] = 1
    return [x for x, y in d.items() if y > 1]

def wordsmith(a):
    return pd.Series(a)[pd.Series(a).duplicated()].values

def NikhilPrabhu(li):
    li = li.copy()
    for x in set(li):
        li.remove(x)

    return list(set(li))

def firelynx(a):
    vc = pd.Series(a).value_counts()
    return vc[vc > 1].index.tolist()

def HenryDev(myList):
    newList = set()

    for i in myList:
        if myList.count(i) >= 2:
            newList.add(i)

    return list(newList)

def yota(number_lst):
    seen_set = set()
    duplicate_set = set(x for x in number_lst if x in seen_set or seen_set.add(x))
    return seen_set - duplicate_set

def IgorVishnevskiy(l):
    s=set(l)
    d=[]
    for x in l:
        if x in s:
            s.remove(x)
        else:
            d.append(x)
    return d

def it_duplicates(l):
    return list(duplicates(l))

def it_unique_duplicates(l):
    return list(unique_everseen(duplicates(l)))

Điểm chuẩn 1

from simple_benchmark import benchmark
import random

funcs = [
    georg_counter, georg_set, georg_set2, georg_set3, RiteshKumar_count, moooeeeep, 
    F1Rumors, Edward, wordsmith, NikhilPrabhu, firelynx,
    HenryDev, yota, IgorVishnevskiy, it_duplicates, it_unique_duplicates
]

args = {2**i: [random.randint(0, 2**(i-1)) for _ in range(2**i)] for i in range(2, 12)}

b = benchmark(funcs, args, 'list size')

b.plot()

Điểm chuẩn 2

funcs = [
    georg_counter, georg_set, georg_set2, georg_set3, moooeeeep, 
    F1Rumors, Edward, wordsmith, firelynx,
    yota, IgorVishnevskiy, it_duplicates, it_unique_duplicates
]

args = {2**i: [random.randint(0, 2**(i-1)) for _ in range(2**i)] for i in range(2, 20)}

b = benchmark(funcs, args, 'list size')
b.plot()

Tuyên bố miễn trừ trách nhiệm

1 Đây là từ một thư viện của bên thứ ba tôi đã viết:

>>> from iteration_utilities import unique_everseen

>>> list(unique_everseen(duplicates([1,1,2,1,2,3,4,2])))
[1, 2]

Làm thế nào để bạn tìm thấy các bản sao trong một danh sách?

Danh sách có trùng lặp trong Python không?

Làm thế nào để bạn xác định và loại bỏ các bản sao trong Python?

Làm thế nào để tôi tìm thấy các bản sao trong gấu trúc?