计算文件中的行数而不将整个文件读入内存？

Question

我正在处理巨大的数据文件（每个文件数百万行）。

在我开始处理之前，我想对文件中的行数进行计数，这样我就可以指出处理的进度。

由于文件的大小，将整个文件读入内存是不切实际的，仅仅计算有多少行。 有没有人有关于如何做到这一点的好建议？

Answer 1

一次读取一行文件：

count = File.foreach(filename).inject(0) {|c, line| c+1}

或 Perl-ish

File.foreach(filename) {}
count = $.

或者

count = 0
File.open(filename) {|f| count = f.read.count("\n")}

会比

count = %x{wc -l #{filename}}.split.first.to_i

Answer 2

如果您在 Unix 环境中，您可以让wc -l完成这项工作。

它不会将整个文件加载到内存中； 由于它针对流文件和计算字/行进行了优化，因此性能足够好，而不是自己在 Ruby 中流文件。

SSCCE：

filename = 'a_file/somewhere.txt'
line_count = `wc -l "#{filename}"`.strip.split(' ')[0].to_i
p line_count

或者，如果您想要在命令行上传递的文件集合：

wc_output = `wc -l "#{ARGV.join('" "')}"`
line_count = wc_output.match(/^ *([0-9]+) +total$/).captures[0].to_i
p line_count

Answer 3

无论您使用哪种语言，如果行的长度可变，您将不得不读取整个文件。 那是因为换行符可以在任何地方，如果不读取文件就无法知道（假设它没有被缓存，一般来说不是）。

如果你想表明进展，你有两个现实的选择。 您可以根据假定的行长推断进度：

assumed lines in file = size of file / assumed line size
progress = lines processed / assumed lines in file * 100%

因为你知道文件的大小。 或者，您可以将进度衡量为：

progress = bytes processed / size of file * 100%

这应该足够了。

Answer 4

使用红宝石：

file=File.open("path-to-file","r")
file.readlines.size

在 325.477 行的文件上比 wc -l 快 39 毫秒

Answer 5

已发布解决方案的摘要

require 'benchmark'
require 'csv'

filename = "name.csv"

Benchmark.bm do |x|
  x.report { `wc -l < #{filename}`.to_i }
  x.report { File.open(filename).inject(0) { |c, line| c + 1 } }
  x.report { File.foreach(filename).inject(0) {|c, line| c+1} }
  x.report { File.read(filename).scan(/\n/).count }
  x.report { CSV.open(filename, "r").readlines.count }
end

包含 807802 行的文件：

       user     system      total        real
   0.000000   0.000000   0.010000 (  0.030606)
   0.370000   0.050000   0.420000 (  0.412472)
   0.360000   0.010000   0.370000 (  0.374642)
   0.290000   0.020000   0.310000 (  0.315488)
   3.190000   0.060000   3.250000 (  3.245171)

Answer 6

与 DJ 的回答相同，但给出了实际的 Ruby 代码：

count = %x{wc -l file_path}.split[0].to_i

第一部分

wc -l file_path

给你

num_lines file_path

split和to_i将其放入一个数字中。

Answer 7

免责声明：已经存在的基准测试使用count而不是length或size ，并且阅读恕我直言很乏味。 因此，这个新答案。

基准

require "benchmark"
require "benchmark/ips"
require "csv"

filename = ENV.fetch("FILENAME")

Benchmark.ips do |x|
  x.report("wc") { `wc -l #{filename}`.to_i }
  x.report("open") { File.open(filename).inject(0, :next) }
  x.report("foreach") { File.foreach(filename).inject(0, :next) }
  x.report("foreach $.") { File.foreach(filename) {}; $. }
  x.report("read.scan.length") { File.read(filename).scan(/\n/).length }
  x.report("CSV.open.readlines") { CSV.open(filename, "r").readlines.length }
  x.report("IO.readlines.length") { IO.readlines(filename).length }

  x.compare!
end

在配备 2.3 GHz Intel Core i5 处理器的 MacBook Pro（2017）上：

Warming up --------------------------------------
                  wc     8.000  i/100ms
                open     2.000  i/100ms
             foreach     2.000  i/100ms
          foreach $.     2.000  i/100ms
    read.scan.length     2.000  i/100ms
  CSV.open.readlines     1.000  i/100ms
 IO.readlines.length     2.000  i/100ms
Calculating -------------------------------------
                  wc    115.014  (±21.7%) i/s -    552.000  in   5.020531s
                open     22.450  (±26.7%) i/s -    104.000  in   5.049692s
             foreach     32.669  (±27.5%) i/s -    150.000  in   5.046793s
          foreach $.     25.244  (±31.7%) i/s -    112.000  in   5.020499s
    read.scan.length     44.102  (±31.7%) i/s -    190.000  in   5.033218s
  CSV.open.readlines      2.395  (±41.8%) i/s -     12.000  in   5.262561s
 IO.readlines.length     36.567  (±27.3%) i/s -    162.000  in   5.089395s

Comparison:
                  wc:      115.0 i/s
    read.scan.length:       44.1 i/s - 2.61x  slower
 IO.readlines.length:       36.6 i/s - 3.15x  slower
             foreach:       32.7 i/s - 3.52x  slower
          foreach $.:       25.2 i/s - 4.56x  slower
                open:       22.4 i/s - 5.12x  slower
  CSV.open.readlines:        2.4 i/s - 48.02x  slower

这是用一个包含 75 516 行和 3 532 510 个字符（每行约 47 个字符）的文件制作的。 您应该使用您自己的文件/尺寸和计算机尝试此操作以获得精确的结果。

Answer 8

由于我不完全理解的原因，使用File扫描文件的换行符似乎比执行CSV#readlines.count快得多。

以下基准测试使用了一个包含 1,045,574 行数据和 4 列的 CSV 文件：

       user     system      total        real
   0.639000   0.047000   0.686000 (  0.682000)
  17.067000   0.171000  17.238000 ( 17.221173)

基准测试的代码如下：

require 'benchmark'
require 'csv'

file = "1-25-2013 DATA.csv"

Benchmark.bm do |x|
    x.report { File.read(file).scan(/\n/).count }
    x.report { CSV.open(file, "r").readlines.count }
end

如您所见，扫描文件中的换行速度快了一个数量级。

Answer 9

我有这个衬里。

puts File.foreach('myfile.txt').count

Answer 10

超过 135k 行的测试结果如下所示。 这是我的基准代码。

 file_name = '100m.csv'
 Benchmark.bm do |x|
   x.report { File.new(file_name).readlines.size }
   x.report { `wc -l "#{file_name}"`.strip.split(' ')[0].to_i }
   x.report { File.read(file_name).scan(/\n/).count }
 end

结果是

   user     system      total        real
 0.100000   0.040000   0.140000 (  0.143636)
 0.000000   0.000000   0.090000 (  0.093293)
 0.380000   0.060000   0.440000 (  0.464925)

wc -l代码有一个问题。 如果文件中只有一行并且最后一个字符不以\\n结尾，则计数为零。

因此，我建议当您数到超过一行时调用 wc。

Answer 11

如果文件是 CSV 文件，如果文件的内容是数字，则记录的长度应该非常一致。 将文件的大小除以记录的长度或前 100 条记录的平均值是否有意义。

Answer 12

使用 UNIX 风格的文本文件，非常简单

f = File.new("/path/to/whatever")
num_newlines = 0
while (c = f.getc) != nil
  num_newlines += 1 if c == "\n"
end

就是这样。 对于 MS Windows 文本文件，您必须检查“\\r\\n”序列，而不仅仅是“\\n”，但这并不困难。 对于 Mac OS Classic 文本文件（与 Mac OS X 相对），您将检查“\\r”而不是“\\n”。

所以，是的，这看起来像 C。那又怎样？ C 很棒，而 Ruby 很棒，因为当 C 答案最简单时，这就是您可以期望 Ruby 代码的样子。 希望您的 dain 还没有被 Java 吹嘘。

顺便说一句，请不要考虑上面使用IO#read或IO#readlines方法依次调用 String 方法读取内容的任何答案。 您说您不想将整个文件读入内存，而这正是它们所做的。 这就是为什么 Donald Knuth 建议人们了解如何更接近硬件进行编程，因为如果他们不这样做，他们最终会编写“奇怪的代码”。 显然，您不想在不必要的时候靠近硬件进行编码，但这应该是常识。 然而，你应该学会识别你必须更接近细节的实例，比如这个。

并且不要试图获得比情况所要求的更多的“面向对象”。 对于想要看起来比实际情况更复杂的新手来说，这是一个令人尴尬的陷阱。 当答案真的很简单时，您应该总是感到高兴，而当没有复杂性让您有机会编写“令人印象深刻”的代码时，不要失望。 但是，如果您想看起来有点“面向对象”并且不介意一次将整行读入内存（即，您知道这些行足够短），您可以这样做

f = File.new("/path/to/whatever")
num_newlines = 0
f.each_line do
  num_newlines += 1
end

这将是一个很好的折衷方案，但前提是线路不太长，在这种情况下，它甚至可能比我的第一个解决方案运行得更快。

Answer 13

在不使用inject情况下使用foreach比使用inject快约 3%。 两者都比使用getc快得多（以我的经验超过 100 倍）。

使用不带inject foreach也可以稍微简化（相对于本线程中其他地方给出的代码段），如下所示：

count = 0;  File.foreach(path) { count+=1}
puts "count: #{count}"

Answer 14

wc -l在内存较少的 Ruby 中，懒惰的方法：

(ARGV.length == 0 ?
 [["", STDIN]] :
    ARGV.lazy.map { |file_name|
        [file_name, File.open(file_name)]
})
.map { |file_name, file|
    "%8d %s\n" % [*file
                    .each_line
                    .lazy
                    .map { |line| 1 }
                    .reduce(:+), file_name]
}
.each(&:display)

正如前田修悟最初展示的那样。

例子：

$ curl -s -o wc.rb -L https://git.io/vVrQi
$ chmod u+x wc.rb
$ ./wc.rb huge_data_file.csv
  43217291 huge_data_file.csv

Answer 15

您只能阅读最后一行并查看其编号：

f = File.new('huge-file')
f.readlines[-1]
count = f.lineno