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 __== '__main__':
for qline in readlines_reverse(raw_input()):
print qline
ファイルは文字ごとに逆順で読み取られるため、個々の行がメモリに収まる限り、非常に大きなファイルでも機能します。
python module 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)
ここで私の実装を見つけることができます。「バッファ」変数を変更することでRAMの使用を制限できます。プログラムが最初に空行を出力するというバグがあります。
また、バッファバイトを超える新しい行がない場合、RAMの使用量が増加する可能性があります。「leak」変数は、新しい行が表示されるまで増加します（「\ n」）。
これは、合計メモリよりも大きい16 GBファイルでも機能します。
import os,sys
buffer = 1024*1024 # 1MB
f = open(sys.argv[1])
f.seek(0, os.SEEK_END)
filesize = f.tell()
division, remainder = divmod(filesize, buffer)
line_leak=''
for chunk_counter in range(1,division + 2):
if division - chunk_counter < 0:
f.seek(0, os.SEEK_SET)
chunk = f.read(remainder)
Elif division - chunk_counter >= 0:
f.seek(-(buffer*chunk_counter), os.SEEK_END)
chunk = f.read(buffer)
chunk_lines_reversed = list(reversed(chunk.split('\n')))
if line_leak: # add line_leak from previous chunk to beginning
chunk_lines_reversed[0] += line_leak
# after reversed, save the leakedline for next chunk iteration
line_leak = chunk_lines_reversed.pop()
if chunk_lines_reversed:
print "\n".join(chunk_lines_reversed)
# print the last leaked line
if division - chunk_counter < 0:
print line_leak
答え@srohdeをありがとう。 「is」演算子を使用して改行文字をチェックする小さなバグがあり、1つの評判で答えにコメントできませんでした。また、外部で開いているファイルを管理したいと思います。これにより、luigiタスクのとりとめを埋め込むことができます。
変更する必要があるのは次の形式です。
with open(filename) as fp:
for line in fp:
#print line, # contains new line
print '>{}<'.format(line)
に変更したい：
with open(filename) as fp:
for line in reversed_fp_iter(fp, 4):
#print line, # contains new line
print '>{}<'.format(line)
ファイルハンドルを必要とし、改行を保持する修正された回答を次に示します。
def reversed_fp_iter(fp, buf_size=8192):
"""a generator that returns the lines of a file in reverse order
ref: https://stackoverflow.com/a/23646049/8776239
"""
segment = None # holds possible incomplete segment at the beginning of the buffer
offset = 0
fp.seek(0, os.SEEK_END)
file_size = remaining_size = fp.tell()
while remaining_size > 0:
offset = min(file_size, offset + buf_size)
fp.seek(file_size - offset)
buffer = fp.read(min(remaining_size, buf_size))
remaining_size -= buf_size
lines = buffer.splitlines(True)
# 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':
#print 'buffer ends with newline'
yield segment
else:
lines[-1] += segment
#print 'enlarged last line to >{}<, len {}'.format(lines[-1], len(lines))
segment = lines[0]
for index in range(len(lines) - 1, 0, -1):
if len(lines[index]):
yield lines[index]
# Don't yield None if the file was empty
if segment is not None:
yield segment
受け入れられた回答は、メモリに収まらない大きなファイルの場合には機能しません（まれなケースではありません）。
他の人によって指摘されたように、 @ srohde answer は良いように見えますが、次の問題があります：
- ファイルオブジェクトを渡し、ユーザーに任せてどのエンコーディングで読み込むかを決定できる場合、ファイルを開くことは冗長に見えます。
ファイルオブジェクトを受け入れるようにリファクタリングしても、すべてのエンコーディングで機能するわけではありません。
utf-8エンコーディングと非ASCIIコンテンツのようなファイルを選択できます。йbuf_sizeに等しい1を渡すと、UnicodeDecodeError: 'utf8' codec can't decode byte 0xb9 in position 0: invalid start byteもちろん、テキストは大きくなりますが、
buf_sizeが選択される可能性があるため、上記のような難読化されたエラーが発生します。- カスタムの行区切り文字を指定することはできません。
- 行区切りを保持することはできません。
これらすべての懸念を考慮して、私は別々の関数を書きました：
- バイトストリームで動作するもの、
- 2番目は、テキストストリームで動作し、基礎となるバイトストリームを最初のストリームに委任し、結果の行をデコードします。
まず、次のユーティリティ関数を定義しましょう。
ceil_division天井付きの分割を行う場合（標準の//床付きの分割とは対照的に、詳細は このスレッド にあります）
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 = object_.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: int) -> bytes:
result = read_batch_from_end(object_,
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(object_,
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つのファイルを生成しました。
- empty.txt、内容なし、サイズ0MB
- tiny.txtサイズ1MB
- small.txt、サイズ10MB
- large.txt50MBのサイズ
また、ファイルパスではなくファイルオブジェクトを操作する@srohdeソリューションをリファクタリングしました。
テストスクリプト
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)))
注：collections.dequeクラスを使用してジェネレーターを使い果たしました。
出力
Windows 10上のPyPy 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
Windows 10上のCPython 3.5の場合：
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バージョンの lzパッケージ に追加しました（必要（Python 3.5+）多くの十分にテストされた機能/反復ユーティリティがあります。
のように使用できます
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)
すべての標準エンコーディング をサポートします（utf-7を除くと、 戦略 でエンコード可能な文字列を生成するのが難しいためです）。
反転した2番目のファイルを作成する単純な関数（Linuxのみ）：
import os
def tac(file1, file2):
print(os.system('tac %s > %s' % (file1,file2)))
使い方
tac('ordered.csv', 'reversed.csv')
f = open('reversed.csv')
ファイルサイズ/メモリ使用量が心配な場合は、ファイルのメモリマッピングと改行の逆スキャンが解決策です。
open（ "filename"）としてf：
print(f.read()[::-1])
def reverse_lines(filename):
y=open(filename).readlines()
return y[::-1]
ファイルを1行ずつ読み取り、逆の順序でリストに追加します。
コードの例を次に示します。
reverse = []
with open("file.txt", "r") as file:
for line in file:
line = line.strip()
reverse[0:0] = line
ほとんどの答えは、何かをする前にファイル全体を読む必要があります。このサンプルは、最後から大きくなるサンプルを読み取ります。
この答えを書いている間、私はムラト・ユクセレンの答えを見ただけです。それはほぼ同じですが、良いことだと思います。以下のサンプルも\ rを扱い、各ステップでバッファサイズを増やします。このコードをバックアップするための ユニットテスト もあります。
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
ファイルを操作するときは、すべてを自動的に処理するため、常にwithを使用します。
with open('filename', 'r') as f:
for line in reversed(f.readlines()):
print line
またはPython 3で：
with open('filename', 'r') as f:
for line in reversed(list(f.readlines())):
print(line)
最初にファイルを読み取り形式で開き、変数に保存してから、2番目のファイルを書き込み形式で開き、[::-1]スライスを使用して変数を書き込みまたは追加し、ファイルを完全に反転する必要があります。また、readlines（）を使用して行のリストにすることもできます。
def copy_and_reverse(filename, newfile):
with open(filename) as file:
text = file.read()
with open(newfile, "w") as file2:
file2.write(text[::-1])
import sys
f = open(sys.argv[1] , 'r')
for line in f.readlines()[::-1]:
print line