Wie finde ich die Duplikate in einer Liste und erstelle eine weitere Liste mit ihnen?

Question

Wie finde ich die Duplikate in einer Liste mit ganzen Zahlen und erstelle eine weitere Liste mit den Duplikaten?

Answer 1

Eine andere Lösung ist die folgende, ohne eine Sammlungsbibliothek zu verwenden.

a = [1,2,3,5,4,6,4,21,4,6,3,32,5,2,23,5]
duplicates = []

for i in a:
    if a.count(i) > 1 and i not in duplicates:
        duplicates.append(i)

print(duplicates)

Die Ausgabe lautet [2, 3, 5, 4, 6]

Answer 2

Einige andere Tests. Natürlich zu tun...

set([x for x in l if l.count(x) > 1])

...ist zu kostspielig. Es ist etwa 500 Mal schneller (je länger das Array ist, desto besser sind die Ergebnisse), die nächste letzte Methode zu verwenden:

def dups_count_dict(l):
    d = {}

    for item in l:
        if item not in d:
            d[item] = 0

        d[item] += 1

    result_d = {key: val for key, val in d.iteritems() if val > 1}

    return result_d.keys()

Nur 2 Schleifen, nicht sehr kostspielig l.count() Operationen.

Hier ist ein Code zum Vergleich der Methoden als Beispiel. Der Code ist unten, hier ist die Ausgabe:

dups_count: 13.368s # this is a function which uses l.count()
dups_count_dict: 0.014s # this is a final best function (of the 3 functions)
dups_count_counter: 0.024s # collections.Counter

Der Prüfcode:

import numpy as np
from time import time
from collections import Counter

class TimerCounter(object):
    def __init__(self):
        self._time_sum = 0

    def start(self):
        self.time = time()

    def stop(self):
        self._time_sum += time() - self.time

    def get_time_sum(self):
        return self._time_sum

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

def dups_count_dict(l):
    d = {}

    for item in l:
        if item not in d:
            d[item] = 0

        d[item] += 1

    result_d = {key: val for key, val in d.iteritems() if val > 1}

    return result_d.keys()

def dups_counter(l):
    counter = Counter(l)    

    result_d = {key: val for key, val in counter.iteritems() if val > 1}

    return result_d.keys()

def gen_array():
    np.random.seed(17)
    return list(np.random.randint(0, 5000, 10000))

def assert_equal_results(*results):
    primary_result = results[0]
    other_results = results[1:]

    for other_result in other_results:
        assert set(primary_result) == set(other_result) and len(primary_result) == len(other_result)

if __name__ == '__main__':
    dups_count_time = TimerCounter()
    dups_count_dict_time = TimerCounter()
    dups_count_counter = TimerCounter()

    l = gen_array()

    for i in range(3):
        dups_count_time.start()
        result1 = dups_count(l)
        dups_count_time.stop()

        dups_count_dict_time.start()
        result2 = dups_count_dict(l)
        dups_count_dict_time.stop()

        dups_count_counter.start()
        result3 = dups_counter(l)
        dups_count_counter.stop()

        assert_equal_results(result1, result2, result3)

    print 'dups_count: %.3f' % dups_count_time.get_time_sum()
    print 'dups_count_dict: %.3f' % dups_count_dict_time.get_time_sum()
    print 'dups_count_counter: %.3f' % dups_count_counter.get_time_sum()

Answer 3

raw_list = [1,2,3,3,4,5,6,6,7,2,3,4,2,3,4,1,3,4,]

clean_list = list(set(raw_list))
duplicated_items = []

for item in raw_list:
    try:
        clean_list.remove(item)
    except ValueError:
        duplicated_items.append(item)

print(duplicated_items)
# [3, 6, 2, 3, 4, 2, 3, 4, 1, 3, 4]

Sie entfernen Duplikate grundsätzlich durch Konvertierung in Set ( clean_list ), dann iterieren Sie die raw_list und gleichzeitig die einzelnen item in der bereinigten Liste für das Vorkommen in raw_list . Wenn item nicht gefunden wird, wird die erhöhte ValueError Ausnahme wird abgefangen und die item wird hinzugefügt zu duplicated_items Liste.

Wenn der Index der duplizierten Elemente benötigt wird, genügt es enumerate die Liste und spielen Sie mit dem Index herum. ( for index, item in enumerate(raw_list): ), das schneller ist und für große Listen (mit mehr als tausend Elementen) optimiert wurde.

Answer 4

Verwendung von list.count() Methode in der Liste, um die doppelten Elemente einer gegebenen Liste herauszufinden

arr=[]
dup =[]
for i in range(int(input("Enter range of list: "))):
    arr.append(int(input("Enter Element in a list: ")))
for i in arr:
    if arr.count(i)>1 and i not in dup:
        dup.append(i)
print(dup)

Answer 5

Einzeiler, nur so zum Spaß, und wenn eine einzige Aussage erforderlich ist.

(lambda iterable: reduce(lambda (uniq, dup), item: (uniq, dup | {item}) if item in uniq else (uniq | {item}, dup), iterable, (set(), set())))(some_iterable)