Быстрый способ поиска строк в одном файле, которых нет в другом?

У меня есть два больших файла (наборы имен файлов). Примерно 30.000 строк в каждом файле. Я пытаюсь найти быстрый способ найти строки в file1, которых нет в file2.

Например, если это файл1:

line1
line2
line3

И это файл2:

line1
line4
line5

Тогда мой результат / вывод должен быть:

line2
line3

Это работает:

grep -v -f file2 file1

Но это очень, очень медленно, когда используется на моих больших файлах.

Я подозреваю, что есть хороший способ сделать это с помощью diff (), но на выходе должны быть только строки, ничего больше, и я не могу найти переключатель для этого.

Может кто-нибудь помочь мне найти быстрый способ сделать это, используя bash и базовые бинарные файлы Linux?

РЕДАКТИРОВАТЬ: Чтобы продолжить мой вопрос, это лучший способ, который я нашел до сих пор с использованием diff ():

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

Конечно, должен быть лучший способ?

Вы можете добиться этого, управляя форматированием старых / новых / неизмененных строк в diffвыводе GNU :

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

Входные файлы должны быть отсортированы, чтобы это работало. С помощью bash(и zsh) вы можете отсортировать на месте с заменой процесса <( ):

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

В вышеупомянутых новые и неизмененные строки подавляются, поэтому выводятся только измененные (т.е. удаленные строки в вашем случае). Вы также можете использовать несколько diffвариантов , которые другие решения не предлагают, например , как -iигнорировать случай, или различные варианты пробельные ( -E, -b, и -vт.д.) для менее строгого соответствия.

объяснение

Опции --new-line-format, --old-line-formatи --unchanged-line-formatпозволяют вам контролировать способ diffформатирования различий, аналогично printfспецификаторам формата. Эти параметры форматируют новые (добавленные), старые (удаленные) и неизмененные строки соответственно. Установка одного в "" предотвращает вывод такой линии.

Если вы знакомы с унифицированным форматом diff , вы можете частично восстановить его с помощью:

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

%LСпецификатор линия в вопросе, и мы префикс друг с «+» «-» или «», как diff -u (заметит , что она выводит только различие, это не хватает --- +++и @@линий в верхней части каждых сгруппированных изменений). Вы также можете использовать это , чтобы делать другие полезные вещи , как числа каждой строки с %dn.

diffМетод (наряду с другими предложениями commи join) производить только ожидаемый результат с отсортированным вводом, хотя вы можете использовать <(sort ...)для сортировки на месте. Вот простой awk(nawk) скрипт (навеянный скриптами, связанными в ответе Konsolebox), который принимает произвольно упорядоченные входные файлы и выводит пропущенные строки в порядке их появления в file1.

# 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]
}

При этом все содержимое файла file1 строка за строкой сохраняется в индексированном массиве с номерами строк ll1[], а все содержимое файла file2 строка за строкой - в индексированном ассоциативном массиве с содержимым строк ss2[]. После того, как оба файла прочитаны, выполните итерацию ll1и используйте inоператор, чтобы определить, присутствует ли строка в файле1 в файле2. (Это будет иметь другой вывод для diffметода, если есть дубликаты.)

В случае, если файлы достаточно велики, и их хранение приводит к проблемам с памятью, вы можете обменять ЦП на память, сохранив только файл1 и удалив совпадения по пути при чтении файла2.

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]
}

Выше хранится все содержимое файла file1 в двух массивах, один индексируется по номеру строки ll1[], другой индексируется по содержимому строки ss1[]. Затем, когда file2 читается, каждая совпадающая строка удаляется из ll1[]и ss1[]. В конце выводятся оставшиеся строки из file1, сохраняя исходный порядок.

В этом случае, с указанной выше проблемой, вы также можете разделить и победить, используя GNU split(фильтрация - это расширение GNU), повторяющиеся прогоны с кусками файла file1 и чтением файла file2 каждый раз:

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

Обратите внимание на использование и размещение -значения stdinв gawkкомандной строке. Это обеспечивается splitиз file1 порциями по 20000 строк на вызов.

Для пользователей в системах , не GNU, есть почти наверняка GNU Coreutils пакет можно получить, в том числе на OSX в рамках компании Apple Xcode инструментов , который обеспечивает GNU diff, awkхотя только POSIX / BSD , splitа не версия GNU.

Команда comm (сокращение от «common») может быть полезнойcomm - 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 

manФайл на самом деле вполне читаемый для этого.

Как предложил konsolebox, решение grep для постеров

grep -v -f file2 file1

на самом деле работает отлично (быстро), если вы просто добавляете -Fопцию, чтобы рассматривать шаблоны как фиксированные строки вместо регулярных выражений. Я проверил это на паре списков ~ 1000 строк, которые мне пришлось сравнить. При -Fперенаправлении вывода grep на это потребовалось 0,031 с (реальное), а без 2,278 с (реальное) wc -l.

Эти тесты также включали -xпереключатель, который является необходимой частью решения для обеспечения полной точности в случаях, когда файл2 содержит строки, которые соответствуют части, но не всем, одной или нескольким строкам в файле1.

Таким образом, решение, которое не требует сортировки входных данных, является быстрым, гибким (чувствительность к регистру и т. Д.):

grep -F -x -v -f file2 file1

Это не работает со всеми версиями grep, например, происходит сбой в macOS, где строка в файле 1 будет отображаться как отсутствующая в файле 2, даже если это так, если она соответствует другой строке, которая является ее подстрокой , В качестве альтернативы вы можете установить GNU grep на macOS , чтобы использовать это решение.

какова скорость сортировки и сравнения?

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

Если вам не хватает «причудливых инструментов», например, в каком-то минимальном дистрибутиве Linux, есть решение с просто cat, sortи uniq:

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

Тест:

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    

Это также относительно быстро, по сравнению с grep.

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

Он -tгарантирует, что он сравнивает всю строку, если у вас есть пробел в некоторых строках.

Вы можете использовать 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())
'

Используйте combineиз moreutilsпакета, утилита наборов , которая поддерживает not, and, or, xorоперации

combine file1 not file2

т.е. дайте мне строки, которые находятся в file1, но не в file2

ИЛИ дайте мне строки в файле1 минус строки в файле2

Примечание: combine сортирует и находит уникальные строки в обоих файлах перед выполнением любой операции, но diffне выполняет. Таким образом, вы можете найти различия между выводом diffиcombine .

Итак, по сути вы говорите

Найти отдельные строки в файле1 и файле2, а затем дать мне строки в файле1 минус строки в файле2

По моему опыту, это намного быстрее, чем другие варианты

Может помочь использование fgrep или добавление опции -F в grep. Но для более быстрых вычислений вы можете использовать Awk.

Вы можете попробовать один из этих методов Awk:

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

Обычно я делаю это, используя --suppress-common-linesфлаг, хотя учтите, что это работает, только если вы делаете это в формате рядом друг с другом.

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

Я обнаружил, что для меня использование нормального оператора цикла if и for работает отлично.

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