¿Cómo leer un archivo en orden inverso?

128

¿Cómo leer un archivo en orden inverso usando python? Quiero leer un archivo desde la última línea hasta la primera línea.

Nimmy
fuente
77
¿Te refieres a "leerlo en orden inverso" o "procesar las líneas en orden inverso"? Hay una diferencia Con el primero, potencialmente el archivo no cabría en la memoria al mismo tiempo, por lo que desea procesar las líneas en orden inverso, pero no puede leer todo el archivo y revertirlo. Con el segundo, puede leer el archivo completo e invertir la lista de líneas antes de procesarlas. Entonces cual es?
Lasse V. Karlsen
1
Recomiendo esto: sin problemas de memoria y rápido: stackoverflow.com/a/260433/1212562
Brian B

Respuestas:

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

Y en Python 3:

for line in reversed(list(open("filename"))):
    print(line.rstrip())
Matt Joiner
fuente
192
Por desgracia, esto no funciona si no puede guardar todo el archivo en la memoria.
vy32
3
Además, si bien el código publicado responde a la pregunta, debemos tener cuidado al cerrar los archivos que abrimos. La withdeclaración suele ser bastante indolora.
William
1
@MichaelDavidWatson: No sin leer primero el iterador original en la memoria y luego presentar un nuevo iterador sobre el primero a la inversa.
Matt Joiner
3
@MichaelDavidWatson: puede leer un archivo al revés sin leerlo en la memoria, pero no es trivial y requiere muchas travesuras de búfer para evitar un desperdicio considerable de llamadas al sistema. También funcionará muy mal (aunque mejor que leer toda la memoria en la memoria si el archivo excede la memoria disponible).
Matt Joiner
1
@William Lo siento, ¿cómo utilizo la solución anterior usando "con abrir" mientras itero sobre el archivo y luego lo cierro limpiamente?
BringBackCommodore64
146

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 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
srohde
fuente
44
Eso no funcionará para archivos de texto en python> = 3.2, ya que por alguna razón las búsquedas relativas al final del archivo ya no son compatibles. Se puede solucionar guardando el tamaño del archivo devuelto por fh.seek(0, os.SEEK_END)y cambiando fh.seek(-offset, os.SEEK_END)también el fh.seek(file_size - offset).
Levesque
9
Después de las ediciones realizadas, esto funciona perfectamente en Python 3.5. La mejor respuesta a la pregunta.
notbad.jpeg
3
revertir este cambio para python 2 donde fh.seek()regresaNone
marengaz
1
Tenga en cuenta que esto puede no funcionar como se esperaba para los archivos de texto. Obtener bloques correctamente en orden inverso solo funciona para archivos binarios. El problema es que para archivos de texto con codificación de varios bytes (como utf8), seek()y se read()refieren a diferentes tamaños. Esa es probablemente también la razón por la cual no se admite el primer argumento de no seek()relativo a relativo a os.SEEK_END.
norok2
3
simple: 'aöaö'.encode()es b'a\xc3\xb6a\xc3\xb6'. Si guarda esto en el disco y luego lo lee en modo texto, cuando lo haga seek(2), se moverá dos bytes, por lo que seek(2); read(1)se producirá un error UnicodeDecodeError: 'utf-8' codec can't decode byte 0xb6 in position 0: invalid start byte, pero si lo hace seek(0); read(2); read(1), obtendrá lo 'a'que esperaba, es decir: seek()nunca está codificando -consciente, read()es si abres el archivo en modo texto. Ahora si tiene 'aöaö' * 1000000, sus bloques no se alinearán correctamente.
norok2
23

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

Dado que 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.

Berislav Lopac
fuente
20

También puedes 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 en 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 más documentación en http://file-read-backwards.readthedocs.io/en/latest/readme.html

usuario7321751
fuente
Gracias por esta solución Me gusta (y también voté) la solución anterior de @srohde, ya que me ayudó a entender cómo se hace, pero como desarrollador prefiero usar un módulo existente cuando puedo, así que estoy feliz de saber sobre este.
joanis
1
Esto funciona con codificación multibyte como UTF-8. La solución de búsqueda / lectura no: seek () cuenta en bytes, read () en caracteres.
Jeremitu
9
for line in reversed(open("file").readlines()):
    print line.rstrip()

Si está en Linux, puede usar el taccomando.

$ tac file

2 recetas que puedes encontrar en ActiveState aquí y aquí

ghostdog74
fuente
1
Me pregunto si invertida () consume toda la secuencia antes de la iteración. Los doctores dicen __reversed__()que se necesita un método, pero python2.5 no se queja en una clase personalizada sin él.
muhuk
@muhuk, probablemente tenga que almacenarlo de alguna manera, sospecho que genera una nueva lista en orden inverso y luego devuelve un iterador a eso
Matt Joiner
1
@ Matt: eso sería ridículo. Simplemente va de atrás hacia adelante: len (L) -1 es la espalda, 0 es el frente. Puedes imaginarte el resto.
Devin Jeanpierre
@muhuk: Las secuencias no se consumen de manera significativa (puede iterar sobre toda la secuencia, pero no importa mucho). __reversed__Tampoco es necesario un método, y no solía ser así. Si un objeto proporciona __len__y __getitem__funcionará bien (menos algunos casos excepcionales, como dict).
Devin Jeanpierre
@Devin Jeanpierre: ¿Solo si readlines () devuelve un objeto que proporciona __reversed__?
Matt Joiner
8
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)
Ignacio Vazquez-Abrams
fuente
Esto parece producir una salida incorrecta para archivos más grandes que el búfer. No entiendo correctamente las líneas que abarcan los fragmentos del tamaño del búfer que lees, según tengo entendido. Publiqué otra respuesta similar (a otra pregunta similar).
Darius Bacon
@Darius: Ah sí, parece que me he perdido un poco. Debería arreglarse ahora.
Ignacio Vazquez-Abrams
Se ve bien Todavía prefiero mi propio código porque esto funciona O (N ^ 2) en un archivo grande que es todo una larga línea. (En las respuestas similares a la otra pregunta que probé, esto causó una seria desaceleración genuina en tales archivos).
Darius Bacon
3
Bueno, la pregunta no mencionó el rendimiento, por lo que no puedo analizar el desastre del rendimiento que son expresiones regulares: P
Matt Joiner
Una explicación más sería útil como rendimiento y si esto realmente puede tratar de decir la última línea y leer solo esa pieza.
user1767754
7

La respuesta aceptada no funcionará para casos con archivos grandes que no caben en la memoria (lo cual no es un caso raro).

Como lo señalaron otros, la respuesta de @srohde se ve bien, pero tiene los siguientes problemas:

  • abrir el archivo parece redundante, cuando podemos pasar el objeto del archivo y dejar que el usuario decida en qué codificación se debe leer,
  • incluso si refactorizamos para aceptar el objeto de archivo, no funcionará para todas las codificaciones: podemos elegir archivos con utf-8codificación y contenido no ascii como

    й

    pasar buf_sizeigual 1y tendrá

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

    por supuesto, el texto puede ser más grande, pero buf_sizepuede ser recogido para que conduzca a un error ofuscado como el anterior,

  • no podemos especificar un separador de línea personalizado,
  • No podemos elegir mantener el separador de línea.

Entonces, considerando todas estas preocupaciones, he escrito funciones separadas:

  • uno que funciona con flujos de bytes,
  • segundo que trabaja con secuencias de texto y delega su secuencia de bytes subyacente a la primera y decodifica las líneas resultantes.

En primer lugar, definamos las siguientes funciones de utilidad:

ceil_divisionpara hacer división con techo (en contraste con la //división estándar con piso, se puede encontrar más información en este hilo )

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

split para dividir cadenas por un separador dado del extremo derecho con la capacidad de mantenerlo:

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 para leer el lote desde el extremo derecho de la secuencia binaria

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)

Después de eso, podemos definir la función para leer el flujo de bytes en orden inverso 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

y finalmente una función para invertir el archivo de texto se puede definir 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))

Pruebas

Preparativos

He generado 4 archivos usando el fsutilcomando :

  1. empty.txt sin contenido, tamaño 0MB
  2. tiny.txt con un tamaño de 1 MB
  3. small.txt con un tamaño de 10 MB
  4. large.txt con un tamaño de 50 MB

También he refactorizado la solución @srohde para trabajar con el objeto de archivo en lugar de la ruta del archivo.

Script de prueba

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 : He usado collections.dequeclass para agotar el generador.

Salidas

Para PyPy 3.5 en 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 CPython 3.5 en 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

Entonces, como podemos ver, funciona como una solución original, pero es más general y está libre de las desventajas mencionadas anteriormente.


Anuncio

He agregado esto a la 0.3.0versión del lzpaquete (requiere Python 3.5 +) que tiene muchas utilidades funcionales / iterativas bien probadas.

Se puede usar 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)

Admite todas las codificaciones estándar (tal vez excepto utf-7porque es difícil para mí definir una estrategia para generar cadenas codificables con él).

Azat Ibrakov
fuente
2

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

Y también el uso de RAM puede aumentar si no hay nuevas líneas para más de bytes de búfer, la variable "fuga" 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
Bekir Dogan
fuente
2

Gracias por la respuesta @srohde. Tiene una pequeña comprobación de errores para 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 administrar el archivo abierto afuera 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 identificador 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://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
Murat Yükselen
fuente
1

Una función simple para crear un segundo archivo invertido (solo 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')
Alexandre Andrade
fuente
Creo que el objetivo era cómo hacerlo en Python. Además, esto solo funciona en sistemas * Nix, aunque es una excelente solución para eso. Esencialmente, solo usa Python como un indicador para ejecutar utilidades de shell.
Alexander Huszagh
1
Este código tiene errores de seguridad importantes tal como están escritos actualmente. ¿Qué sucede si está tratando de revertir un archivo creado con mv mycontent.txt $'hello $(rm -rf $HOME) world.txt', o de manera similar, utilizando un nombre de archivo de salida dado por un usuario no confiable? Si desea manejar nombres de archivos arbitrarios de forma segura, se requiere más precaución. subprocess.Popen(['tac', file1], stdout=open(file2, 'w'))estaría a salvo, por ejemplo.
Charles Duffy el
El código existente tampoco maneja correctamente los archivos con espacios, comodines, etc.
Charles Duffy el
1

con abierto ("nombre de archivo") como f:

    print(f.read()[::-1])
JackoM
fuente
¿Esto lee todo el archivo? ¿Es esto seguro en archivos grandes? Esta parece ser una forma muy fácil y realista de hacerlo, pero no estoy seguro acerca de las preguntas anteriores ... Me gustaría buscar el archivo de esta manera (usando re) ...
ikwyl6
@ ikwyl6 Esto debería ser equivalente a list(reversed(f.read())).
AMC
0
def reverse_lines(filename):
    y=open(filename).readlines()
    return y[::-1]
Gareema
fuente
¿No es esencialmente la misma solución que la respuesta aceptada ?
AMC
0

Úselo siempre withcuando 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)
Carlos Afonso
fuente
0

primero debería abrir su archivo en formato de lectura, guardarlo en una variable, luego abrir el segundo archivo en formato de escritura donde escribiría o agregaría la variable usando el segmento [:: - 1], invirtiendo completamente 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])
PawlakJ
fuente
0

La mayoría de las respuestas necesitan leer el archivo completo antes de hacer nada. Esta muestra lee muestras cada vez más grandes desde el final .

Solo vi la respuesta de Murat Yükselen mientras escribía esta respuesta. Es casi lo mismo, lo que supongo que es algo bueno. El siguiente ejemplo también trata \ r y aumenta su tamaño de búfer en cada paso. También tengo algunas pruebas unitarias para respaldar este 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
Almar
fuente
0

Lea el archivo línea por línea y luego agréguelo a una lista en orden inverso.

Aquí hay un ejemplo de código:

reverse = []
with open("file.txt", "r") as file:
    for line in file:
        line = line.strip()
         reverse[0:0] = line
Willy Wonka
fuente
Esto simplemente parece una versión inferior de la solución en la respuesta aceptada .
AMC
0
import sys
f = open(sys.argv[1] , 'r')
for line in f.readlines()[::-1]:
    print line
Powerup California
fuente
¿No es esencialmente la misma solución que la respuesta aceptada ?
AMC
0
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)
Vyacheslav
fuente
-3

Tuve que hacer esto hace algún tiempo y usé el siguiente código. Se canaliza a la cáscara. Me temo que ya no tengo el script completo. Si tiene un sistema operativo unixish, puede usar "tac", sin embargo, por ejemplo, en Mac OSX el comando tac no funciona, use tail -r. El siguiente fragmento de código prueba en 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)
Jeorgen
fuente
El cartel busca una respuesta de Python.
mikemaccana
Bueno, es una respuesta de Python, aunque parece estar incompleta.
DrDee
2
no es, no es una plataforma cruzada, usando comandos del sistema = no pitónico
Phyo Arkar Lwin
El póster está buscando una respuesta "usando Python", en la que está escrito el fragmento de código. Pero estoy de acuerdo en que no es una muy buena solución en comparación con muchos de los otros publicados.
jeorgen
1
El fragmento no es lo suficientemente completo como para evaluar la corrección (no se muestran otras partes de la invocación), pero el almacenamiento de comandos de shell en cadenas es en sí mismo altamente sospechoso: es fácil tener errores de inyección de shell a menos que se haga mucho. de cuidado.
Charles Duffy el