L'eliminazione di linee in pitone dopo di loro che scrivo

Question

L'approvazione qui è il mio codice esistente:

////////////// = []
for line in datafile:
    splitline = line.split()
    for item in splitline:
        if not item.endswith("JAX"):
            if item.startswith("STF") or item.startswith("BRACKER"):
                //////////.append( item )


for line in //////////
    print /////////////
   /////////// +=1
    for t in//////
        if t in line[:line.find(',')]:
            line = line.strip().split(',')
           ///////////////write(','.join(line[:3]) + '\n') 
            break

/////////////.close()
/////////////close()
///////////.close()

Voglio fare un'ulteriore ottimizzazione. Il file è in realtà di grandi dimensioni. Vorrei eliminare le righe da esso che sono state abbinate dopo che sono stati abbinati e scritti nel file di piccole dimensioni per ridurre la quantità di tempo necessario per la ricerca in file grande. Qualche suggerimento su come dovrei andare su questo?

Answer 1

Puoi linee non elimina in un file di testo -. Sarebbe necessario spostare tutti i dati dopo la linea cancellata fino a colmare il gap, e sarebbe massicciamente inefficiente

Un modo per farlo è quello di scrivere un file temporaneo con tutte le linee che si desidera conservare in bigfile.txt, e quando hai terminato l'elaborazione bigfile.txt cancellare e rinominare il file temporaneo per sostituirlo.

In alternativa, se bigfile.txt è abbastanza piccolo da stare in memoria che si poteva leggere l'intero file in una lista ed eliminare le linee dalla lista, quindi scrivere l'elenco su disco.

Vorrei anche indovinare dal codice che bigfile.txt è una sorta di file CSV. Se è così allora può essere meglio per convertirlo in un file di database SQL e l'uso per interrogare esso. Python viene fornito con il modulo SQLite integrato e ci sono le librerie di 3rd parti per la maggior parte degli altri database.

Answer 2

Come ho detto in un commento, non sembra a me come la dimensione del "bigfile" dovrebbe rallentare la velocità con cui gli incrementi di conteggio. Quando eseguire iterazioni su un file del genere, Python legge solo una riga alla volta al fine.

Le ottimizzazioni che si possono fare a questo punto dipenderà da quanto matchedLines è grande, e che rapporto hanno le corde matchedLines al testo che stai cercando in.

Se matchedLines è grande, si potrebbe risparmiare tempo solo facendo il 'trovare' una volta:

for line in completedataset:
   text = line[:line.find(',')] 
   for t in matchedLines:
        if t in text:
            line = line.strip().split(',')
            smallerdataset.write(','.join(line[:3]) + '\n') 
            break

Nel mio test, il 'trovare' sono voluti circa 300 nanosecondi, quindi se matchedLines è qualche milione di oggetti lunghi, c'è il secondo in più proprio lì.

Se siete alla ricerca di corrispondenze esatte, non sottostringa le partite, è possibile accelerare le cose strada fino utilizzando un set:

matchedLines = set(matchedLines)
for line in completedataset:
    target = line[:line.find(',')]
    ## One lookup and you're done!
    if target in matchedLines:
        line = line.strip().split(',')
        smallerdataset.write(','.join(line[:3]) + '\n') 

Se i testi di destinazione che non corrispondono tendono a guardare completamente diverso da quelli che lo fanno (per esempio, la maggior parte degli obiettivi sono stringhe casuali, e matchedLines è un mucchio di nomi) e la matchedLines sono tutti di sopra di una certa lunghezza , si potrebbe provare a ottenere davvero intelligente controllando stringhe. Supponiamo che tutti matchedLines sono almeno 5 caratteri ...

def subkeys(s):
    ## e.g. if len(s) is 7, return s[0:5], s[1:6], s[2:7].
    return [s[i:i+5] for i in range(len(s) + 1 - 5)]

existing_subkeys = set()
for line in matchedLines:
    existing_subkeys.update(subkeys(line))

for line in completedataset:
    target = line[:line.find(',')]
    might_match = False
    for subkey in subkeys(target):
        if subkey in existing_subkeys:
            might_match = True
            break
    if might_match:
        # Then we have to do the old slow way.
        for matchedLine in matchedLines:
            if matchedLine in target:
                # Do the split and write and so on.

Ma è veramente facile da superare in astuzia a cercare di fare cose del genere, e dipende da quello che i vostri dati assomiglia.