Come leggere un file in ordine inverso?


128

Come leggere un file in ordine inverso usando Python? Voglio leggere un file dall'ultima riga alla prima riga.


7
Intendi "leggilo in ordine inverso" o "elabora le righe in ordine inverso"? C'è una differenza Con il primo, potenzialmente il file non si adatterà alla memoria contemporaneamente, quindi si desidera elaborare le righe in ordine inverso, ma non è possibile leggere l'intero file e invertirlo. Con il secondo, potresti semplicemente leggere l'intero file e invertire l'elenco delle righe prima di elaborarle. Quindi che cos'è?
Lasse V. Karlsen,


1
Lo consiglio - nessun problema di memoria e veloce: stackoverflow.com/a/260433/1212562
Brian B

Risposte:


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

E in Python 3:

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

192
Purtroppo, questo non funziona se non è possibile adattare l'intero file in memoria.
vy32,

3
Inoltre, mentre il codice pubblicato risponde alla domanda, dovremmo fare attenzione a chiudere i file che apriamo. L' withaffermazione è di solito abbastanza indolore.
William

1
@MichaelDavidWatson: Non senza prima leggere l'iteratore originale in memoria e poi presentare un nuovo iteratore sopra il primo al contrario.
Matt Joiner,

3
@MichaelDavidWatson: puoi leggere un file al contrario senza leggerlo in memoria ma non è banale e richiede molti shenanigans buffer per evitare un notevole spreco di chiamate di sistema. Funzionerà anche molto male (anche se meglio di leggere l'intera memoria in memoria se il file supera la memoria disponibile).
Matt Joiner,

1
@William Siamo spiacenti, come posso utilizzare la soluzione sopra usando "con open" mentre eseguo l'iterazione sul file e quindi lo pulisco?
BringBackCommodore64

146

Una risposta corretta ed efficiente scritta come generatore.

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

4
Ciò non funzionerà per i file di testo in python> = 3.2, poiché per qualche motivo le ricerche relative alla fine del file non sono più supportate. Può essere risolto salvando la dimensione del file restituito fh.seek(0, os.SEEK_END)e cambiando fh.seek(-offset, os.SEEK_END)anche fh.seek(file_size - offset).
Levesque,

9
Dopo le modifiche apportate, funziona perfettamente in Python 3.5. La migliore risposta alla domanda.
notbad.jpeg,

3
annulla questa modifica per python 2 dove fh.seek()ritornaNone
marengaz

1
Attenzione, potrebbe non funzionare come previsto per i file di testo. Ottenere correttamente i blocchi in ordine inverso funziona solo con file binari. Il problema è che per i file di testo con codifica multi-byte (come utf8) seek()e read()fare riferimento a dimensioni diverse. Questo è probabilmente anche il motivo per cui il primo argomento diverso da zero di seek()relative a os.SEEK_ENDnon è supportato.
norok2

3
semplice: 'aöaö'.encode()è b'a\xc3\xb6a\xc3\xb6'. Se lo salvi su disco e poi leggi in modalità testo, quando lo fai seek(2)si sposterà di due byte, quindi ciò seek(2); read(1)comporterà un errore UnicodeDecodeError: 'utf-8' codec can't decode byte 0xb6 in position 0: invalid start byte, ma se lo fai seek(0); read(2); read(1), otterrai quello che 'a'ti aspettavi, cioè: seek()non è mai la codifica -consapevole, read()è se si apre il file in modalità testo. Se sì 'aöaö' * 1000000, i tuoi blocchi non saranno allineati correttamente.
norok2

23

Che ne dici di qualcosa del genere:

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

Poiché il file viene letto carattere per carattere in ordine inverso, funzionerà anche su file molto grandi, purché le singole righe si adattino alla memoria.


20

Puoi anche usare il modulo python file_read_backwards.

Dopo averlo installato, tramite pip install file_read_backwards(v1.2.1), è possibile leggere l'intero file all'indietro (a livello di riga) in modo efficiente dalla memoria tramite:

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

Supporta le codifiche "utf-8", "latin-1" e "ascii".

Il supporto è disponibile anche per python3. Ulteriore documentazione è disponibile all'indirizzo http://file-read-backwards.readthedocs.io/en/latest/readme.html


Grazie per questa soluzione Mi piace (e ho anche votato) la soluzione sopra di @srohde poiché mi ha aiutato a capire come è fatto, ma come sviluppatore preferisco usare un modulo esistente quando posso, quindi sono felice di conoscerlo.
joanis,

1
Funziona con la codifica multibyte come UTF-8. La soluzione seek / read non: seek () conta in byte, read () in caratteri.
Jeremitu,

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

Se sei su Linux, puoi usare il taccomando.

$ tac file

2 ricette che puoi trovare in ActiveState qui e qui


1
Mi chiedo se reversed () consuma l'intera sequenza prima dell'iterazione. I documenti dicono __reversed__()che è necessario un metodo, ma python2.5 non si lamenta di una classe personalizzata senza di essa.
Muhuk,

@muhuk, probabilmente deve in qualche modo memorizzarlo nella cache, sospetto che generi un nuovo elenco in ordine inverso, quindi restituisce un iteratore a quello
Matt Joiner,

1
@Matt: sarebbe ridicolo. Va semplicemente dalla parte posteriore alla parte anteriore: len (L) -1 è la parte posteriore, 0 è la parte anteriore. Puoi immaginare il resto.
Devin Jeanpierre,

@muhuk: le sequenze non vengono consumate in modo significativo (puoi iterare sull'intera sequenza, ma non importa molto). __reversed__Inoltre, non è necessario un metodo e non esisteva una cosa del genere. Se un oggetto fornisce __len__e __getitem__funzionerà bene (meno alcuni casi eccezionali, come ad esempio dict).
Devin Jeanpierre,

@Devin Jeanpierre: Solo se readlines () restituisce un oggetto che fornisce __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)

Ciò sembra produrre un output errato per file più grandi del buffer. Non gestirà correttamente le linee che coprono i blocchi di dimensioni buffer in cui leggi, a quanto ho capito. Ho pubblicato un'altra risposta simile (a un'altra domanda simile).
Darius Bacon,

@Dario: Ah sì, mi sembra di essermi perso un po '. Ora dovrebbe essere risolto.
Ignacio Vazquez-Abrams,

Sembra giusto Preferirei ancora il mio codice perché questo O (N ^ 2) funziona su un file di grandi dimensioni che è tutto una linea lunga. (Nelle risposte simili all'altra domanda che ho provato questo ha causato un serio rallentamento genuino su tali file.)
Darius Bacon

3
Beh, la domanda non ha menzionato la performance, quindi non posso rispondere al disastro della performance che è espressioni regolari: P
Matt Joiner

Qualche spiegazione in più sarebbe utile come performance e se questo in realtà può cercare di dire l'ultima riga e leggere solo quel pezzo.
user1767754

7

La risposta accettata non funzionerà per i casi con file di grandi dimensioni che non rientrano nella memoria (che non è un caso raro).

Come è stato notato da altri, la risposta di @srohde sembra buona, ma ha i prossimi problemi:

  • il file openning sembra ridondante, quando possiamo passare l'oggetto file e lasciarlo all'utente per decidere in quale codifica deve essere letto,
  • anche se rifattiamo di accettare l'oggetto file, non funzionerà per tutte le codifiche: possiamo scegliere file con utf-8codifica e contenuti non ascii come

    й

    passare buf_sizeuguale 1e avrà

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

    ovviamente il testo può essere più grande ma buf_sizepuò essere raccolto in modo da causare errori offuscati come sopra,

  • non possiamo specificare un separatore di riga personalizzato,
  • non possiamo scegliere di mantenere il separatore di riga.

Quindi, considerando tutte queste preoccupazioni, ho scritto funzioni separate:

  • uno che funziona con flussi di byte,
  • il secondo che lavora con flussi di testo e delega il flusso di byte sottostante al primo e decodifica le righe risultanti.

Innanzitutto definiamo le prossime funzioni di utilità:

ceil_divisionper la divisione con soffitto (a differenza della //divisione standard con pavimento, ulteriori informazioni sono disponibili in questa discussione )

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

split per dividere la stringa in base al separatore dato dall'estremità destra con la possibilità di mantenerla:

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 per leggere il batch dall'estremità destra del flusso binario

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)

Dopodiché possiamo definire la funzione per leggere il flusso di byte in ordine inverso come

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 infine una funzione per invertire il file di testo può essere definita come:

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

test

preparativi

Ho generato 4 file usando il fsutilcomando :

  1. empty.txt senza contenuto, dimensioni 0 MB
  2. tiny.txt con dimensioni di 1 MB
  3. small.txt con dimensioni di 10 MB
  4. large.txt con dimensioni di 50 MB

inoltre ho refactored la soluzione @srohde per lavorare con l'oggetto file anziché il percorso del file.

Test script

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 : ho usato la collections.dequeclasse per il generatore di scarico.

Uscite

Per PyPy 3.5 su 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

Per CPython 3.5 su 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

Come possiamo vedere, funziona come una soluzione originale, ma è più generale e privo dei suoi svantaggi elencati sopra.


Annuncio pubblicitario

Ho aggiunto questo alla 0.3.0versione del lzpacchetto (richiede Python 3.5 +) che ha molte utilità funzionali / iteranti ben testate.

Può essere usato come

 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)

Supporta tutte le codifiche standard (forse tranne utf-7per il fatto che per me è difficile definire una strategia per generare stringhe codificabili con essa).


2

Qui puoi trovare la mia implementazione, puoi limitare l'utilizzo della RAM modificando la variabile "buffer", c'è un bug che il programma stampa una riga vuota all'inizio.

E anche l'utilizzo della RAM può aumentare se non ci sono nuove righe per più di byte buffer, la variabile "leak" aumenterà fino a vedere una nuova riga ("\ n").

Questo funziona anche con file da 16 GB che sono più grandi della mia memoria totale.

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

2

Grazie per la risposta @srohde. Ha un piccolo bug che controlla il carattere di nuova riga con l'operatore 'is' e non ho potuto commentare la risposta con 1 reputazione. Inoltre, vorrei gestire il file aperto all'esterno perché ciò mi consente di incorporare le mie divagazioni per le attività di luigi.

Quello che dovevo cambiare ha la forma:

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

Mi piacerebbe cambiare in:

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

Ecco una risposta modificata che vuole un file handle e mantiene le nuove righe:

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

1

una semplice funzione per creare un secondo file invertito (solo Linux):

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

come usare

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

Penso che l'obiettivo fosse come farlo in Python. Inoltre, funziona solo su sistemi * Nix, anche se è un'ottima soluzione per questo. In sostanza, utilizza Python solo come prompt per eseguire utility di shell.
Alexander Huszagh,

1
Questo codice presenta importanti bug di sicurezza come attualmente scritti. Cosa succede se si sta tentando di invertire un file creato con mv mycontent.txt $'hello $(rm -rf $HOME) world.txt'o in modo simile utilizzando un nome di file di output fornito da un utente non attendibile? Se si desidera gestire in modo sicuro nomi di file arbitrari, è necessario prestare maggiore attenzione. subprocess.Popen(['tac', file1], stdout=open(file2, 'w'))sarebbe sicuro, per esempio.
Charles Duffy,

Inoltre, il codice esistente non gestisce correttamente i file con spazi, caratteri jolly e così via.
Charles Duffy,


1

con open ("nome file") come f:

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

Questo legge l'intero file in? È sicuro su file di grandi dimensioni? Questo sembra essere un modo molto semplice e realistico per farlo, ma non sono sicuro delle domande di cui sopra. Vorrei cercare il file in questo modo (usando re) ..
ikwyl6

@ ikwyl6 Questo dovrebbe essere equivalente a list(reversed(f.read())).
AMC,


0

Utilizzare sempre withquando si lavora con i file in quanto gestisce tutto per te:

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

O in Python 3:

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

0

dovresti prima aprire il tuo file in formato di lettura, salvarlo in una variabile, quindi aprire il secondo file in formato di scrittura in cui scrivere o aggiungere la variabile usando una sezione [:: - 1], invertendo completamente il file. Puoi anche usare readlines () per trasformarlo in un elenco di righe, che puoi manipolare

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

0

La maggior parte delle risposte deve leggere l'intero file prima di fare qualsiasi cosa. Questo esempio legge campioni sempre più grandi dalla fine .

Ho visto la risposta di Murat Yükselen solo mentre scrivevo questa risposta. È quasi lo stesso, che suppongo sia una buona cosa. Il seguente esempio si occupa anche di \ r e aumenta la sua dimensione buffer ad ogni passaggio. Ho anche alcuni test unitari per il backup di questo codice.

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

0

Leggi il file riga per riga, quindi aggiungilo a un elenco in ordine inverso.

Ecco un esempio di codice:

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

Questa sembra solo una versione inferiore della soluzione nella risposta accettata .
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

usare:

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

-3

Ho dovuto farlo qualche tempo fa e ho usato il codice qui sotto. Si collega al guscio. Temo di non avere più lo script completo. Se si utilizza un sistema operativo unixish, è possibile utilizzare "tac", tuttavia ad es. Su Mac OSX il comando tac non funziona, utilizzare tail -r. Lo snippet di codice seguente verifica la piattaforma su cui ti trovi e regola di conseguenza il comando

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

Il poster sta cercando una risposta in pitone.
mikemaccana,

Bene, è una risposta Python anche se sembra essere incompleta.
DrDee,

2
non è, non è multipiattaforma, usando i comandi di sistema = non pitonico
Phyo Arkar Lwin,

Il mittente sta cercando una risposta "usando python", in cui lo snippet di codice è effettivamente scritto. Ma sono d'accordo che non è una soluzione molto buona rispetto a molte delle altre pubblicate.
jeorgen,

1
Lo snippet non è abbastanza completo per valutare la correttezza (non vengono mostrate altre parti dell'invocazione), ma l'archiviazione dei comandi della shell nelle stringhe è di per sé altamente sospetta - è facile avere bug di iniezione della shell a meno che non prendano molto di cura.
Charles Duffy,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.