¿Forma rápida de encontrar líneas en un archivo que no están en otro?

Tengo dos archivos grandes (conjuntos de nombres de archivo). Aproximadamente 30,000 líneas en cada archivo. Estoy tratando de encontrar una forma rápida de encontrar líneas en el archivo1 que no estén presentes en el archivo2.

Por ejemplo, si este es el archivo1:

line1
line2
line3

Y este es el archivo2:

line1
line4
line5

Entonces mi resultado / salida debería ser:

line2
line3

Esto funciona:

grep -v -f file2 file1

Pero es muy, muy lento cuando se usa en mis archivos grandes.

Sospecho que hay una buena manera de hacer esto usando diff (), pero la salida debería ser solo las líneas, nada más, y parece que no puedo encontrar un interruptor para eso.

¿Alguien puede ayudarme a encontrar una manera rápida de hacer esto, usando bash y binarios básicos de Linux?

EDITAR: Para seguir mi propia pregunta, esta es la mejor manera que he encontrado hasta ahora usando diff ():

diff file2 file1 | grep '^>' | sed 's/^>\ //'

Seguramente, debe haber una mejor manera?

Puede lograr esto controlando el formato de las líneas antiguas / nuevas / sin cambios en la diffsalida GNU :

diff --new-line-format="" --unchanged-line-format=""  file1 file2

Los archivos de entrada deben ordenarse para que esto funcione. Con bash(y zsh) puede ordenar en el lugar con la sustitución del proceso <( ):

diff --new-line-format="" --unchanged-line-format="" <(sort file1) <(sort file2)

En lo anterior, las líneas nuevas y sin cambios se suprimen, por lo que solo se emiten las cambiadas (es decir, las líneas eliminadas en su caso). También puede utilizar un par de diffopciones que otras soluciones no ofrecen, tales como -ihacer caso omiso de caso, o varias opciones en blanco ( -E, -b, -vetc) por menos estricta coincidencia.

Explicación

Las opciones --new-line-format, --old-line-formaty --unchanged-line-formatpermiten controlar la forma en que difflos formatos de las diferencias, de forma similar a printflos especificadores de formato. Estas opciones dan formato a líneas nuevas (agregadas), antiguas (eliminadas) y sin cambios respectivamente. Establecer uno para vaciar "" previene la salida de ese tipo de línea.

Si está familiarizado con el formato diff unificado , puede recrearlo en parte con:

diff --old-line-format="-%L" --unchanged-line-format=" %L" \
     --new-line-format="+%L" file1 file2

El %Lespecificador es la línea en cuestión y prefijamos cada uno con "+" "-" o "", como diff -u (tenga en cuenta que solo genera diferencias, carece de las líneas --- +++y @@en la parte superior de cada cambio agrupado). También puede usar esto para hacer otras cosas útiles como numerar cada línea con %dn.

El diffmétodo (junto con otras sugerencias commy join) solo produce la salida esperada con la entrada ordenada , aunque puede usar <(sort ...)para ordenar en el lugar. Aquí hay un awkscript simple (nawk) (inspirado en los scripts vinculados a la respuesta de Konsolebox) que acepta archivos de entrada ordenados arbitrariamente y genera las líneas que faltan en el orden en que aparecen en el archivo1.

# output lines in file1 that are not in file2
BEGIN { FS="" }                         # preserve whitespace
(NR==FNR) { ll1[FNR]=$0; nl1=FNR; }     # file1, index by lineno
(NR!=FNR) { ss2[$0]++; }                # file2, index by string
END {
    for (ll=1; ll<=nl1; ll++) if (!(ll1[ll] in ss2)) print ll1[ll]
}

Esto almacena todo el contenido del archivo1 línea por línea en una matriz indexada de número de línea ll1[], y todo el contenido del archivo2 línea por línea en una matriz asociativa indexada de contenido de línea ss2[]. Después de leer ambos archivos, repita ll1y use el inoperador para determinar si la línea en el archivo1 está presente en el archivo2. (Esto tendrá un resultado diferente para el diffmétodo si hay duplicados).

En el caso de que los archivos sean lo suficientemente grandes como para almacenarlos y causar un problema de memoria, puede cambiar la CPU por memoria almacenando solo el archivo1 y eliminando coincidencias a medida que se lee el archivo2.

BEGIN { FS="" }
(NR==FNR) {  # file1, index by lineno and string
  ll1[FNR]=$0; ss1[$0]=FNR; nl1=FNR;
}
(NR!=FNR) {  # file2
  if ($0 in ss1) { delete ll1[ss1[$0]]; delete ss1[$0]; }
}
END {
  for (ll=1; ll<=nl1; ll++) if (ll in ll1) print ll1[ll]
}

Lo anterior almacena todo el contenido del archivo1 en dos matrices, una indexada por número de línea ll1[]y otra indexada por contenido de línea ss1[]. Luego, a medida que se lee el archivo2, cada línea coincidente se elimina de ll1[]y ss1[]. Al final, salen las líneas restantes del archivo1, conservando el orden original.

En este caso, con el problema como se indicó, también puede dividir y conquistar usando GNU split(el filtrado es una extensión de GNU), ejecuciones repetidas con fragmentos de archivo1 y lectura de archivo2 completamente cada vez:

split -l 20000 --filter='gawk -f linesnotin.awk - file2' < file1

Tenga en cuenta el uso y la ubicación del -significado stdinen la gawklínea de comando. Esto lo proporciona splitfrom file1 en fragmentos de 20000 líneas por invocación.

Para los usuarios en los sistemas no GNU, es casi seguro que un paquete GNU coreutils puede obtener, incluso en OSX como parte de los de Apple Xcode herramientas que proporciona GNU diff, awk, aunque sólo un POSIX / BSD spliten lugar de una versión de GNU.

El comando comm (abreviatura de "común") puede ser útilcomm - compare two sorted files line by line

#find lines only in file1
comm -23 file1 file2 

#find lines only in file2
comm -13 file1 file2 

#find lines common to both files
comm -12 file1 file2 

El manarchivo es realmente bastante legible para esto.

Como sugirió konsolebox, la solución grep de carteles

grep -v -f file2 file1

en realidad funciona muy bien (rápido) si simplemente agrega la -Fopción, para tratar los patrones como cadenas fijas en lugar de expresiones regulares. Verifiqué esto en un par de ~ 1000 listas de archivos de líneas que tuve que comparar. Con -Festo tomó 0.031 s (real), mientras que sin tomó 2.278 s (real), al redirigir la salida grep a wc -l.

Estas pruebas también incluyeron el -xinterruptor, que son parte necesaria de la solución para garantizar una precisión total en los casos en que el archivo 2 contiene líneas que coinciden con una, o no todas, una o más líneas en el archivo 1.

Entonces, una solución que no requiere que se ordenen las entradas, es rápida y flexible (mayúsculas y minúsculas, etc.) es:

grep -F -x -v -f file2 file1

Esto no funciona con todas las versiones de grep, por ejemplo, falla en macOS, donde una línea en el archivo 1 se mostrará como no presente en el archivo 2, aunque lo sea, si coincide con otra línea que es una subcadena del mismo . Alternativamente, puede instalar GNU grep en macOS para usar esta solución.

¿Cuál es la velocidad de como sort y diff?

sort file1 -u > file1.sorted
sort file2 -u > file2.sorted
diff file1.sorted file2.sorted

Si estás corto de "herramientas de fantasía", por ejemplo en alguna distribución de Linux mínimo, hay una solución con sólo cat, sorty uniq:

cat includes.txt excludes.txt excludes.txt | sort | uniq --unique

Prueba:

seq 1 1 7 | sort --random-sort > includes.txt
seq 3 1 9 | sort --random-sort > excludes.txt
cat includes.txt excludes.txt excludes.txt | sort | uniq --unique

# Output:
1
2    

Esto también es relativamente rápido, en comparación con grep.

$ join -v 1 -t '' file1 file2
line2
line3

El -tse asegura de que compara toda la línea, si tenía un espacio en algunas de las líneas.

Puedes usar Python:

python -c '
lines_to_remove = set()
with open("file2", "r") as f:
    for line in f.readlines():
        lines_to_remove.add(line.strip())

with open("f1", "r") as f:
    for line in f.readlines():
        if line.strip() not in lines_to_remove:
            print(line.strip())
'

Utilizar combinede moreutilspaquete, una utilidad que soporta conjuntos not, and, or, xoroperaciones

combine file1 not file2

es decir, dame líneas que estén en el archivo 1 pero no en el archivo 2

O dame líneas en el archivo1 menos líneas en el archivo2

Nota: combine ordena y encuentra líneas únicas en ambos archivos antes de realizar cualquier operación, pero diffno lo hace. Por lo tanto, puede encontrar diferencias entre la salida de diffy combine.

Entonces, en efecto, estás diciendo

Encuentra líneas distintas en archivo1 y archivo2 y luego dame líneas en archivo1 menos líneas en archivo2

En mi experiencia, es mucho más rápido que otras opciones

El uso de fgrep o agregar la opción -F a grep podría ayudar. Pero para cálculos más rápidos, podría usar Awk.

Puede probar uno de estos métodos Awk:

http://www.linuxquestions.org/questions/programming-9/grep-for-huge-files-826030/#post4066219

La forma en que generalmente hago esto es usando la --suppress-common-linesbandera, aunque tenga en cuenta que esto solo funciona si lo hace en formato de lado a lado.

diff -y --suppress-common-lines file1.txt file2.txt

Encontré que para mí usar una instrucción de bucle if y for normal funcionó perfectamente.

for i in $(cat file2);do if [ $(grep -i $i file1) ];then echo "$i found" >>Matching_lines.txt;else echo "$i missing" >>missing_lines.txt ;fi;done