Entfernen Sie doppelte Zeilen aus einer großen Datei in Python

Wenn Sie möchten, eine wirklich einfache Möglichkeit, dies zu tun, erstellen Sie einfach eine sqlite-Datenbank:

import sqlite3
conn = sqlite3.connect('single.db')
cur = conn.cursor()
cur.execute("""create table test(
f1 text,
f2 text,
f3 text,
f4 text,
f5 text,
f6 text,
f7 text,
f8 text,
f9 text,
f10 text,
f11 text,
f12 text,
f13 text,
f14 text,
f15 text,
primary key(f1,  f2,  f3,  f4,  f5,  f6,  f7,  
            f8,  f9,  f10,  f11,  f12,  f13,  f14,  f15))
"""
conn.commit()

#simplified/pseudo code
for row in reader:
    #assuming row returns a list-type object
    try:
        cur.execute('''insert into test values(?, ?, ?, ?, ?, ?, ?, 
                       ?, ?, ?, ?, ?, ?, ?, ?)''', row)
        conn.commit()
    except IntegrityError:
        pass

conn.commit()
cur.execute('select * from test')

for row in cur:
    #write row to csv file

Dann würden Sie nicht haben, um sorgen über die Vergleich-Logik-sich - lassen sqlite übernehmen das für Sie. Es wird wahrscheinlich nicht viel schneller als die Vermischung der Saiten, aber es ist wahrscheinlich viel einfacher. Natürlich würden Sie ändern Sie den Typ in der Datenbank gespeichert, wenn Sie wollte, oder nicht, wie der Fall sein kann. Natürlich da hast du schon konvertieren der Daten in eine Zeichenfolge, die Sie könnte nur noch ein Feld statt. Viele Optionen hier.

Ihre aktuelle Methode ist nicht garantiert, um richtig zu arbeiten.

Erstens gibt es die geringe Wahrscheinlichkeit, dass zwei Linien, die sind tatsächlich anders produzieren können, die den gleichen hash-Wert. hash(a) == hash(b) bedeutet nicht immer, dass a == b

Zweitens -, Sie machen die Wahrscheinlichkeit höher mit Ihrem "reduzieren/lambda" caper:

>>> reduce(lambda x,y: x+y, ['foo', '1', '23'])
'foo123'
>>> reduce(lambda x,y: x+y, ['foo', '12', '3'])
'foo123'
>>>

BTW, wäre das nicht "".join(['foo', '1', '23']) etwas klarer?

BTW2, warum nicht ein set statt einer dict für htable?

Hier eine praktische Lösung: den "core utils" - Paket von der GnuWin32 Website, und installieren Sie es. Dann:

1. schreiben eine Kopie der Datei ohne die überschriften, um (sagen wir) infile.csv -
2. c:\gnuwin32\bin\sort --unique -ooutfile.csv infile.csv
3. Lesen outfile.csv und schreiben eine Kopie mit den überschriften vorangestellt

Für jeden der Schritte 1 & 3, können Sie ein Python-Skript, oder einige der anderen GnuWin32 utilities (head, tail, tee, Katze, ...).

Da ich angenommen, Sie haben auf einem etwas regelmäßig (oder man müsste gehackt eine einmal-over-Skript), und Sie haben erwähnt, Sie waren daran interessiert, eine theoretische Lösung, hier ist eine Möglichkeit.

Lesen Sie die input-Zeilen in B-Bäumen bestellt durch jeden Eingang hash-Wert, das schreiben auf die Festplatte, wenn der Speicher füllt. Wir kümmern uns um zu speichern, auf der B-Bäume, die ursprünglichen Linien angebracht, um die hash (als set, da wir nur über einzigartige Linien). Wenn wir Lesen, ein doppeltes element, überprüfen wir die Linien festgelegt, auf die gespeicherte element und fügen Sie es, wenn es eine neue Linie, die geschieht, um hash um den gleichen Wert.

Warum B-Bäume???? Sie erfordert weniger Festplatte liest, wenn Sie nur können (oder wollen) zu Lesen, teilen Sie Sie in den Speicher. Der Grad (Anzahl der Kinder) auf jedem Knoten hängt von den verfügbaren Speicher und die Anzahl der Linien, aber Sie wollen nicht zu viele Knoten.

Einmal haben wir diese B-Bäume auf der Festplatte, vergleichen wir die niedrigste element von jeder von Ihnen. Wir entfernen die niedrigsten von allen, von allem B-Bäume, die es haben. Wir verschmelzen Ihre Linien setzt, was bedeutet, dass wir keine Duplikate haben Links für diese Zeilen (und auch, dass wir keine Zeilen mehr, dass hash-Wert). Wir schreiben Sie dann die Zeilen aus diesem merge in der Ausgabe csv-Struktur.

Können wir die Trennung die Hälfte des Speichers für das Lesen der B-Bäume, und die Hälfte halten Sie die csv-Ausgabe im Speicher für einige Zeit. Wir Spülen das csv-Format auf die Festplatte, wenn die Hälfte voll ist, Anhängen, was bereits geschrieben wurde. Wie viel von jedem B-Baum Lesen wir auf jedem Schritt können Sie grob berechnen, indem (available_memory /2) /number_of_btrees, gerundet, so Lesen wir voller Knoten.

In pseudo-Python:

ins = DictReader(...)
i = 0
while ins.still_has_lines_to_be_read():
    tree = BTree(i)
    while fits_into_memory:
        line = ins.readline()
        tree.add(line, key=hash)
    tree.write_to_disc()
    i += 1
n_btrees = i

# At this point, we have several (n_btres) B-Trees on disk
while n_btrees:
    n_bytes = (available_memory / 2) / n_btrees
    btrees = [read_btree_from_disk(i, n_bytes)
              for i in enumerate(range(n_btrees))]
    lowest_candidates = [get_lowest(b) for b in btrees]
    lowest = min(lowest_candidates)
    lines = set()
    for i in range(number_of_btrees):
        tree = btrees[i]
        if lowest == lowest_candidates[i]:
            node = tree.pop_lowest()
            lines.update(node.lines)
        if tree.is_empty():
        n_btrees -= 1

    if output_memory_is_full or n_btrees == 0:
        outs.append_on_disk(lines)