Чтение файла в обратном порядке с помощью python

правильный, эффективный ответ, написанный как генератор.

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 concact the segment to the last line of new chunk
                # instead, yield the segment first 
                if buffer[-1] is not '\n':
                    lines[-1] += segment
                else:
                    yield segment
            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

Как насчет чего-то вроде этого:

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 file

2 рецепта вы можете найти в ActiveState здесь и здесь

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)

здесь вы можете найти мою реализацию my, вы можете ограничить использование ОЗУ, изменив переменную "буфер", есть ошибка, что программа печатает пустую строку в начале.

а также использование ОЗУ может быть увеличено, если нет новых строк для более чем буферных байтов, переменная "утечка" будет увеличиваться до появления новой строки ("\n").

Это также работает для 16 ГБ файлов, которые больше, чем моя общая память.

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

простая функция для создания второго файла в обратном порядке (только для linux):

import os
def tac(file1, file2):
     print(os.system('tac %s > %s' % (file1,file2)))

Как использовать

tac('ordered.csv', 'reversed.csv')
f = open('reversed.csv')

Если вас беспокоит размер файла / использование памяти, memory-mapping файл и сканирование назад для новых строк-это решение:

как искать строку в текстовых файлах?

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)

вам нужно будет сначала открыть файл в формате чтения, сохранить его в переменную, а затем открыть второй файл в формате записи, где вы будете писать или добавлять переменную, используя срез [::-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])

большинство ответов нужно прочитать весь файл, прежде чем что-либо делать. Этот образец читает все более крупные образцы С конца.

Я только видел ответ Мурата Юкселена, когда писал этот ответ. Это почти то же самое, что, я полагаю, хорошо. Приведенный ниже пример также имеет дело с \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

Я должен был сделать это некоторое время назад и использовал ниже код. Это трубы к раковине. Боюсь, что у меня больше нет полного сценария. Если вы находитесь в операционной системе unixish, вы можете использовать "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)