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にあります。

for line in reversed(open("file").readlines()):
    print line.rstrip()

Linuxを使用している場合は、tacコマンドを使用できます。

$ tac file

こことここでActiveStateにある2つのレシピ

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の回答は良さそうですが、次の問題があります。

• ファイルオブジェクトを渡して、どのエンコーディングで読み取るかをユーザーに任せることができる場合、ファイルを開くことは冗長に見えます。

• ファイルオブジェクトを受け入れるようにリファクタリングしても、すべてのエンコーディングで機能するわけではありません。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 = 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コマンドを使用して4つのファイルを生成しました：

1. 内容のないempty.txt、サイズ0MB
2. サイズが1MBのtiny.txt
3. サイズが10MBのsmall.txt
4. サイズが50MBのlarge.txt

また、@ 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バージョン（Python 3.5 + が必要）に追加しました。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)

すべての標準エンコーディングをサポートします（コード化可能utf-7な文字列を生成するための戦略を定義するのが難しいためを除いて）。

ここに私の実装を見つけることができます。「バッファ」変数を変更することでRAMの使用を制限できます。プログラムが最初に空の行を出力するというバグがあります。

また、バッファバイトを超える新しい行がない場合は、RAMの使用量が増加する可能性があります。「リーク」変数は、新しい行（「\ 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つの評判で回答にコメントできませんでした。また、外で開いているファイルを管理したいのです。これにより、ルイージタスクのとりとめを埋め込むことができます。

私が変更する必要があったのは次の形式です：

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

リバースされた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]

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])

答えのほとんどは、何かを行う前にファイル全体を読み取る必要があります。このサンプルは、最後から次第に大きなサンプルを読み取ります。

MuratYükselenの回答は、この回答を書いているときだけ見ました。ほぼ同じですが、良いことだと思います。以下のサンプルも\ 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

ファイルを1行ずつ読み取り、逆の順序でリストに追加します。

次にコードの例を示します。

reverse = []
with open("file.txt", "r") as file:
    for line in file:
        line = line.strip()
         reverse[0:0] = line

import sys
f = open(sys.argv[1] , 'r')
for line in f.readlines()[::-1]:
    print line

def previous_line(self, opened_file):
        opened_file.seek(0, os.SEEK_END)
        position = opened_file.tell()
        buffer = bytearray()
        while position >= 0:
            opened_file.seek(position)
            position -= 1
            new_byte = opened_file.read(1)
            if new_byte == self.NEW_LINE:
                parsed_string = buffer.decode()
                yield parsed_string
                buffer = bytearray()
            elif new_byte == self.EMPTY_BYTE:
                continue
            else:
                new_byte_array = bytearray(new_byte)
                new_byte_array.extend(buffer)
                buffer = new_byte_array
        yield None

使用する：

opened_file = open(filepath, "rb")
iterator = self.previous_line(opened_file)
line = next(iterator) #one step
close(opened_file)

私はこれを少し前に行う必要があり、以下のコードを使用しました。それはシェルにパイプします。完全なスクリプトはもうありません。UNIXオペレーティングシステムを使用している場合は、「tac」を使用できますが、Mac OSXではtacコマンドが機能しない場合は、tail -rを使用します。以下のコードスニペットは、使用しているプラ​​ットフォームをテストし、それに応じてコマンドを調整します

# We need a command to reverse the line order of the file. On Linux this
# is 'tac', on OSX it is 'tail -r'
# 'tac' is not supported on osx, 'tail -r' is not supported on linux.

if sys.platform == "darwin":
    command += "|tail -r"
elif sys.platform == "linux2":
    command += "|tac"
else:
    raise EnvironmentError('Platform %s not supported' % sys.platform)