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

Question

如何以最节省内存和时间的方式获取大文件的行数？

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

Answer 1

一行，比OP的for循环更快（尽管不是最快）并且非常简洁：

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

您还可以通过使用提高速度（和鲁棒性） rbU 模式并将其包含在 with 块中以关闭文件：

with open("myfile.txt", "rbU") as f:
    num_lines = sum(1 for _ in f)

注意： 中的 U rbU 模式自 Python 3.3 及更高版本起已被弃用，因此我们应该使用 rb 而不是 rbU （它已在 Python 3.11)。

Answer 2

没有比这更好的了。

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

您是否有更好的方法来做到这一点而不读取整个文件？ 不确定...最好的解决方案总是受 I/O 限制，您能做的最好的事情就是确保不使用不必要的内存，但看起来您已经涵盖了这一点。

[2023 年 5 月编辑]

正如许多其他答案中所评论的那样，Python 3 中有更好的替代方案。 for 循环并不是最有效的。 例如，使用 mmap 或缓冲区更有效。

Answer 3

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

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

Windows XP、Python 2.5、2 GB 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):
    with open(filename, "r+") as f:
        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 4

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

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

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 5

您可以执行子进程并运行 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 6

经过 perfplot 分析后，我们必须推荐缓冲读取解决方案，

def buf_count_newlines_gen(fname):
    def _make_gen(reader):
        while True:
            b = reader(2 ** 16)
            if not b: break
            yield b

    with open(fname, "rb") as f:
        count = sum(buf.count(b"\n") for buf in _make_gen(f.raw.read))
    return count

它速度快且内存效率高。 大多数其他解决方案的速度要慢 20 倍左右。

---

重现情节的代码：

import mmap
import subprocess
from functools import partial

import perfplot


def setup(n):
    fname = "t.txt"
    with open(fname, "w") as f:
        for i in range(n):
            f.write(str(i) + "\n")
    return fname


def for_enumerate(fname):
    i = 0
    with open(fname) as f:
        for i, _ in enumerate(f):
            pass
    return i + 1


def sum1(fname):
    return sum(1 for _ in open(fname))


def mmap_count(fname):
    with open(fname, "r+") as f:
        buf = mmap.mmap(f.fileno(), 0)

    lines = 0
    while buf.readline():
        lines += 1
    return lines


def for_open(fname):
    lines = 0
    for _ in open(fname):
        lines += 1
    return lines


def buf_count_newlines(fname):
    lines = 0
    buf_size = 2 ** 16
    with open(fname) as f:
        buf = f.read(buf_size)
        while buf:
            lines += buf.count("\n")
            buf = f.read(buf_size)
    return lines


def buf_count_newlines_gen(fname):
    def _make_gen(reader):
        b = reader(2 ** 16)
        while b:
            yield b
            b = reader(2 ** 16)

    with open(fname, "rb") as f:
        count = sum(buf.count(b"\n") for buf in _make_gen(f.raw.read))
    return count


def wc_l(fname):
    return int(subprocess.check_output(["wc", "-l", fname]).split()[0])


def sum_partial(fname):
    with open(fname) as f:
        count = sum(x.count("\n") for x in iter(partial(f.read, 2 ** 16), ""))
    return count


def read_count(fname):
    return open(fname).read().count("\n")


b = perfplot.bench(
    setup=setup,
    kernels=[
        for_enumerate,
        sum1,
        mmap_count,
        for_open,
        wc_l,
        buf_count_newlines,
        buf_count_newlines_gen,
        sum_partial,
        read_count,
    ],
    n_range=[2 ** k for k in range(27)],
    xlabel="num lines",
)
b.save("out.png")
b.show()

Answer 7

类似于这个答案的单行 Bash 解决方案，使用现代的 subprocess.check_output 函数：

def line_count(filename):
    return int(subprocess.check_output(['wc', '-l', filename]).split()[0])

Answer 8

这是一个使用多处理库在机器/核心之间分配行计数的 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 9

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

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

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

Answer 10

这是我发现使用纯 Python 最快的事情。

您可以通过设置 buffer 使用任意数量的内存，尽管 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), ''))

我在这里找到了答案 为什么要阅读C++ 中来自 stdin 的行比 Python 慢得多？ 并对其进行了一点点调整。 尽管 wc -l 仍然比其他任何方法快大约 75%，但对于了解如何快速计算行数来说，这是一本非常好的读物。

Answer 11

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 12

这是我使用的，它看起来很干净：

import subprocess

def count_file_lines(file_path):
    """
    Counts the number of lines in a file using wc utility.
    :param file_path: path to file
    :return: int, no of lines
    """
    num = subprocess.check_output(['wc', '-l', file_path])
    num = num.split(' ')
    return int(num[0])

这比使用纯 Python 稍微快一些，但以内存使用为代价。 子进程在执行命令时将分叉一个与父进程具有相同内存占用的新进程。

Answer 13

一行解决方案：

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

我的代码片段：

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

输出：

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

Answer 14

凯尔的答案

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 15

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

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

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

Answer 16

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

#!/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 17

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

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

Answer 18

只是为了完成之前答案中的方法，我尝试了 fileinput 模块的变体：

import fileinput as fi   

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

并将一个 6000 万行文件传递给之前答案中的所有所述方法：

mapcount:    6.13
simplecount: 4.59
opcount:     4.43
filecount:  43.3
bufcount:    0.171

令我感到有点惊讶的是 fileinput 如此糟糕并且规模如此之大比所有其他方法更糟糕...

Answer 19

我已经修改了这样的缓冲区情况：

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 20

已经有很多答案具有很好的时序比较，但我相信他们只是查看行数来衡量性能（例如，伟大的图来自 Nico Schlömer）。

为了在衡量性能时准确，我们应该查看：

• 行数 行
• 的平均大小
• ... 文件的最终总大小（这可能会影响内存）

首先，OP 的功能（带有一个for) 和函数 sum(1 for line in f) 的表现不太好...

好的竞争者是 mmap 或 >缓冲区。

总结一下：根据我的分析（带 SSD 的 Windows 上的 Python 3.9）：

1. 对于行相对较短（100 个字符以内）的大文件：使用带有缓冲区的函数 buf_count_newlines_gen

   def buf_count_newlines_gen(fname: str) ->   整数： 
         """计算文件中的行数""" 
         def _make_gen（阅读器）： 
             b = 读取器(1024 * 1024) 
             而b： 
                 产量b 
                 b = 读取器(1024 * 1024) 
   
         将 open(fname, "rb") 作为 f： 
             count = sum(buf.count(b"\n") for buf in _make_gen(f.raw.read)) 
         返回计数 
   
     

2. 对于行可能较长（最多 2000 个字符）的文件，忽略行数：使用函数使用 mmap：count_nb_lines_mmap

   def count_nb_lines_mmap(文件：路径) ->   整数： 
         """计算文件中的行数""" 
         打开（文件，模式=“rb”）作为f： 
             mm = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) 
             nb_行= 0 
             而 mm.readline(): 
                 nb_行 += 1 
             mm.close() 
             返回 nb_lines 
     

3. 对于性能非常好的短代码（特别是对于大小大于的文件）至中等尺寸）：

   def itercount(filename: str) ->;   整数： 
         """计算文件中的行数""" 
         将 open(文件名, 'rb') 作为 f: 
             返回 sum(1 for _ in f) 
     

以下是不同指标的摘要（7 次运行的 timeit 的平均时间，每次运行 10 个循环）

：	小文件，短行	小文件，长行	大文件，短行	大文件，长行	较大文件，短行
... 大小 ...	0.04 MB	1.16 MB	318 MB	17 MB	328 MB
... nb 行 ...	第915章 100 个字符	915 行 < 2000 个	字符 389000 行 < 100 个字符	389,000 行 < 2000 个字符	980 万行 < 100 个字符
count_nb_lines_blocks	0.183 毫秒	1.718 毫秒	36.799 毫秒	415.393 毫秒	517.920 毫秒
count_nb_lines_mmap	0.185 毫秒	0.582 毫秒	44.801 毫秒	185.461 毫秒	691.637 毫秒
buf_count_newlines_gen	0.665 毫秒	1.032 毫秒	15.620 毫秒	213.458	毫秒 318.939 毫秒
itercount	0.135 毫秒	0.817 ms	31.292 ms	223.120 ms	628.760 ms

注意：我还在 8 GB 的文件上比较了 count_nb_lines_mmap 和 buf_count_newlines_gen，其中 970 万行超过 800人物。 buf_count_newlines_gen 的平均时间为 5.39 秒，count_nb_lines_mmap 的平均时间为 4.2 秒，因此后一个函数对于行数较长的文件来说似乎确实更好。

这是我使用过的代码：

import mmap
from pathlib import Path

def count_nb_lines_blocks(file: Path) -> int:
    """Count the number of lines in a file"""

    def blocks(files, size=65536):
        while True:
            b = files.read(size)
            if not b:
                break
            yield b

    with open(file, encoding="utf-8", errors="ignore") as f:
        return sum(bl.count("\n") for bl in blocks(f))


def count_nb_lines_mmap(file: Path) -> int:
    """Count the number of lines in a file"""
    with open(file, mode="rb") as f:
        mm = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ)
        nb_lines = 0
        while mm.readline():
            nb_lines += 1
        mm.close()
        return nb_lines


def count_nb_lines_sum(file: Path) -> int:
    """Count the number of lines in a file"""
    with open(file, "r", encoding="utf-8", errors="ignore") as f:
        return sum(1 for line in f)


def count_nb_lines_for(file: Path) -> int:
    """Count the number of lines in a file"""
    i = 0
    with open(file) as f:
        for i, _ in enumerate(f, start=1):
            pass
    return i


def buf_count_newlines_gen(fname: str) -> int:
    """Count the number of lines in a file"""
    def _make_gen(reader):
        b = reader(1024 * 1024)
        while b:
            yield b
            b = reader(1024 * 1024)

    with open(fname, "rb") as f:
        count = sum(buf.count(b"\n") for buf in _make_gen(f.raw.read))
    return count


def itercount(filename: str) -> int:
    """Count the number of lines in a file"""
    with open(filename, 'rbU') as f:
        return sum(1 for _ in f)


files = [small_file, big_file, small_file_shorter, big_file_shorter, small_file_shorter_sim_size, big_file_shorter_sim_size]
for file in files:
    print(f"File: {file.name} (size: {file.stat().st_size / 1024 ** 2:.2f} MB)")
    for func in [
        count_nb_lines_blocks,
        count_nb_lines_mmap,
        count_nb_lines_sum,
        count_nb_lines_for,
        buf_count_newlines_gen,
        itercount,
    ]:
        result = func(file)
        time = Timer(lambda: func(file)).repeat(7, 10)
        print(f" * {func.__name__}: {result} lines in {mean(time) / 10 * 1000:.3f} ms")
    print()

File: small_file.ndjson (size: 1.16 MB)
 * count_nb_lines_blocks: 915 lines in 1.718 ms
 * count_nb_lines_mmap: 915 lines in 0.582 ms
 * count_nb_lines_sum: 915 lines in 1.993 ms
 * count_nb_lines_for: 915 lines in 3.876 ms
 * buf_count_newlines_gen: 915 lines in 1.032 ms
 * itercount: 915 lines in 0.817 ms

File: big_file.ndjson (size: 317.99 MB)
 * count_nb_lines_blocks: 389000 lines in 415.393 ms
 * count_nb_lines_mmap: 389000 lines in 185.461 ms
 * count_nb_lines_sum: 389000 lines in 485.370 ms
 * count_nb_lines_for: 389000 lines in 967.075 ms
 * buf_count_newlines_gen: 389000 lines in 213.458 ms
 * itercount: 389000 lines in 223.120 ms

File: small_file__shorter.ndjson (size: 0.04 MB)
 * count_nb_lines_blocks: 915 lines in 0.183 ms
 * count_nb_lines_mmap: 915 lines in 0.185 ms
 * count_nb_lines_sum: 915 lines in 0.251 ms
 * count_nb_lines_for: 915 lines in 0.244 ms
 * buf_count_newlines_gen: 915 lines in 0.665 ms
 * itercount: 915 lines in 0.135 ms

File: big_file__shorter.ndjson (size: 17.42 MB)
 * count_nb_lines_blocks: 389000 lines in 36.799 ms
 * count_nb_lines_mmap: 389000 lines in 44.801 ms
 * count_nb_lines_sum: 389000 lines in 59.068 ms
 * count_nb_lines_for: 389000 lines in 81.387 ms
 * buf_count_newlines_gen: 389000 lines in 15.620 ms
 * itercount: 389000 lines in 31.292 ms

File: small_file__shorter_sim_size.ndjson (size: 1.21 MB)
 * count_nb_lines_blocks: 36457 lines in 1.920 ms
 * count_nb_lines_mmap: 36457 lines in 2.615 ms
 * count_nb_lines_sum: 36457 lines in 3.993 ms
 * count_nb_lines_for: 36457 lines in 6.011 ms
 * buf_count_newlines_gen: 36457 lines in 1.363 ms
 * itercount: 36457 lines in 2.147 ms

File: big_file__shorter_sim_size.ndjson (size: 328.19 MB)
 * count_nb_lines_blocks: 9834248 lines in 517.920 ms
 * count_nb_lines_mmap: 9834248 lines in 691.637 ms
 * count_nb_lines_sum: 9834248 lines in 1109.669 ms
 * count_nb_lines_for: 9834248 lines in 1683.859 ms
 * buf_count_newlines_gen: 9834248 lines in 318.939 ms
 * itercount: 9834248 lines in 628.760 ms

Answer 21

如果想在 Linux 中便宜地获取 Python 的行数，我推荐这种方法：

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

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

Answer 22

这是对其他一些答案的元评论。

1. 行读取和缓冲 \n 计数技术不会为每个文件返回相同的答案，因为某些文本文件在最后一行末尾没有换行符。 您可以通过检查最后一个非空缓冲区的最后一个字节并在不是 b'\n' 时添加 1 来解决此问题。

2. 在 Python 3 中，以文本模式和二进制模式打开文件可能会产生不同的结果，因为文本模式默认将 CR、LF 和 CRLF 识别为行结尾（将它们全部转换为 '\n'< /code>)，而在二进制模式下，如果计算 b'\n'，则仅计算 LF 和 CRLF。 无论您是按行读取还是固定大小的缓冲区读取，这都适用。 经典 Mac OS 使用 CR 作为行结尾； 我不知道这些文件现在有多常见。

   


3. 缓冲区读取方法使用有限数量的 RAM，与文件大小无关，而行读取方法可以在最坏的情况下立即将整个文件读入 RAM（特别是如果文件使用 CR 行结尾）。 在最坏的情况下，由于动态调整行缓冲区大小以及（如果在文本模式下打开）Unicode 解码和存储的开销，它可能会使用比文件大小更多的 RAM。

4. 您可以通过预分配字节数组并使用 readinto 而不是 read 来提高缓冲方法的内存使用率，甚至可能提高速度。 现有的答案之一（几乎没有投票）可以做到这一点，但它有错误（它重​​复计算了一些字节）。

5. 顶部缓冲区读取答案使用大缓冲区 (1MiB)。 由于操作系统预读，使用较小的缓冲区实际上可以更快。 如果您一次读取 32K 或 64K，操作系统可能会在您请求之前开始将下一个 32K/64K 读入缓存，并且每次访问内核都会几乎立即返回。 如果您一次读取 1MiB，则操作系统不太可能推测读取整个兆字节。 它可能会预读较少的数据，但您仍然会花费大量时间坐在内核中等待磁盘返回其余数据。

Answer 23

已经有很多答案了，但不幸的是，它们中的大多数只是一个几乎无法优化的问题上的微小经济体......

我参与了几个项目，其中行数是软件的核心功能，并尽可能快地处理巨大的问题。文件数量至关重要。

行计数的主要瓶颈是 I/O 访问，因为您需要读取每一行才能检测行返回字符，根本没有办法解决。 第二个潜在瓶颈是内存管理：一次加载的越多，处理速度就越快，但与第一个瓶颈相比，这个瓶颈可以忽略不计。

因此，除了诸如禁用 GC收集和其他微观管理技巧：

1. 硬件解决方案：主要且最明显的方法是非编程：购买非常快的SSD/闪存硬盘驾驶。 到目前为止，这是获得最大速度提升的方法。

2. 数据预处理和行并行化：如果您生成或可以修改您处理的文件的生成方式，或者您可以预处理它们。 首先将行 return 转换为 Unix 样式 (\n ），因为与 Windows 相比，这将节省 1 个字符（节省的不多，但很容易获得），其次也是最重要的是，您可以编写固定长度的行。 如果您需要可变长度，如果长度变化不是那么大，您可以填充较小的线。 这样，您可以立即计算出文件总大小的行数，从而访问速度更快。 此外，通过固定长度的行，您通常不仅可以预先分配内存以加快处理速度，而且还可以并行处理行！ 当然，并行化对于随机访问 I/O 比 HDD 快得多的闪存/SSD 磁盘效果更好。通常，问题的最佳解决方案是对其进行预处理，以便它更好地满足您的最终目的。

3. 磁盘并行化+硬件解决方案：如果您可以购买多个硬盘（如果可能的话还可以购买SSD闪存盘），那么您甚至可以通过利用并行化、存储您的数据来超越一个磁盘的速度。在磁盘之间以平衡的方式（最简单的是按总大小平衡）文件，然后从所有这些磁盘并行读取。 然后，您可以期望获得与您拥有的磁盘数量成比例的乘数提升。 如果购买多个磁盘不适合您，那么并行化可能不会有帮助（除非您的磁盘像某些专业级磁盘一样具有多个读取头，但即使如此，磁盘的内部高速缓存和 PCB 电路也可能成为瓶颈并阻止您完全并行地使用所有磁头，此外，您还必须为您将使用的该硬盘设计特定的代码，因为您需要知道确切的簇映射，以便将文件存储在不同磁头下的簇上，等等之后你可以用不同的头脑来阅读它们）。 事实上，众所周知，顺序读取几乎总是比随机读取快，并且单个磁盘上的并行化将具有比顺序读取更类似于随机读取的性能（您可以使用CrystalDiskMark）。

如果这些都不是一个选择，那么您只能依靠微观管理技巧来将行计数功能的速度提高几个百分点，但不要指望有任何真正重要的效果。 相反，您可以预期，与您将看到的速度改进的回报相比，您花费在调整上的时间将是不成比例的。

Answer 24

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

Answer 25

使用 Numba

我们可以使用 Numba 将我们的函数 JIT（及时）编译为机器代码。 def numbacountparallel(fname) 运行速度提高 2.8 倍
比问题中的 def file_len(fname) 。

注意：

在运行基准测试之前，操作系统已经将文件缓存到内存中，因为我在电脑上没有看到太多磁盘活动。
第一次读取文件时，时间会慢很多，使得使用 Numba 的时间优势变得微不足道。

第一次调用该函数时，JIT 编译需要额外的时间。

如果我们要做的不仅仅是计算行数，这将很有用。

Cython 是另一种选择。

结论

由于计算行数将受到 I/O 限制，因此请使用问题中的 def file_len(fname) ，除非您想做的不仅仅是计算行数。

import timeit

from numba import jit, prange
import numpy as np

from itertools import (takewhile,repeat)

FILE = '../data/us_confirmed.csv' # 40.6MB, 371755 line file
CR = ord('\n')


# Copied from the question above. Used as a benchmark
def file_len(fname):
    with open(fname) as f:
        for i, l in enumerate(f):
            pass
    return i + 1


# Copied from another answer. Used as a benchmark
def rawincount(filename):
    f = open(filename, 'rb')
    bufgen = takewhile(lambda x: x, (f.read(1024*1024*10) for _ in repeat(None)))
    return sum( buf.count(b'\n') for buf in bufgen )


# Single thread
@jit(nopython=True)
def numbacountsingle_chunk(bs):

    c = 0
    for i in range(len(bs)):
        if bs[i] == CR:
            c += 1

    return c


def numbacountsingle(filename):
    f = open(filename, "rb")
    total = 0
    while True:
        chunk = f.read(1024*1024*10)
        lines = numbacountsingle_chunk(chunk)
        total += lines
        if not chunk:
            break

    return total


# Multi thread
@jit(nopython=True, parallel=True)
def numbacountparallel_chunk(bs):

    c = 0
    for i in prange(len(bs)):
        if bs[i] == CR:
            c += 1

    return c


def numbacountparallel(filename):
    f = open(filename, "rb")
    total = 0
    while True:
        chunk = f.read(1024*1024*10)
        lines = numbacountparallel_chunk(np.frombuffer(chunk, dtype=np.uint8))
        total += lines
        if not chunk:
            break

    return total

print('numbacountparallel')
print(numbacountparallel(FILE)) # This allows Numba to compile and cache the function without adding to the time.
print(timeit.Timer(lambda: numbacountparallel(FILE)).timeit(number=100))

print('\nnumbacountsingle')
print(numbacountsingle(FILE))
print(timeit.Timer(lambda: numbacountsingle(FILE)).timeit(number=100))

print('\nfile_len')
print(file_len(FILE))
print(timeit.Timer(lambda: rawincount(FILE)).timeit(number=100))

print('\nrawincount')
print(rawincount(FILE))
print(timeit.Timer(lambda: rawincount(FILE)).timeit(number=100))

每个函数 100 次调用的时间（以秒为单位）

numbacountparallel
371755
2.8007332000000003

numbacountsingle
371755
3.1508585999999994

file_len
371755
6.7945494

rawincount
371755
6.815438

Answer 26

简单方法：

1. 方法1

   >>>   f = len(open("myfile.txt").readlines()) 
     >>>>>   F 
     

   输出：

   430 
     

2. 方法 2

   >>>   f = open("myfile.txt").read().count('\n') 
     >>>>>   F 
     

   输出：

   430 
     

3. 方法 3

   num_lines = len(list(open('myfile.txt'))) 
     

Answer 27

def count_text_file_lines(path):
    with open(path, 'rt') as file:
        line_count = sum(1 for _line in file)
    return line_count

Answer 28

大文件的替代方法是使用 xreadlines()：

count = 0
for line in open(thefilepath).xreadlines(  ): count += 1

对于 Python 3，请参阅：什么替代 xreadlines() Python 3？

Answer 29

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

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

这比显式循环更简洁，并且避免了枚举。

Answer 30

这可以工作：

import fileinput
import sys

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

fileinput.close()
print counter