Lea un archivo en orden inverso usando Python

file reverse

Question

¿Cómo leer un archivo en orden inverso usando Python? Quiero leer un archivo de la última línea a la primera línea.

Answer 1

Aquí puede encontrar mi implementación, puede limitar el uso del ram cambiando la variable "buffer", hay un error de que el programa imprime una línea vacía al principio.

Y también el uso del ram puede aumentar si no hay líneas nuevas para más bytes de buffer, la variable "leak" aumentará hasta ver una nueva línea ("/ n").

Esto también funciona para archivos de 16 GB, que es más grande que mi memoria 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

Answer 2

Gracias por la respuesta @srohde. Tiene un pequeño error para verificar el carácter de nueva línea con el operador ''es'', y no pude comentar la respuesta con 1 reputación. También me gustaría gestionar el archivo abierto al aire libre porque eso me permite incrustar mis divagaciones para las tareas de luigi.

Lo que necesitaba cambiar tiene la forma:

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

Me encantaría cambiar a:

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

Aquí hay una respuesta modificada que quiere un manejador de archivo y mantiene nuevas líneas:

def reversed_fp_iter(fp, buf_size=8192):
    """a generator that returns the lines of a file in reverse order
    ref: https://.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

Answer 3

Qué tal algo como esto:

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 el archivo se lee carácter por carácter en orden inverso, funcionará incluso en archivos muy grandes, siempre que las líneas individuales quepan en la memoria.

Answer 4

Si le preocupa el uso del tamaño de archivo / memoria, mapear la memoria del archivo y escanear hacia atrás las nuevas líneas es una solución:

¿Cómo buscar una cadena en archivos de texto?

Answer 5

Siempre utilícelo cuando trabaje con archivos, ya que maneja todo por usted:

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

O en Python 3:

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

Answer 6

También puede usar el módulo python file_read_backwards .

Después de instalarlo, a través de pip install file_read_backwards (v1.2.1), puede leer todo el archivo al revés (en línea) de una manera eficiente de la memoria a travé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

Admite codificaciones "utf-8", "latin-1" y "ascii".

El soporte también está disponible para python3. Se puede encontrar documentación adicional en http://file-read-backwards.readthedocs.io/en/latest/readme.html

Answer 7

Tuve que hacer esto hace algún tiempo y usé el siguiente código. Se canaliza hacia el caparazón. Me temo que ya no tengo el guion completo. Si tiene un sistema operativo unixish, puede usar "tac"; sin embargo, p. Ej., El comando tac de Mac OSX no funciona, utilice tail -r. El siguiente fragmento de código prueba para qué plataforma estás y ajusta el comando en consecuencia

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

Answer 8

Una respuesta correcta y eficiente escrita como generador.

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

Answer 9

primero necesitaría abrir el archivo en formato de lectura, guardarlo en una variable y luego abrir el segundo archivo en formato de escritura donde escribiría o anexaría la variable utilizando un segmento [:: - 1], invirtiendo por completo el archivo. También puede usar readlines () para convertirlo en una lista de líneas, que puede 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])

Answer 10

una función simple para crear un segundo archivo invertido (solo en Linux):

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

cómo utilizar

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

Answer 11

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)

Answer 12

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

Answer 13

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

Si está en linux, puede usar el comando tac .

$ tac file

2 recetas que puedes encontrar en ActiveState here y here

Answer 14

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

Y en Python 3:

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