¿Cómo eliminar líneas duplicadas dentro de un archivo de texto?

Un enorme archivo de texto (hasta 2 GiB) contiene aproximadamente 100 duplicados exactos de cada línea (inútil en mi caso, ya que el archivo es una tabla de datos similar a CSV).

Lo que necesito es eliminar todas las repeticiones mientras (preferiblemente, pero esto se puede sacrificar por un aumento significativo del rendimiento) mantener el orden de secuencia original. En el resultado, cada línea debe ser única. Si hubiera 100 líneas iguales (generalmente los duplicados se extienden por el archivo y no serán vecinos), solo quedará uno del tipo.

He escrito un programa en Scala (considérelo Java si no sabe sobre Scala) para implementar esto. ¿Pero tal vez hay herramientas nativas escritas en C más rápidas capaces de hacerlo más rápido?

ACTUALIZACIÓN: la awk '!seen[$0]++' filenamesolución parecía funcionar bien para mí, siempre y cuando los archivos estuvieran cerca de 2 GiB o menos, pero ahora que tengo que limpiar un archivo de 8 GiB ya no funciona. Parece tener infinito en una Mac con 4 GiB RAM y una PC con Windows 7 de 64 bits con 4 GiB RAM y 6 GiB swap simplemente se queda sin memoria. Y no me entusiasma probarlo en Linux con 4 GiB RAM dada esta experiencia.

Una awksolución vista en #bash (Freenode):

awk '!seen[$0]++' filename

Hay un método simple (que no quiere decir obvio) que utiliza utilidades estándar que no requiere una gran memoria, excepto para ejecutarse sort, que en la mayoría de las implementaciones tiene optimizaciones específicas para archivos de gran tamaño (un buen algoritmo de ordenamiento externo). Una ventaja de este método es que solo recorre todas las líneas dentro de las utilidades especiales, nunca dentro de los lenguajes interpretados.

<input nl -b a -s : |           # number the lines
sort -t : -k 2 -u |             # sort and uniquify ignoring the line numbers
sort -t : -k 1n |               # sort according to the line numbers
cut -d : -f 2- >output          # remove the line numbers

Si todas las líneas comienzan con un carácter que no sea un espacio en blanco, puede prescindir de algunas de las opciones:

<input nl | sort -k 2 -u | sort -k 1n | cut -f 2- >output

Para una gran cantidad de duplicación, un método que solo requiere almacenar una sola copia de cada línea en la memoria funcionará mejor. Con un poco de interpretación general, hay un script awk muy conciso para eso (ya publicado por enzotib ):

<input awk '!seen[$0]++'

De manera menos concisa: !seen[$0] {print} {seen[$0] += 1}es decir, imprima la línea actual si aún no se ha visto, luego incremente el seencontador para esta línea (las variables no inicializadas o los elementos de la matriz tienen el valor numérico 0).

Para líneas largas, puede ahorrar memoria manteniendo solo una suma de comprobación no falsificable (por ejemplo, un resumen criptográfico) de cada línea. Por ejemplo, con SHA-1, solo necesita 20 bytes más una sobrecarga constante por línea. Pero calcular los resúmenes es bastante lento; este método solo ganará si tiene una CPU rápida (especialmente una con un acelerador de hardware para calcular los resúmenes) y no hay mucha memoria en relación con el tamaño del archivo y líneas suficientemente largas. Ninguna utilidad básica le permite calcular una suma de verificación para cada línea; tendría que soportar la sobrecarga de interpretación de Perl / Python / Ruby / ... o escribir un programa compilado dedicado.

<input perl -MDigest::MD5 -ne '$seen{Digest::MD5::md5($_)}++ or print' >output

sort -u big-csv-file.csv > duplicates-removed.csv

Tenga en cuenta que el archivo de salida se ordenará.

Suponiendo que puede permitirse mantener tanto como el archivo desduplicado en la memoria (si sus datos están duplicados por un factor de 100, eso debería ser aproximadamente 20MiB + sobrecarga), puede hacer esto muy fácilmente con Perl.

$ perl -ne 'print unless $dup{$_}++;' input_file > output_file

Esto preserva el orden también.

Si lo desea, puede extraer el número de apariciones de cada línea del %duphash, como un bono gratis adicional.

Si lo prefiere awk, esto también debería hacerlo (la misma lógica que la versión perl, el mismo orden, los mismos datos recopilados en la dupvariable):

$ awk '{if (++dup[$0] == 1) print $0;}' input_file > output_file

Como ninguna otra respuesta proporcionó soporte in situ, aquí hay una:

gawk -i inplace '!a[$0]++' file

Puede usar uniq http://www.computerhope.com/unix/uuniq.htm

uniq informa o filtra líneas repetidas en un archivo.

Forros Python One:

python -c "import sys; lines = sys.stdin.readlines(); print ''.join(sorted(set(lines)))" < InputFile

Ninguna de las respuestas aquí funcionó para mí en mi Mac, así que escribí un simple script de Python que funciona para mí. Estoy ignorando los espacios en blanco iniciales / finales y tampoco me importa el consumo de memoria.

import sys

inputfile = sys.argv[1]
outputfile = sys.argv[2]

with open(inputfile) as f:
    content = f.readlines()

content = [x.strip() for x in content]

my_list = list(set(content))

with open(outputfile, 'w') as output:
    for item in my_list:
        output.write("%s\n" % item)

Guarde lo anterior en unique.py y ejecútelo así:

python unique.py inputfile.txt outputfile.txt

Con bash 4, se puede utilizar una solución de bash puro que aprovecha las matrices asociativas . Aquí hay un ejemplo

unset llist; declare -A llist;
while read -r line; do
if [[ ${llist[$line]} ]]; then
  continue
else 
  printf '%s\n' "$line"
  llist[$line]="x"
fi
done < file.txt