如何使用python反向读取文件？我想从最后一行读取文件。
for line in reversed(open("filename").readlines()):
print line.rstrip()
在Python 3中：
for line in reversed(list(open("filename"))):
print(line.rstrip())
写为生成器的正确，有效的答案。
import os
def reverse_readline(filename, buf_size=8192):
"""A generator that returns the lines of a file in reverse order"""
with open(filename) as fh:
segment = None
offset = 0
fh.seek(0, os.SEEK_END)
file_size = remaining_size = fh.tell()
while remaining_size > 0:
offset = min(file_size, offset + buf_size)
fh.seek(file_size - offset)
buffer = fh.read(min(remaining_size, buf_size))
remaining_size -= buf_size
lines = buffer.split('\n')
# The first line of the buffer is probably not a complete line so
# we'll save it and append it to the last line of the next buffer
# we read
if segment is not None:
# If the previous chunk starts right from the beginning of line
# do not concat the segment to the last line of new chunk.
# Instead, yield the segment first
if buffer[-1] != '\n':
lines[-1] += segment
else:
yield segment
segment = lines[0]
for index in range(len(lines) - 1, 0, -1):
if lines[index]:
yield lines[index]
# Don't yield None if the file was empty
if segment is not None:
yield segment
类似这样的事情：
import os
def readlines_reverse(filename):
with open(filename) as qfile:
qfile.seek(0, os.SEEK_END)
position = qfile.tell()
line = ''
while position >= 0:
qfile.seek(position)
next_char = qfile.read(1)
if next_char == "\n":
yield line[::-1]
line = ''
else:
line += next_char
position -= 1
yield line[::-1]
if __name__ == '__main__':
for qline in readlines_reverse(raw_input()):
print qline
由于以相反的顺序逐个字符地读取文件，因此即使在非常大的文件中也可以使用，只要将单独的行放入内存中即可。
您也可以使用python模块file_read_backwards。
[通过pip install file_read_backwards（v1.2.1）安装后，可以通过以下方式以内存高效的方式向后（逐行）读取整个文件：
#!/usr/bin/env python2.7
from file_read_backwards import FileReadBackwards
with FileReadBackwards("/path/to/file", encoding="utf-8") as frb:
for l in frb:
print l
它支持“ utf-8”，“ latin-1”和“ ascii”编码。
也支持python3。可以在http://file-read-backwards.readthedocs.io/en/latest/readme.html
中找到更多文档import re
def filerev(somefile, buffer=0x20000):
somefile.seek(0, os.SEEK_END)
size = somefile.tell()
lines = ['']
rem = size % buffer
pos = max(0, (size // buffer - 1) * buffer)
while pos >= 0:
somefile.seek(pos, os.SEEK_SET)
data = somefile.read(rem + buffer) + lines[0]
rem = 0
lines = re.findall('[^\n]*\n?', data)
ix = len(lines) - 2
while ix > 0:
yield lines[ix]
ix -= 1
pos -= buffer
else:
yield lines[0]
with open(sys.argv[1], 'r') as f:
for line in filerev(f):
sys.stdout.write(line)
接受的答案不适用于文件大而内存不足的情况（这并非罕见）。>>
[正如其他人所指出的，@srohde answer看起来不错，但还有下一个问题：
即使我们重构为接受文件对象，它也不适用于所有编码：我们可以选择具有utf-8编码和非ascii内容的文件，例如
й通过
buf_size等于1并且将具有
UnicodeDecodeError: 'utf8' codec can't decode byte 0xb9 in position 0: invalid start byte当然，文本可能更大，但可能会拾取
buf_size，因此将导致类似上面的混淆错误，
因此，考虑到所有这些问题，我编写了单独的函数：
首先让我们定义下一个实用程序功能：
ceil_division用于天花板分隔（与标准//地板分隔相反，更多信息可以在this thread中找到）
def ceil_division(left_number, right_number): """ Divides given numbers with ceiling. """ return -(-left_number // right_number)[
split用于通过给定的分隔符从右端分割字符串并保持其能力：
def split(string, separator, keep_separator): """ Splits given string by given separator. """ parts = string.split(separator) if keep_separator: *parts, last_part = parts parts = [part + separator for part in parts] if last_part: return parts + [last_part] return parts
read_batch_from_end从二进制流的右端读取批处理
def read_batch_from_end(byte_stream, size, end_position): """ Reads batch from the end of given byte stream. """ if end_position > size: offset = end_position - size else: offset = 0 size = end_position byte_stream.seek(offset) return byte_stream.read(size)此后，我们可以定义用于以相反顺序读取字节流的函数，例如
import functools import itertools import os from operator import methodcaller, sub def reverse_binary_stream(byte_stream, batch_size=None, lines_separator=None, keep_lines_separator=True): if lines_separator is None: lines_separator = (b'\r', b'\n', b'\r\n') lines_splitter = methodcaller(str.splitlines.__name__, keep_lines_separator) else: lines_splitter = functools.partial(split, separator=lines_separator, keep_separator=keep_lines_separator) stream_size = byte_stream.seek(0, os.SEEK_END) if batch_size is None: batch_size = stream_size or 1 batches_count = ceil_division(stream_size, batch_size) remaining_bytes_indicator = itertools.islice( itertools.accumulate(itertools.chain([stream_size], itertools.repeat(batch_size)), sub), batches_count) try: remaining_bytes_count = next(remaining_bytes_indicator) except StopIteration: return def read_batch(position): result = read_batch_from_end(byte_stream, size=batch_size, end_position=position) while result.startswith(lines_separator): try: position = next(remaining_bytes_indicator) except StopIteration: break result = (read_batch_from_end(byte_stream, size=batch_size, end_position=position) + result) return result batch = read_batch(remaining_bytes_count) segment, *lines = lines_splitter(batch) yield from reverse(lines) for remaining_bytes_count in remaining_bytes_indicator: batch = read_batch(remaining_bytes_count) lines = lines_splitter(batch) if batch.endswith(lines_separator): yield segment else: lines[-1] += segment segment, *lines = lines yield from reverse(lines) yield segment最后可以将文本文件反转的功能定义为：
import codecs def reverse_file(file, batch_size=None, lines_separator=None, keep_lines_separator=True): encoding = file.encoding if lines_separator is not None: lines_separator = lines_separator.encode(encoding) yield from map(functools.partial(codecs.decode, encoding=encoding), reverse_binary_stream( file.buffer, batch_size=batch_size, lines_separator=lines_separator, keep_lines_separator=keep_lines_separator))测试
我已经使用fsutil command生成了4个文件：
而且我已经重构了@srohde解决方案以使用文件对象而不是文件路径。
fsutil注：我使用过from timeit import Timer
repeats_count = 7
number = 1
create_setup = ('from collections import deque\n'
'from __main__ import reverse_file, reverse_readline\n'
'file = open("{}")').format
srohde_solution = ('with file:\n'
' deque(reverse_readline(file,\n'
' buf_size=8192),'
' maxlen=0)')
azat_ibrakov_solution = ('with file:\n'
' deque(reverse_file(file,\n'
' lines_separator="\\n",\n'
' keep_lines_separator=False,\n'
' batch_size=8192), maxlen=0)')
print('reversing empty file by "srohde"',
min(Timer(srohde_solution,
create_setup('empty.txt')).repeat(repeats_count, number)))
print('reversing empty file by "Azat Ibrakov"',
min(Timer(azat_ibrakov_solution,
create_setup('empty.txt')).repeat(repeats_count, number)))
print('reversing tiny file (1MB) by "srohde"',
min(Timer(srohde_solution,
create_setup('tiny.txt')).repeat(repeats_count, number)))
print('reversing tiny file (1MB) by "Azat Ibrakov"',
min(Timer(azat_ibrakov_solution,
create_setup('tiny.txt')).repeat(repeats_count, number)))
print('reversing small file (10MB) by "srohde"',
min(Timer(srohde_solution,
create_setup('small.txt')).repeat(repeats_count, number)))
print('reversing small file (10MB) by "Azat Ibrakov"',
min(Timer(azat_ibrakov_solution,
create_setup('small.txt')).repeat(repeats_count, number)))
print('reversing large file (50MB) by "srohde"',
min(Timer(srohde_solution,
create_setup('large.txt')).repeat(repeats_count, number)))
print('reversing large file (50MB) by "Azat Ibrakov"',
min(Timer(azat_ibrakov_solution,
create_setup('large.txt')).repeat(repeats_count, number)))
类来排放发电机。
对于Windows 10上的PyPy 3.5：
collections.deque对于Windows 10上的CPython 3.5：
reversing empty file by "srohde" 8.31e-05 reversing empty file by "Azat Ibrakov" 0.00016090000000000028 reversing tiny file (1MB) by "srohde" 0.160081 reversing tiny file (1MB) by "Azat Ibrakov" 0.09594989999999998 reversing small file (10MB) by "srohde" 8.8891863 reversing small file (10MB) by "Azat Ibrakov" 5.323388100000001 reversing large file (50MB) by "srohde" 186.5338368 reversing large file (50MB) by "Azat Ibrakov" 99.07450229999998因此，我们可以看到它的性能与原始解决方案相似，但更通用，没有上面列出的缺点。
我已经将此添加到reversing empty file by "srohde" 3.600000000000001e-05
reversing empty file by "Azat Ibrakov" 4.519999999999958e-05
reversing tiny file (1MB) by "srohde" 0.01965560000000001
reversing tiny file (1MB) by "Azat Ibrakov" 0.019207699999999994
reversing small file (10MB) by "srohde" 3.1341862999999996
reversing small file (10MB) by "Azat Ibrakov" 3.0872588000000007
reversing large file (50MB) by "srohde" 82.01206720000002
reversing large file (50MB) by "Azat Ibrakov" 82.16775059999998
的0.3.0版本（需要Python 3.5 +）中，该版本具有许多经过测试的功能/迭代实用程序。
可以像这样使用
lzpackage它支持
lz（可能是import io from lz.iterating import reverse ... with open('path/to/file') as file: for line in reverse(file, batch_size=io.DEFAULT_BUFFER_SIZE): print(line)除外，因为我很难定义all standard encodings来生成可编码的字符串）。
[在这里您可以找到我的实现，可以通过更改“ buffer”变量来限制ram的使用，这是一个错误，程序会在开始时打印一个空行。
感谢您的回答@srohde。它使用“ is”运算符检查换行符时存在一个小错误，并且我无法对信誉为1的答案进行评论。另外，我想管理外部文件的打开，因为这使我可以将自己的任务嵌入到luigi任务中。
一个用于创建第二个文件的简单函数被反转（仅Linux）：
如果您担心文件的大小/内存使用情况，则可以将文件映射到内存并向后扫描换行符：
带有open（“ filename”）as f：
在处理文件时总是使用 print(f.read()[::-1])
，因为它可以为您处理所有事情：
您首先需要以读取格式打开文件，将其保存到变量，然后以写入格式打开第二个文件，在该文件中您将使用[::-1]切片来写入或附加变量，从而完全反转文件。您还可以使用readlines（）使其成为一行列表，您可以对其进行操作
大多数答案需要先阅读整个文件，然后再执行任何操作。此样本读取越来越大的样本从结尾
逐行读取文件，然后以相反顺序将其添加到列表中。
def readlines_reversed(f):
""" Iterate over the lines in a file in reverse. The file must be
open in 'rb' mode. Yields the lines unencoded (as bytes), including the
newline character. Produces the same result as readlines, but reversed.
If this is used to reverse the line in a file twice, the result is
exactly the same.
"""
head = b""
f.seek(0, 2)
t = f.tell()
buffersize, maxbuffersize = 64, 4096
while True:
if t <= 0:
break
# Read next block
buffersize = min(buffersize * 2, maxbuffersize)
tprev = t
t = max(0, t - buffersize)
f.seek(t)
lines = f.read(tprev - t).splitlines(True)
# Align to line breaks
if not lines[-1].endswith((b"\n", b"\r")):
lines[-1] += head # current tail is previous head
elif head == b"\n" and lines[-1].endswith(b"\r"):
lines[-1] += head # Keep \r\n together
elif head:
lines.append(head)
head = lines.pop(0) # can be '\n' (ok)
# Iterate over current block in reverse
for line in reversed(lines):
yield line
if head:
yield head
reverse = []
with open("file.txt", "r") as file:
for line in file:
line = line.strip()
reverse[0:0] = line
我前段时间必须这样做，并使用了以下代码。它通过管道传递给外壳。恐怕我没有完整的脚本了。如果您使用的是unixish操作系统，则可以使用“ tac”，例如，在Mac OSX tac命令不起作用，请使用tail -r。以下代码段测试了您所使用的平台，并相应地调整了命令]