按行号过滤文件

给定一个文件L，每行一个非负整数，并且文本文件F，那么仅将行号出现在文件L中的那些行保留在F中的快速方法是什么？

例：

$ cat L.txt
1
3

$ cat F.txt
Hello World
Hallo Welt
Hola mundo

$ command-in-question -x L.txt F.txt
Hello World
Hola mundo

我正在寻找一个可以处理具有5亿或更多条目的文件L的命令；文件L按数字排序。

注意：我已经完成了的实现的一半，command-in-question但是我只是想知道，这里是否也可以使用某些Unix工具。

更新：感谢您提供所有答案，我今天学到了很多东西！我想接受一个以上的答案，但这是不可能的。

随着C省略有意义的错误信息：

#include <stdio.h>
#include <stdlib.h>

int main (int argc, char *argv[]) {

    FILE *L;
    FILE *F;

    unsigned int to_print;
    unsigned int current = 0;
    char *line = NULL;
    size_t len = 0;

    if ((L = fopen(argv[1], "r")) == NULL) {
        return 1;
    } else if ((F = fopen(argv[2], "r")) == NULL) {
        fclose(L);
        return 1;
    } else {

        while (fscanf(L, "%u", &to_print) > 0) {
            while (getline(&line, &len, F) != -1 && ++current != to_print);
            if (current == to_print) {
                printf("%s", line);
            }
        }

        free(line);
        fclose(L);
        fclose(F);
        return 0;
    }
}

我会使用awk，但不会将的全部内容存储L.txt在内存中，并进行不必要的哈希查找；-)。

list=L.txt file=F.txt
LIST="$list" awk '
  function nextline() {
    if ((getline n < list) <=0) exit
  }
  BEGIN{
    list = ENVIRON["LIST"]
    nextline()
  }
  NR == n {
    print
    nextline()
  }' < "$file"

grep -n | sort | sed | cut

(   export LC_ALL=C
    grep -n ''   | sort -t:  -nmk1,1 ./L - |
    sed /:/d\;n  | cut  -sd: -f2-
)   <./F

无论输入什么大小，它都应该可以很快地工作（下面包括一些定时测试）。有关如何的一些注意事项：

• export LC_ALL=C
  • 因为以下操作的重点是使整个文件./F与其./Llineno的文件内联，所以我们真正需要担心的唯一字符是ASCII [0-9]数字和:冒号。
  • 因此，担心是否要在一组128种可能的字符中找到这11个字符比使用UTF-8时要容易得多。
• grep -n ''
  • 这会将字符串LINENO:插入到stdin-或中的每一行的开头<./F。
• sort -t: -nmk1,1 ./L -
  • sort根本不考虑对其输入文件进行排序，而是（正确地）假定它们已-m预先-numerically排序并按排序顺序合并它们，而基本上忽略了任何可能-k1,1出现的-t:冒号字符。
  • 尽管这可能需要一些临时空间（取决于某些序列可能发生的间隔），但与适当的排序相比并不需要太多，并且它非常快，因为它涉及零回溯。
  • sort将输出单个流，其中任何lineno都./L将紧接在中的相应行之前./F。./L的行始终排在最前面，因为它们较短。
• sed /:/d\;n
  • 如果当前行与/:/冒号匹配，d则将其从输出中删除。否则，自动打印当前n行和外部行。
  • 因此，将sedprunes sort的输出仅输出到与冒号和下一行不匹配的顺序行对-或仅输出到./L然后是下一行的行。
• cut -sd: -f2-
  • cut -s从输出中压制不包含其至少一个-d:分隔符字符串之一的输入行-从而./L完全修剪了的行。
  • 对于这些行，它们的第一个:冒号分隔的字段-f就cut消失了-所有grep插入的行号也都消失了。

小输入测试

seq 5 | sed -ne'2,3!w /tmp/L
        s/.*/a-z &\& 0-9/p' >/tmp/F

...生成5行样本输入。然后...

(   export LC_ALL=C; </tmp/F \
    grep -n ''   | sort -t:  -nmk1,1 ./L - |
    sed /:/d\;n  | cut  -sd: -f2-
)|  head - /tmp[FL]

...印刷品...

==> standard input <==
a-z 1& 0-9
a-z 4& 0-9
a-z 5& 0-9

==> /tmp/F <==
a-z 1& 0-9
a-z 2& 0-9
a-z 3& 0-9
a-z 4& 0-9
a-z 5& 0-9

==> /tmp/L <==
1
4
5

更大的定时测试

我创建了几个非常大的文件：

seq 5000000 | tee /tmp/F |
sort -R | head -n1500000 |
sort -n >/tmp/L

...将500万行放入其中，并将150万行/tmp/F随机选择放入/tmp/L。然后我做了：

time \
(   export LC_ALL=C
    grep -n ''   | sort -t:  -nmk1,1 ./L - |
    sed /:/d\;n  | cut  -sd: -f2-
)   <./F |wc - l

它打印：

1500000
grep -n '' \
    0.82s user 0.05s system 73% cpu 1.185 total
sort -t: -nmk1,1 /tmp/L - \
    0.92s user 0.11s system 86% cpu 1.185 total
sed /:/d\;n \
    1.02s user 0.14s system 98% cpu 1.185 total
cut -sd: -f2- \
    0.79s user 0.17s system 80% cpu 1.184 total
wc -l \
    0.05s user 0.07s system 10% cpu 1.183 total

（我在那里添加了反斜杠）

在这里当前提供的解决方案中，这是所有解决方案中最快的，但是与我机器上上面生成的数据集相提并论。在其他人中，只有一个接近争夺第二名，那就是perl 在这里。

这绝不是原始的解决方案-由于其他人的建议/启发，它减少了执行时间的三分之一。有关较慢的解决方案，请参见发布历史记录（但是为什么？）。

另外，值得注意的是，如果不是针对我系统的多CPU体系结构以及该管道中每个进程的并发执行，则其他答案可能会更好。它们都在同一时间工作-每个都在自己的处理器核心上-传递数据并处理整个数据的一小部分。它太酷了。

但是最快的解决方案是...

但这不是最快的解决方案。这里提供的最快的解决方案是C程序。我叫它cselect。将其复制到X剪贴板后，我将其编译为：

xsel -bo | cc -xc - -o cselect

然后我做了：

time \
    ./cselect /tmp/L /tmp/F |
wc -l

...结果是...

1500000
./cselect /tmp/L /tmp/F  \
    0.50s user 0.05s system 99% cpu 0.551 total
wc -l \
    0.05s user 0.05s system 19% cpu 0.551 total

我会用awk：

awk 'NR==FNR {a[$1]; next}; FNR in a' L.txt F.txt

更新：我已经做了绩效评估；似乎此版本可在非常大的数据集（如所述要求的情况）下更好地扩展，因为比较非常快并且过度补偿了构建哈希表所需的工作。

仅出于完整性考虑：我们可以将StéphaneChazelas的答案中优秀的awk脚本与kos的答案中的perl脚本合并，但不将整个列表都存储在内存中，希望perl可能比awk更快。（我已更改了args的顺序以匹配原始问题）。

#!/usr/bin/env perl
use strict;

die "Usage: $0 l f\n" if $#ARGV+1 != 2;
open(L,$ARGV[0]) or die "$ARGV[0]: $!";
open(F,$ARGV[1]) or die "$ARGV[1]: $!";

while(my $number = <L>){
    #chop $number;
    while (<F>) {
        if($. == $number){
            print;
            last;
        }
    }
}

我写了一个简单的Perl脚本来做到这一点：

Usage: script.pl inputfile_f inputfile_f

#!/usr/bin/env perl

$number_arguments = $#ARGV + 1;
if ($number_arguments != 2) {
    die "Usage: script.pl inputfile_f inputfile_l\n";
}

open($f, '<', $ARGV[0])
    or die "$ARGV[0]: Not found\n";
open($l, '<', $ARGV[1])
    or die "$ARGV[1]: Not found\n";

@line_numbers = <$l>;

while ($line = <$f>) {
    $count_f ++;
    if ($count_f == @line_numbers[$count_l]) {
        print $line;
        $count_l ++;
    }
}

• 负荷 F.txt
• 负荷 L.txt
• 将每一行存储L.txt到一个数组中
• F.txt逐行读取，跟踪其当前行号和当前数组索引；增加F.txt当前行号；如果F.txt当前行号与当前数组索引处的数组内容匹配，它将打印当前行并增加索引

成本和复杂性考虑：

考虑到进行分配的成本，进行比较的成本以及打印行的成本，给定N ₁作为in中的行数，F.txtN ₂作为in中的行数L.txt，while循环最多运行N ₁次，导致2N ₁ + N ₂分配（显然假设N ₁ > N ₂），2N ₁比较和N ₂打印；给定与每个操作相同的成本，运行while循环的总成本为4N ₁ + 2N ₂，这导致O（N）脚本的复杂性。

测试一千万行的输入文件：

使用一个1000万行的F.txt文件，其中包含随机的50个字符长的行，以及一个1000万行的L.txt文件，其中包含从1到10000000的数字（最坏的情况）：

~/tmp$ for ((i=0; i<3; i++)); do time ./script.pl F.txt L.txt > output; done

real    0m15.628s
user    0m13.396s
sys 0m2.180s

real    0m16.001s
user    0m13.376s
sys 0m2.436s

real    0m16.153s
user    0m13.564s
sys 0m2.304s

该perl解决方案比其他awk或perl解决方案快20％左右，但显然不及C中的解决方案快。

perl -e '
  open L, shift or die $!;
  open F, shift or die $!;
  exit if ! ($n = <L>);
  while (1) {
    $_ = <F>;
    next if $. != $n;
    print;
    exit if ! ($n = <L>);
  }
' -- L F

cat <<! >L.txt
1
3
!

cat <<! >F.txt
Hello World
Hallo Welt
Hola mundo
!

cmd(){
 L=$1 F=$2
 cat -n $F |
 join $L - |
 sed 's/[^ ]* //'
}

cmd L.txt F.txt
Hello World
Hola mundo

由于L.txt已排序，因此您可以使用join。只需为F.txt中的每一行编号，将两个文件合并，然后删除行号即可。不需要大的中间文件。

实际上，以上内容将通过用一个空格替换所有空格来破坏您的数据线。为了使行保持完整，您需要选择一些未出现在数据中的字符作为分隔符，例如“ |”。然后是

cmd(){
 L=$1 F=$2
 cat -n $F |
 sed 's/^ *//;s/\t/|/' |
 join -t'|' $L - |
 sed 's/[^|]*|//'
}

第一个sed从“ cat -n”输出中删除前导空格并替换选项卡。第二个sed删除行号和“ |”。

为了完整性，join解决方案的另一种尝试：

sed -r 's/^/00000000000000/;s/[0-9]*([0-9]{15})/\1/' /tmp/L | join <( nl -w15 -nrz /tmp/F ) - | cut -d' ' -f2-

这是通过将连接的行号列格式化为固定长度并以前导零表示的，从而使数字始终为15位数字。这避免了联接不喜欢常规数值排序顺序的问题，因为该列现在已被有效地强制为字典排序。 nl用于将这种格式的行号添加到F.txt。不幸sed需要用于重新格式化L.txt中的编号。

这种方法对于使用@mikeserv方法生成的测试数据似乎可以正常工作。但是它仍然非常慢-C解决方案在我的机器上快60倍。大约2/3的时间用在了sed1/3英寸中join。也许有更好的sed表达...

由于接受的答案在C中，因此我认为可以在此处抛出python解决方案：

# Read mask
with open('L.txt', 'r') as f:
    mask = [int(line_num) for line_num in f.read().splitlines()]

# Filter input file
filtered_lines = []
with open('F.txt', 'r') as f:
    for i, line in enumerate(f.read().splitlines()):
        if (i+1) in mask:
            filtered_lines.append(line)

# Write newly filtered file
with open('F_filtered.txt', 'w') as f:
    for line in filtered_lines:
        f.write('%s\n' % line)

如果使用像numpy这样的外部库，则解决方案看起来会更加精致：

import numpy as np

with open('L.txt', 'r') as f:
    mask = np.array([int(line_num)-1 for line_num in f.read().splitlines()])

with open('F.txt', 'r') as f:
    lines = np.array(f.read().splitlines())
filtered_lines = lines[mask]

with open('F_filtered.txt', 'w') as f:
    for line in filtered_lines:
        f.write('%s\n' % line)