如何逐行读取大文件？
Posted
技术标签:
【中文标题】如何逐行读取大文件？【英文标题】：How to read a large file - line by line? 【发布时间】：2011-12-22 00:46:46 【问题描述】：我想遍历整个文件的每一行。一种方法是读取整个文件，将其保存到列表中，然后遍历感兴趣的行。此方法占用大量内存，所以我正在寻找替代方法。
到目前为止我的代码：
for each_line in fileinput.input(input_file):
do_something(each_line)
for each_line_again in fileinput.input(input_file):
do_something(each_line_again)
执行此代码会给出错误消息：device active。
有什么建议吗？
目的是计算成对的字符串相似度，这意味着对于文件中的每一行，我想计算与其他每一行的 Levenshtein 距离。
【问题讨论】：
为什么每一行都需要重新读取整个文件？也许如果你说出你想要完成的事情，有人可能会提出更好的方法。 【参考方案1】：读取文件的正确、完全 Pythonic 方式如下：
with open(...) as f:
for line in f:
# Do something with 'line'
with 语句处理打开和关闭文件，包括是否在内块中引发异常。 for line in f 将文件对象 f 视为一个可迭代对象，它会自动使用缓冲 I/O 和内存管理，因此您不必担心大文件。
应该有一种——最好只有一种——明显的方法。
【讨论】：
是的，这是最好的python 2.6及以上版本 我个人更喜欢使用生成器和协程来处理数据管道。 如果文件是一个巨大的文本文件但只有一行，并且想法是处理单词，那么最好的策略是什么？ 有人能解释一下for line in f: 的工作原理吗？我的意思是，如何迭代文件对象？
如果你遍历一个对象，Python 会在对象方法列表中查找一个名为__iter__ 的特殊方法，它会告诉它要做什么。文件对象定义了这个特殊的方法来在行上返回一个迭代器。 （大致。）【参考方案2】：
按排名顺序排列的两种内存高效方式（第一是最好的）-
-
使用
with - python 2.5 及更高版本支持
如果您真的想控制阅读量，请使用yield
1。使用with
with 是读取大文件的一种不错且高效的 Python 方式。优点 - 1) 文件对象在退出with 执行块后自动关闭。 2) with 块内的异常处理。 3）内存for循环逐行遍历f文件对象。在内部，它会缓冲 IO（以优化昂贵的 IO 操作）和内存管理。
with open("x.txt") as f:
for line in f:
do something with data
2。使用yield
有时，人们可能希望更细粒度地控制每次迭代中要读取的内容。在这种情况下使用iter & yield。请注意，这种方法需要在最后关闭文件。
def readInChunks(fileObj, chunkSize=2048):
"""
Lazy function to read a file piece by piece.
Default chunk size: 2kB.
"""
while True:
data = fileObj.read(chunkSize)
if not data:
break
yield data
f = open('bigFile')
for chunk in readInChunks(f):
do_something(chunk)
f.close()
陷阱和完整性考虑 - 以下方法在读取大文件时不如或不优雅，但请阅读以获得全面理解。
在 Python 中，从文件中读取行的最常见方法是执行以下操作：
for line in open('myfile','r').readlines():
do_something(line)
然而，当这完成后，readlines() 函数（同样适用于read() 函数）将整个文件加载到内存中，然后对其进行迭代。对于大文件，稍微好一点的方法（上面提到的两种方法最好）是使用fileinput模块，如下：
import fileinput
for line in fileinput.input(['myfile']):
do_something(line)
fileinput.input() 调用按顺序读取行，但在读取后不会将它们保存在内存中，甚至只是这样，因为 python 中的file 是可迭代的。
参考文献
-
Python with statement
【讨论】：
-1for line in open(...).readlines(): <do stuff> 基本上从来都不是一个好主意。你为什么要？！你只是失去了 Python 聪明的缓冲迭代器 IO 的所有好处，而没有任何好处。
@Srikar：有时间和地点可以为问题提供所有可能的解决方案；教初学者如何做文件输入是不是。将正确答案埋在满是错误答案的长篇文章的底部并不是好的教学。
@Srikar：您可以通过将正确的方式放在顶部，然后提及readlines 并解释为什么这样做不是一件好事（因为它将文件读入内存），从而使您的帖子显着更好)，然后解释 fileinput 模块的作用以及为什么您可能希望在其他方法上使用它，然后解释文件分块如何使 IO 更好，并给出分块函数的示例（但提到 Python 已经这样做了给你，所以你不需要）。但是仅仅给出解决一个简单问题的五种方法，其中四个在这种情况下是错误的，是不好的。
为了完整起见添加任何内容，请最后添加，而不是首先添加。先显示正确的方法。
@katrielalex 重新审视了我的回答，发现它值得重组。我可以看到较早的答案如何引起混乱。希望这能让未来的用户清楚。【参考方案3】：
去除换行符：
with open(file_path, 'rU') as f:
for line_terminated in f:
line = line_terminated.rstrip('\n')
...
对于universal newline support，所有文本文件行似乎都以'\n' 终止，无论文件中的终止符是'\r'、'\n' 还是'\r\n'。
EDIT - 指定通用换行支持：
Unix 上的 Python 2 -open(file_path, mode='rU') - 必需 [感谢 @Dave]
Windows 上的 Python 2 - open(file_path, mode='rU') - 可选
Python 3 - open(file_path, newline=None) - 可选
newline 参数仅在 Python 3 中受支持，默认为 None。在所有情况下，mode 参数默认为 'r'。 U 在 Python 3 中已弃用。在 Windows 上的 Python 2 中，一些其他机制似乎将 \r\n 转换为 \n。
文档：
open() for Python 2 open() for Python 3要保留本机行终止符：
with open(file_path, 'rb') as f:
with line_native_terminated in f:
...
二进制模式仍然可以将文件解析为带有in 的行。每一行都会有它在文件中的任何终止符。
感谢@katrielalex 的answer、Python 的open() 文档和iPython 实验。
【讨论】：
在 Python 2.7 上，我必须open(file_path, 'rU') 才能启用通用换行符。【参考方案4】：
这是在 python 中读取文件的一种可能方式：
f = open(input_file)
for line in f:
do_stuff(line)
f.close()
它没有分配一个完整的列表。它遍历行。
【讨论】：
虽然这可行，但它绝对不是规范的方式。规范的方法是使用上下文包装器，例如with open(input_file) as f:。这可以为您节省 f.close() 并确保您不会不小心忘记关闭它。防止内存泄漏等，在读取文件时非常重要。
正如@Mast 所说，这不是规范的方式，所以对此投反对票。【参考方案5】：
关于我来自哪里的一些背景信息。代码 sn-ps 在最后。
如果可以的话，我更喜欢使用像 H2O 这样的开源工具来进行超高性能的并行 CSV 文件读取，但是这个工具在功能集上是有限的。我最终编写了大量代码来创建数据科学管道，然后再将其馈送到 H2O 集群以进行适当的监督学习。
我一直在从 UCI 存储库读取文件，例如 8GB HIGGS 数据集，甚至是用于数据科学目的的 40GB CSV 文件，通过使用多处理库的池对象和映射函数添加大量并行性，显着加快了速度。例如，最近邻搜索的聚类以及 DBSCAN 和马尔可夫聚类算法需要一些并行编程技巧来绕过一些严重具有挑战性的内存和挂钟时间问题。
我通常喜欢先使用 gnu 工具将文件按行分成几部分，然后将它们全部 glob-filemask 以在 python 程序中并行查找和读取它们。我通常使用 1000 多个部分文件。使用这些技巧可以极大地提高处理速度和内存限制。
pandas dataframe.read_csv 是单线程的，因此您可以通过运行 map() 并行执行这些技巧来使 pandas 更快。您可以使用 htop 看到，对于普通的旧顺序 pandas dataframe.read_csv，只有一个核心上的 100% cpu 是 pd.read_csv 的实际瓶颈，而不是磁盘。
我应该补充一下，我在快速显卡总线上使用 SSD，而不是在 SATA6 总线上使用旋转 HD，外加 16 个 CPU 内核。
另外，我发现在某些应用程序中效果很好的另一种技术是并行 CSV 文件读取一个大文件中的所有内容，以不同的偏移量启动每个工作程序到文件中，而不是将一个大文件预先拆分为多个部分文件。在每个并行工作者中使用 python 的文件 seek() 和 tell() 以条状读取大文本文件，在大文件中不同的字节偏移开始字节和结束字节位置，同时同时进行。您可以对字节执行正则表达式查找，并返回换行数。这是部分金额。最后在worker完成后map函数返回时将部分和相加得到全局和。
以下是使用并行字节偏移技巧的一些示例基准：
我使用 2 个文件：HIGGS.csv 为 8 GB。它来自 UCI 机器学习存储库。 all_bin .csv 为 40.4 GB，来自我当前的项目。 我使用了2个程序：Linux自带的GNU wc程序，以及我自己开发的纯python fastread.py程序。
HP-Z820:/mnt/fastssd/fast_file_reader$ ls -l /mnt/fastssd/nzv/HIGGS.csv
-rw-rw-r-- 1 8035497980 Jan 24 16:00 /mnt/fastssd/nzv/HIGGS.csv
HP-Z820:/mnt/fastssd$ ls -l all_bin.csv
-rw-rw-r-- 1 40412077758 Feb 2 09:00 all_bin.csv
ga@ga-HP-Z820:/mnt/fastssd$ time python fastread.py --fileName="all_bin.csv" --numProcesses=32 --balanceFactor=2
2367496
real 0m8.920s
user 1m30.056s
sys 2m38.744s
In [1]: 40412077758. / 8.92
Out[1]: 4530501990.807175
这是大约 4.5 GB/s 或 45 Gb/s 的文件 slurping 速度。那不是没有旋转的硬盘，我的朋友。那实际上是三星 Pro 950 SSD。
以下是由纯 C 编译程序 gnu wc 对同一文件进行行数计算的速度基准。
很酷的是，在这种情况下，您可以看到我的纯 python 程序与 gnu wc 编译的 C 程序的速度基本匹配。 Python 是解释的，但 C 是编译的，所以这是一个非常有趣的速度壮举，我想你会同意的。当然，wc 确实需要改成一个并行程序，然后它就真的会打败我的 python 程序。但就目前而言，gnu wc 只是一个顺序程序。你尽你所能，python今天可以并行。 Cython 编译可能会对我有所帮助（其他时间）。还没有探索内存映射文件。
HP-Z820:/mnt/fastssd$ time wc -l all_bin.csv
2367496 all_bin.csv
real 0m8.807s
user 0m1.168s
sys 0m7.636s
HP-Z820:/mnt/fastssd/fast_file_reader$ time python fastread.py --fileName="HIGGS.csv" --numProcesses=16 --balanceFactor=2
11000000
real 0m2.257s
user 0m12.088s
sys 0m20.512s
HP-Z820:/mnt/fastssd/fast_file_reader$ time wc -l HIGGS.csv
11000000 HIGGS.csv
real 0m1.820s
user 0m0.364s
sys 0m1.456s
结论：与C程序相比，纯python程序的速度是好的。但是，使用纯 Python 程序而不是 C 程序还不够好，至少对于行计数目的而言是这样。一般来说，该技术可以用于其他文件处理，所以这个python代码还是不错的。
问题：只编译一次正则表达式并将其传递给所有工作人员会提高速度吗？答：Regex 预编译在此应用程序中没有帮助。我想原因是所有工作人员的进程序列化和创建开销占主导地位。
还有一件事。 并行 CSV 文件读取是否有帮助？磁盘是瓶颈，还是CPU？他们说，*** 上的许多所谓的***答案都包含一个共同的开发智慧，即您只需要一个线程即可读取文件，尽您所能。但他们确定吗？
让我们找出答案：
HP-Z820:/mnt/fastssd/fast_file_reader$ time python fastread.py --fileName="HIGGS.csv" --numProcesses=16 --balanceFactor=2
11000000
real 0m2.256s
user 0m10.696s
sys 0m19.952s
HP-Z820:/mnt/fastssd/fast_file_reader$ time python fastread.py --fileName="HIGGS.csv" --numProcesses=1 --balanceFactor=1
11000000
real 0m17.380s
user 0m11.124s
sys 0m6.272s
哦，是的，是的。并行文件读取效果很好。好了，你去吧！
附言。如果你们中的一些人想知道，如果使用单个工作进程时 balanceFactor 为 2 会怎样？好吧，这太可怕了：
HP-Z820:/mnt/fastssd/fast_file_reader$ time python fastread.py --fileName="HIGGS.csv" --numProcesses=1 --balanceFactor=2
11000000
real 1m37.077s
user 0m12.432s
sys 1m24.700s
fastread.py python程序的关键部分：
fileBytes = stat(fileName).st_size # Read quickly from OS how many bytes are in a text file
startByte, endByte = PartitionDataToWorkers(workers=numProcesses, items=fileBytes, balanceFactor=balanceFactor)
p = Pool(numProcesses)
partialSum = p.starmap(ReadFileSegment, zip(startByte, endByte, repeat(fileName))) # startByte is already a list. fileName is made into a same-length list of duplicates values.
globalSum = sum(partialSum)
print(globalSum)
def ReadFileSegment(startByte, endByte, fileName, searchChar='\n'): # counts number of searchChar appearing in the byte range
with open(fileName, 'r') as f:
f.seek(startByte-1) # seek is initially at byte 0 and then moves forward the specified amount, so seek(5) points at the 6th byte.
bytes = f.read(endByte - startByte + 1)
cnt = len(re.findall(searchChar, bytes)) # findall with implicit compiling runs just as fast here as re.compile once + re.finditer many times.
return cnt
PartitionDataToWorkers 的 def 只是普通的顺序代码。我把它留了下来，以防其他人想练习一下并行编程是什么样的。为了您的学习，我免费赠送了更难的部分：经过测试和工作的并行代码。
感谢：开源 H2O 项目，由 Arno 和 Cliff 以及 H2O 工作人员提供的出色软件和教学视频，为我提供了如上所示的纯 Python 高性能并行字节偏移阅读器的灵感。 H2O 使用 java 进行并行文件读取，可由 python 和 R 程序调用，而且速度非常快，读取大型 CSV 文件的速度比地球上任何东西都快。
【讨论】：
并行块基本上就是这样。此外，我预计 SSD 和闪存是唯一兼容此技术的存储设备。 Spinning HD 不太可能兼容。 您是如何考虑操作系统缓存磁盘文件的？【参考方案6】：Katrielalex 提供了打开和读取一个文件的方法。
无论您的算法采用何种方式，它都会为文件的每一行读取整个文件。这意味着如果 N 是文件中的行数，则读取文件的总量 - 并计算 Levenshtein distance - 将完成 N*N。由于您担心文件大小并且不想将其保存在内存中，因此我担心生成的quadratic runtime。您的算法属于 O(n^2) 类算法，通常可以通过专门化来改进。
我怀疑您在这里已经知道内存与运行时的权衡，但也许您想研究是否有一种有效的方法来并行计算多个 Levenshtein 距离。如果是这样，在这里分享您的解决方案会很有趣。
您的文件有多少行，您的算法必须在哪种机器（内存和 cpu 功率）上运行，以及允许的运行时间是多少？
代码如下：
with f_outer as open(input_file, 'r'):
for line_outer in f_outer:
with f_inner as open(input_file, 'r'):
for line_inner in f_inner:
compute_distance(line_outer, line_inner)
但问题是您如何存储距离（矩阵？），以及您能否获得准备的优势，例如用于处理的外线，或缓存一些中间结果以供重用。
【讨论】：
我的意思是，这篇文章不包含问题的答案，只是更多的问题！ IMO 它更适合作为评论。 @katriealex：错误。奇怪的。您确实看到了嵌套循环，扩展了您自己的答案以适合实际问题？我可以从我的答案中删除我的问题，并且还有足够的内容可以保证将其作为 - 尽管是部分 - 答案。如果您编辑自己的答案以包含嵌套循环示例（问题明确提出），我也可以接受，然后我可以愉快地删除自己的答案。但是投反对票是我根本没有得到的。 还不错；我并没有真正看到演示嵌套 for 循环作为问题的答案，但我想它非常强烈地针对初学者。已删除反对票。【参考方案7】：来自fileinput.input() 的python 文档：
这会遍历
sys.argv[1:]中列出的所有文件的行，如果列表为空，则默认为sys.stdin
进一步，函数的定义是：
fileinput.FileInput([files[, inplace[, backup[, mode[, openhook]]]]])
在字里行间，这告诉我files 可以是一个列表，所以你可以有类似的东西：
for each_line in fileinput.input([input_file, input_file]):
do_something(each_line)
更多信息请见here
【讨论】：
【参考方案8】：我强烈建议不要使用默认文件加载，因为它非常慢。您应该查看 numpy 函数和 IOpro 函数（例如 numpy.loadtxt()）。
http://docs.scipy.org/doc/numpy/user/basics.io.genfromtxt.html
https://store.continuum.io/cshop/iopro/
然后你可以将你的成对操作分成块：
import numpy as np
import math
lines_total = n
similarity = np.zeros(n,n)
lines_per_chunk = m
n_chunks = math.ceil(float(n)/m)
for i in xrange(n_chunks):
for j in xrange(n_chunks):
chunk_i = (function of your choice to read lines i*lines_per_chunk to (i+1)*lines_per_chunk)
chunk_j = (function of your choice to read lines j*lines_per_chunk to (j+1)*lines_per_chunk)
similarity[i*lines_per_chunk:(i+1)*lines_per_chunk,
j*lines_per_chunk:(j+1)*lines_per_chunk] = fast_operation(chunk_i, chunk_j)
分块加载数据然后对其执行矩阵运算几乎总是比逐个元素地执行要快得多！
【讨论】：
【参考方案9】：#Using a text file for the example
with open("yourFile.txt","r") as f:
text = f.readlines()
for line in text:
print line
例如，如果您想检查长度大于 10 的特定行，请使用您已有的。
for line in text:
if len(line) > 10:
print line
【讨论】：
不是这个问题的最佳选择，但这段代码主要在你正在寻找的情况下有用。是“slurping”（一次读取整个文件）。那是我的情况，谷歌把我带到了这里。 +1。此外，为了原子性，或者如果您在循环中进行耗时的处理，可能会更快地读取整个文件 另外，对代码进行了一些改进：1. 在 with 之后不需要关闭：(docs.python.org/2/tutorial/inputoutput.html, 搜索“使用 with 关键字是个好习惯...”) 2. 文本可以在读取文件后处理（除了带有循环......）【参考方案10】：需要经常从上次读取位置读取大文件？
我创建了一个脚本，用于每天多次剪切 Apache access.log 文件。
所以我需要在上次执行期间解析的最后一行设置位置光标。
为此，我使用了file.seek() 和file.seek() 方法，它们允许将光标存储在文件中。
我的代码：
ENCODING = "utf8"
CURRENT_FILE_DIR = os.path.dirname(os.path.abspath(__file__))
# This file is used to store the last cursor position
cursor_position = os.path.join(CURRENT_FILE_DIR, "access_cursor_position.log")
# Log file with new lines
log_file_to_cut = os.path.join(CURRENT_FILE_DIR, "access.log")
cut_file = os.path.join(CURRENT_FILE_DIR, "cut_access", "cut.log")
# Set in from_line
from_position = 0
try:
with open(cursor_position, "r", encoding=ENCODING) as f:
from_position = int(f.read())
except Exception as e:
pass
# We read log_file_to_cut to put new lines in cut_file
with open(log_file_to_cut, "r", encoding=ENCODING) as f:
with open(cut_file, "w", encoding=ENCODING) as fw:
# We set cursor to the last position used (during last run of script)
f.seek(from_position)
for line in f:
fw.write("%s" % (line))
# We save the last position of cursor for next usage
with open(cursor_position, "w", encoding=ENCODING) as fw:
fw.write(str(f.tell()))
【讨论】：
【参考方案11】：逐行读取大文件的最佳方法是使用python enumerate函数
with open(file_name, "rU") as read_file:
for i, row in enumerate(read_file, 1):
#do something
#i in line of that line
#row containts all data of that line
【讨论】：
为什么使用枚举更好？与已接受的答案相比，唯一的好处是您获得了 OP 不需要的索引，并且您使代码的可读性降低。以上是关于如何逐行读取大文件？的主要内容，如果未能解决你的问题，请参考以下文章