Como ler um arquivo na ordem inversa usando python? Quero ler um arquivo da última linha para a primeira linha.

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

E no Python 3:

for line in reversed(list(open("filename"))):
    print(line.rstrip())

Uma resposta correta e eficiente escrita como um gerador.

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

Que tal algo como isso:

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

Como o arquivo é lido caractere por caractere na ordem inversa, ele funcionará mesmo em arquivos muito grandes, desde que linhas individuais se ajustem à memória.

Você também pode usar o módulo python file_read_backwards.

Após a instalação, via pip install file_read_backwards(v1.2.1), você pode ler o arquivo inteiro de trás para a frente (em linhas) de uma maneira eficiente em termos de memória, através de:

#!/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

Ele suporta as codificações "utf-8", "latin-1" e "ascii".

O suporte também está disponível para python3. Mais documentação pode ser encontrada em http://file-read-backwards.readthedocs.io/en/latest/readme.html

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

Se você estiver no linux, poderá usar o taccomando

$ tac file

2 receitas que você pode encontrar no ActiveState aqui e aqui

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)

A resposta aceita não funcionará para casos com arquivos grandes que não cabem na memória (o que não é um caso raro).

Como foi observado por outros, a resposta @srohde parece boa, mas tem os próximos problemas:

• o arquivo de abertura parece redundante, quando podemos passar o objeto de arquivo e deixar para o usuário decidir em qual codificação deve ser lida,

• mesmo se refatorarmos para aceitar o objeto de arquivo, ele não funcionará para todas as codificações: podemos escolher um arquivo com utf-8conteúdo de codificação e não-ascii, como

  й

  passar buf_sizeigual 1e terá

  UnicodeDecodeError: 'utf8' codec can't decode byte 0xb9 in position 0: invalid start byte

  é claro que o texto pode ser maior, mas buf_sizepode ser coletado, resultando em erro ofuscado, como acima,

• não podemos especificar separador de linha personalizado,
• não podemos optar por manter o separador de linhas.

Portanto, considerando todas essas preocupações, escrevi funções separadas:

• um que trabalha com fluxos de bytes,
• o segundo que trabalha com fluxos de texto e delega seu fluxo de bytes subjacente ao primeiro e decodifica as linhas resultantes.

Antes de tudo, vamos definir as próximas funções utilitárias:

ceil_divisionpara fazer divisão com teto (em contraste com a //divisão padrão com piso, mais informações podem ser encontradas neste tópico )

def ceil_division(left_number, right_number):
    """
    Divides given numbers with ceiling.
    """
    return -(-left_number // right_number)

split para dividir a string pelo separador fornecido da extremidade direita, com capacidade de mantê-la:

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 ler lote da extremidade direita do fluxo binário

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)

Depois disso, podemos definir a função para ler o fluxo de bytes em ordem inversa, como

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

e, finalmente, uma função para reverter o arquivo de texto pode ser definida como:

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

Testes

Preparações

Eu criei 4 arquivos usando o fsutilcomando :

1. empty.txt sem conteúdo, tamanho 0MB
2. tiny.txt com tamanho de 1MB
3. small.txt com tamanho de 10 MB
4. large.txt com tamanho de 50MB

Também refatorei a solução @srohde para trabalhar com o objeto de arquivo em vez do caminho do arquivo.

Script de teste

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

Nota : Eu usei collections.dequeclasse para esgotar o gerador.

Saídas

Para o PyPy 3.5 no Windows 10:

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

Para o CPython 3.5 no Windows 10:

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

Então, como podemos ver, ele funciona como solução original, mas é mais geral e livre de suas desvantagens listadas acima.

Propaganda

Adicionei isso à 0.3.0versão do lzpacote (requer Python 3.5 +) que possui muitos utilitários funcionais / de iteração bem testados.

Pode ser usado como

 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)

Ele suporta todas as codificações padrão (talvez, exceto utf-7porque é difícil para mim definir uma estratégia para gerar cadeias codificáveis ​​com ela).

Aqui você pode encontrar minha implementação, você pode limitar o uso de memória RAM alterando a variável "buffer"; existe um erro que o programa imprime uma linha vazia no início.

E também o uso de memória RAM pode aumentar se não houver novas linhas com mais de bytes de buffer, a variável "leak" aumentará até ver uma nova linha ("\ n").

Isso também funciona para arquivos de 16 GB, que são maiores que minha memória total.

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

Obrigado pela resposta @srohde. Ele tem um pequeno erro ao verificar o caractere de nova linha com o operador 'is' e não pude comentar a resposta com 1 reputação. Também gostaria de gerenciar a abertura de arquivos do lado de fora, porque isso me permite incorporar minhas divagações para tarefas luigi.

O que eu precisava mudar tem a forma:

with open(filename) as fp:
    for line in fp:
        #print line,  # contains new line
        print '>{}<'.format(line)

Gostaria de mudar para:

with open(filename) as fp:
    for line in reversed_fp_iter(fp, 4):
        #print line,  # contains new line
        print '>{}<'.format(line)

Aqui está uma resposta modificada que deseja manipular um arquivo e mantém novas linhas:

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

uma função simples para criar um segundo arquivo invertido (somente linux):

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

Como usar

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

Se você estiver preocupado com o tamanho do arquivo / uso da memória, mapear a memória do arquivo e digitalizar para trás em busca de novas linhas é uma solução:

Como procurar uma string em arquivos de texto?

com aberto ("nome do arquivo") como f:

    print(f.read()[::-1])

def reverse_lines(filename):
    y=open(filename).readlines()
    return y[::-1]

Sempre use withao trabalhar com arquivos, pois lida com tudo para você:

with open('filename', 'r') as f:
    for line in reversed(f.readlines()):
        print line

Ou no Python 3:

with open('filename', 'r') as f:
    for line in reversed(list(f.readlines())):
        print(line)

você precisaria primeiro abrir seu arquivo no formato de leitura, salvá-lo em uma variável e, em seguida, abrir o segundo arquivo no formato de gravação em que gravaria ou acrescentaria a variável usando uma fatia [:: - 1], revertendo completamente o arquivo. Você também pode usar readlines () para torná-lo uma lista de linhas, que você pode manipular

def copy_and_reverse(filename, newfile):
    with open(filename) as file:
        text = file.read()
    with open(newfile, "w") as file2:
        file2.write(text[::-1])

A maioria das respostas precisa ler o arquivo inteiro antes de fazer qualquer coisa. Esta amostra lê amostras cada vez maiores do final .

Eu só vi a resposta de Murat Yükselen enquanto escrevia essa resposta. É quase o mesmo, o que eu acho que é uma coisa boa. A amostra abaixo também lida com \ re aumenta seu tamanho do buffer em cada etapa. Eu também tenho alguns testes de unidade para fazer backup desse código.

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

Leia o arquivo linha por linha e adicione-o em uma lista na ordem inversa.

Aqui está um exemplo de código:

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

usar:

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

Eu tive que fazer isso há algum tempo e usei o código abaixo. Tubos para a concha. Receio não ter mais o script completo. Se você estiver em um sistema operacional unixish, poderá usar "tac"; no entanto, por exemplo, no comando Mac OSX tac não funciona, use tail -r. O trecho de código abaixo testa qual plataforma você está e ajusta o comando de acordo

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