Katrielalex提供了打开和读取一个文件的方法。

不管你的算法是如何运行的，它会为文件的每一行读取整个文件。这意味着，如果N是文件中的行数，那么读取文件的总量(以及计算Levenshtein距离)将是N*N。由于您关心文件大小，并且不想将其保存在内存中，因此我关心的是所产生的二次运行时。你的算法属于O(n^2)类算法，通常可以通过专门化来改进。

我怀疑您已经知道这里内存与运行时的权衡，但是您可能想要研究是否有一种并行计算多个Levenshtein距离的有效方法。如果是这样的话，在这里分享你的解决方案会很有趣。

你的文件有多少行，你的算法必须在什么样的机器(mem和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)

但问题是你如何存储距离(矩阵?)，你能获得一个优势准备例如outer_line处理，或缓存一些中间结果以供重用。

需要经常从上一个位置读取一个大文件?

我创建了一个脚本，用于每天多次删除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()))

我强烈建议不要使用默认的文件加载，因为它非常慢。你应该研究一下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) 

以块方式加载数据，然后对其进行矩阵操作，几乎总是比一个元素一个元素地加载数据快得多!!

去除换行符:

with open(file_path, 'rU') as f:
    for line_terminated in f:
        line = line_terminated.rstrip('\n')
        ...

在通用换行支持下，所有文本文件行似乎都以'\n'结束，无论文件中的终止符是'\r'、'\n'还是'\r\n'。

EDIT -指定通用换行支持:

Python 2 on Unix - open(file_path, mode='rU') - required[谢谢@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上的python2中，一些其他机制似乎将\r\n转换为\n。

文档:

open()用于Python 2 open()用于Python 3

保存本机行终止符:

with open(file_path, 'rb') as f:
    with line_native_terminated in f:
        ...

二进制模式仍然可以用in将文件解析成行。每一行都有它在文件中的终止符。

感谢@katrielalex的回答，Python的open() doc和iPython实验。

逐行读取大文件的最佳方法是使用python枚举函数

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

Katrielalex提供了打开和读取一个文件的方法。

不管你的算法是如何运行的，它会为文件的每一行读取整个文件。这意味着，如果N是文件中的行数，那么读取文件的总量(以及计算Levenshtein距离)将是N*N。由于您关心文件大小，并且不想将其保存在内存中，因此我关心的是所产生的二次运行时。你的算法属于O(n^2)类算法，通常可以通过专门化来改进。

我怀疑您已经知道这里内存与运行时的权衡，但是您可能想要研究是否有一种并行计算多个Levenshtein距离的有效方法。如果是这样的话，在这里分享你的解决方案会很有趣。

你的文件有多少行，你的算法必须在什么样的机器(mem和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)

但问题是你如何存储距离(矩阵?)，你能获得一个优势准备例如outer_line处理，或缓存一些中间结果以供重用。