如何在 Python 中廉价地获取大文件的行数？

Question

我需要在 python 中获取一个大文件（数十万行）的行数。在内存和时间方面最有效的方法是什么？

目前我这样做：

def file_len(fname):
    with open(fname) as f:
        for i, l in enumerate(f):
            pass
    return i + 1

有没有可能做得更好？

Answer 1

你可以执行一个子进程并运行wc -l filename

import subprocess

def file_len(fname):
    p = subprocess.Popen(['wc', '-l', fname], stdout=subprocess.PIPE, 
                                              stderr=subprocess.PIPE)
    result, err = p.communicate()
    if p.returncode != 0:
        raise IOError(err)
    return int(result.strip().split()[0])

Answer 2

def file_len(full_path):
  """ Count number of lines in a file."""
  f = open(full_path)
  nr_of_lines = sum(1 for line in f)
  f.close()
  return nr_of_lines

Answer 3

没有比这更好的了。

毕竟，任何解决方案都必须读取整个文件，计算出您有多少\n，然后返回该结果。

您有没有更好的方法来做到这一点而无需阅读整个文件？不确定...最好的解决方案始终是 I/O-bound，你能做的最好的就是确保你不使用不必要的内存，但看起来你已经涵盖了。

Answer 4

对我来说，这个变种将是最快的：

#!/usr/bin/env python

def main():
    f = open('filename')                  
    lines = 0
    buf_size = 1024 * 1024
    read_f = f.read # loop optimization

    buf = read_f(buf_size)
    while buf:
        lines += buf.count('\n')
        buf = read_f(buf_size)

    print lines

if __name__ == '__main__':
    main()

原因：缓冲比逐行读取快，string.count也很快

Answer 5

打开文件的结果是一个迭代器，可以转换成一个序列，有一个长度：

with open(filename) as f:
   return len(list(f))

这比你的显式循环更简洁，并且避免了enumerate。

Answer 6

这个呢

def file_len(fname):
  counts = itertools.count()
  with open(fname) as f: 
    for _ in f: counts.next()
  return counts.next()

Answer 7

为什么不读取前 100 行和后 100 行并估计平均行长度，然后将总文件大小除以这些数字？如果您不需要确切的值，这可以工作。

Answer 8

我相信内存映射文件将是最快的解决方案。我尝试了四个功能：OP发布的功能（opcount）；对文件中的行进行简单的迭代 (simplecount)；带有内存映射文件 (mmap) (mapcount) 的 readline；以及 Mykola Kharechko (bufcount) 提供的缓冲区读取解决方案。

我对每个函数运行了五次，并计算了一个 120 万行文本文件的平均运行时间。

Windows XP、Python 2.5、2GB RAM、2 GHz AMD 处理器

这是我的结果：

mapcount : 0.465599966049
simplecount : 0.756399965286
bufcount : 0.546800041199
opcount : 0.718600034714

编辑：Python 2.6 的数字：

mapcount : 0.471799945831
simplecount : 0.634400033951
bufcount : 0.468800067902
opcount : 0.602999973297

所以缓冲区读取策略似乎是 Windows/Python 2.6 中最快的

代码如下：

from __future__ import with_statement
import time
import mmap
import random
from collections import defaultdict

def mapcount(filename):
    f = open(filename, "r+")
    buf = mmap.mmap(f.fileno(), 0)
    lines = 0
    readline = buf.readline
    while readline():
        lines += 1
    return lines

def simplecount(filename):
    lines = 0
    for line in open(filename):
        lines += 1
    return lines

def bufcount(filename):
    f = open(filename)                  
    lines = 0
    buf_size = 1024 * 1024
    read_f = f.read # loop optimization

    buf = read_f(buf_size)
    while buf:
        lines += buf.count('\n')
        buf = read_f(buf_size)

    return lines

def opcount(fname):
    with open(fname) as f:
        for i, l in enumerate(f):
            pass
    return i + 1


counts = defaultdict(list)

for i in range(5):
    for func in [mapcount, simplecount, bufcount, opcount]:
        start_time = time.time()
        assert func("big_file.txt") == 1209138
        counts[func].append(time.time() - start_time)

for key, vals in counts.items():
    print key.__name__, ":", sum(vals) / float(len(vals))

Answer 9

一行，可能很快：

num_lines = sum(1 for line in open('myfile.txt'))

Answer 10

为了完成上述方法，我尝试了 fileinput 模块的变体：

import fileinput as fi   
def filecount(fname):
        for line in fi.input(fname):
            pass
        return fi.lineno()

并将一个 6000 万行的文件传递给上述所有方法：

mapcount : 6.1331050396
simplecount : 4.588793993
opcount : 4.42918205261
filecount : 43.2780818939
bufcount : 0.170812129974

令我有点惊讶的是，fileinput 如此糟糕，而且规模远比所有其他方法都要糟糕...

Answer 11

这个呢？

import sys
sys.stdin=open('fname','r')
data=sys.stdin.readlines()
print "counted",len(data),"lines"

Answer 12

为什么以下方法不起作用？

import sys

# input comes from STDIN
file = sys.stdin
data = file.readlines()

# get total number of lines in file
lines = len(data)

print lines

在这种情况下，len 函数使用输入行作为确定长度的方法。

Answer 13

count = max(enumerate(open(filename)))[0]

Answer 14

这个怎么样？

import fileinput
import sys

counter=0
for line in fileinput.input([sys.argv[1]]):
    counter+=1

fileinput.close()
print counter

Answer 15

这是一个 python 程序，它使用多处理库在机器/内核之间分配行数。我的测试使用 8 核 windows 64 服务器将 2000 万行文件的计数从 26 秒提高到 7 秒。注意：不使用内存映射会使事情变得更慢。

import multiprocessing, sys, time, os, mmap
import logging, logging.handlers

def init_logger(pid):
    console_format = 'P{0} %(levelname)s %(message)s'.format(pid)
    logger = logging.getLogger()  # New logger at root level
    logger.setLevel( logging.INFO )
    logger.handlers.append( logging.StreamHandler() )
    logger.handlers[0].setFormatter( logging.Formatter( console_format, '%d/%m/%y %H:%M:%S' ) )

def getFileLineCount( queues, pid, processes, file1 ):
    init_logger(pid)
    logging.info( 'start' )

    physical_file = open(file1, "r")
    #  mmap.mmap(fileno, length[, tagname[, access[, offset]]]

    m1 = mmap.mmap( physical_file.fileno(), 0, access=mmap.ACCESS_READ )

    #work out file size to divide up line counting

    fSize = os.stat(file1).st_size
    chunk = (fSize / processes) + 1

    lines = 0

    #get where I start and stop
    _seedStart = chunk * (pid)
    _seekEnd = chunk * (pid+1)
    seekStart = int(_seedStart)
    seekEnd = int(_seekEnd)

    if seekEnd < int(_seekEnd + 1):
        seekEnd += 1

    if _seedStart < int(seekStart + 1):
        seekStart += 1

    if seekEnd > fSize:
        seekEnd = fSize

    #find where to start
    if pid > 0:
        m1.seek( seekStart )
        #read next line
        l1 = m1.readline()  # need to use readline with memory mapped files
        seekStart = m1.tell()

    #tell previous rank my seek start to make their seek end

    if pid > 0:
        queues[pid-1].put( seekStart )
    if pid < processes-1:
        seekEnd = queues[pid].get()

    m1.seek( seekStart )
    l1 = m1.readline()

    while len(l1) > 0:
        lines += 1
        l1 = m1.readline()
        if m1.tell() > seekEnd or len(l1) == 0:
            break

    logging.info( 'done' )
    # add up the results
    if pid == 0:
        for p in range(1,processes):
            lines += queues[0].get()
        queues[0].put(lines) # the total lines counted
    else:
        queues[0].put(lines)

    m1.close()
    physical_file.close()

if __name__ == '__main__':
    init_logger( 'main' )
    if len(sys.argv) > 1:
        file_name = sys.argv[1]
    else:
        logging.fatal( 'parameters required: file-name [processes]' )
        exit()

    t = time.time()
    processes = multiprocessing.cpu_count()
    if len(sys.argv) > 2:
        processes = int(sys.argv[2])
    queues=[] # a queue for each process
    for pid in range(processes):
        queues.append( multiprocessing.Queue() )
    jobs=[]
    prev_pipe = 0
    for pid in range(processes):
        p = multiprocessing.Process( target = getFileLineCount, args=(queues, pid, processes, file_name,) )
        p.start()
        jobs.append(p)

    jobs[0].join() #wait for counting to finish
    lines = queues[0].get()

    logging.info( 'finished {} Lines:{}'.format( time.time() - t, lines ) )

Answer 16

我已经像这样修改了缓冲区案例：

def CountLines(filename):
    f = open(filename)
    try:
        lines = 1
        buf_size = 1024 * 1024
        read_f = f.read # loop optimization
        buf = read_f(buf_size)

        # Empty file
        if not buf:
            return 0

        while buf:
            lines += buf.count('\n')
            buf = read_f(buf_size)

        return lines
    finally:
        f.close()

现在也计算空文件和最后一行（不带 \n）。

Answer 17

我在这个版本中获得了一个小的 (4-8%) 改进，它重用了一个常量缓冲区，因此它应该避免任何内存或 GC 开销：

lines = 0
buffer = bytearray(2048)
with open(filename) as f:
  while f.readinto(buffer) > 0:
      lines += buffer.count('\n')

您可以调整缓冲区大小，也许会看到一些改进。

Answer 18

同样：

lines = 0
with open(path) as f:
    for line in f:
        lines += 1

Answer 19

这个单线怎么样：

file_length = len(open('myfile.txt','r').read().split('\n'))

使用此方法在 3900 行文件上计时需要 0.003 秒

def c():
  import time
  s = time.time()
  file_length = len(open('myfile.txt','r').read().split('\n'))
  print time.time() - s

Answer 20

我会使用Python的文件对象方法readlines，如下：

with open(input_file) as foo:
    lines = len(foo.readlines())

这将打开文件，在文件中创建行列表，计算列表的长度，将其保存到变量并再次关闭文件。

Answer 21

print open('file.txt', 'r').read().count("\n") + 1

Answer 22

def line_count(path):
    count = 0
    with open(path) as lines:
        for count, l in enumerate(lines, start=1):
            pass
    return count

Answer 23

如果想在 Linux 中用 Python 廉价地获取行数，我推荐这种方法：

import os
print os.popen("wc -l file_path").readline().split()[0]

file_path 既可以是抽象文件路径，也可以是相对路径。希望这可能会有所帮助。

Answer 24

Kyle's answer

num_lines = sum(1 for line in open('my_file.txt'))

可能是最好的，替代方法是

num_lines =  len(open('my_file.txt').read().splitlines())

这是两者的性能比较

In [20]: timeit sum(1 for line in open('Charts.ipynb'))
100000 loops, best of 3: 9.79 µs per loop

In [21]: timeit len(open('Charts.ipynb').read().splitlines())
100000 loops, best of 3: 12 µs per loop

Answer 25

您可以通过以下方式使用os.path 模块：

import os
import subprocess
Number_lines = int( (subprocess.Popen( 'wc -l {0}'.format( Filename ), shell=True, stdout=subprocess.PIPE).stdout).readlines()[0].split()[0] )

，其中Filename 是文件的绝对路径。

Answer 26

我不得不在一个类似的问题上发布这个，直到我的声誉得分有所上升（感谢撞到我的人！）。

所有这些解决方案都忽略了一种使该程序运行得更快的方法，即使用无缓冲（原始）接口、使用字节数组和进行自己的缓冲。 （这只适用于 Python 3。在 Python 2 中，默认情况下可能使用也可能不使用原始接口，但在 Python 3 中，您将默认使用 Unicode。）

使用计时工具的修改版本，我相信以下代码比提供的任何解决方案都更快（并且稍微更 Python 化）：

def rawcount(filename):
    f = open(filename, 'rb')
    lines = 0
    buf_size = 1024 * 1024
    read_f = f.raw.read

    buf = read_f(buf_size)
    while buf:
        lines += buf.count(b'\n')
        buf = read_f(buf_size)

    return lines

使用单独的生成器函数，运行速度更快：

def _make_gen(reader):
    b = reader(1024 * 1024)
    while b:
        yield b
        b = reader(1024*1024)

def rawgencount(filename):
    f = open(filename, 'rb')
    f_gen = _make_gen(f.raw.read)
    return sum( buf.count(b'\n') for buf in f_gen )

这可以通过使用 itertools 内联的生成器表达式来完成，但是看起来很奇怪：

from itertools import (takewhile,repeat)

def rawincount(filename):
    f = open(filename, 'rb')
    bufgen = takewhile(lambda x: x, (f.raw.read(1024*1024) for _ in repeat(None)))
    return sum( buf.count(b'\n') for buf in bufgen )

这是我的时间安排：

function      average, s  min, s   ratio
rawincount        0.0043  0.0041   1.00
rawgencount       0.0044  0.0042   1.01
rawcount          0.0048  0.0045   1.09
bufcount          0.008   0.0068   1.64
wccount           0.01    0.0097   2.35
itercount         0.014   0.014    3.41
opcount           0.02    0.02     4.83
kylecount         0.021   0.021    5.05
simplecount       0.022   0.022    5.25
mapcount          0.037   0.031    7.46

Answer 27

另一种可能性：

import subprocess

def num_lines_in_file(fpath):
    return int(subprocess.check_output('wc -l %s' % fpath, shell=True).strip().split()[0])

Answer 28

这段代码更短更清晰。这可能是最好的方法：

num_lines = open('yourfile.ext').read().count('\n')

Answer 29

这是我使用纯 python 发现的最快的东西。 您可以通过设置缓冲区来使用所需的任何内存量，尽管 2**16 似乎是我计算机上的最佳选择。

from functools import partial

buffer=2**16
with open(myfile) as f:
        print sum(x.count('\n') for x in iter(partial(f.read,buffer), ''))

我在这里找到了答案 Why is reading lines from stdin much slower in C++ than Python? 并稍微调整了一下。虽然wc -l 仍然比其他任何东西快 75% 左右，但它是一本很好的读物，可以了解如何快速计算行数。

Answer 30

一线解决方案：

import os
os.system("wc -l  filename")  

我的sn-p：

>>> os.system('wc -l *.txt')

0 bar.txt
1000 command.txt
3 test_file.txt
1003 total