Wie lese ich eine Datei in umgekehrter Reihenfolge?

128

Wie lese ich eine Datei in umgekehrter Reihenfolge mit Python? Ich möchte eine Datei von der letzten bis zur ersten Zeile lesen.

Nimmy
quelle
7
Meinen Sie "in umgekehrter Reihenfolge lesen" oder "Zeilen in umgekehrter Reihenfolge verarbeiten"? Es besteht ein Unterschied. Beim ersten Schritt passt die Datei möglicherweise nicht alle gleichzeitig in den Speicher. Sie möchten die Zeilen also in umgekehrter Reihenfolge verarbeiten, können jedoch nicht die gesamte Datei einlesen und umkehren. Mit dem zweiten können Sie einfach die gesamte Datei einlesen und die Liste der Zeilen umkehren, bevor Sie sie verarbeiten. Also was ist es?
Lasse V. Karlsen
1
Ich empfehle dies - keine Speicherprobleme und schnell: stackoverflow.com/a/260433/1212562
Brian B

Antworten:

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

Und in Python 3:

for line in reversed(list(open("filename"))):
    print(line.rstrip())
Matt Joiner
quelle
192
Leider funktioniert dies nicht, wenn Sie nicht die gesamte Datei in den Speicher passen können.
vy32
3
Auch wenn der veröffentlichte Code die Frage beantwortet, sollten wir darauf achten, die von uns geöffneten Dateien zu schließen. Die withAussage ist normalerweise ziemlich schmerzlos.
William
1
@MichaelDavidWatson: Nicht ohne zuerst den ursprünglichen Iterator in den Speicher einzulesen und dann umgekehrt einen neuen Iterator über den ersten zu präsentieren.
Matt Joiner
3
@MichaelDavidWatson: Sie können eine Datei in umgekehrter Reihenfolge lesen, ohne sie in den Speicher einzulesen. Sie ist jedoch nicht trivial und erfordert viele Puffershenanigans, um erhebliche Verschwendung von Systemaufrufen zu vermeiden. Es funktioniert auch sehr schlecht (wenn auch besser als das Einlesen des gesamten Speichers in den Speicher, wenn die Datei den verfügbaren Speicher überschreitet).
Matt Joiner
1
@William Entschuldigung, wie verwende ich die obige Lösung mit "with open", während ich über die Datei iteriere und sie dann sauber schließe?
BringBackCommodore64
146

Eine korrekte, effiziente Antwort, die als Generator geschrieben wurde.

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
quelle
4
Das wird nicht für arbeiten Text - Dateien in Python> = 3.2, da aus irgendeinem Grund zum Ende der Datei relativ sucht nicht mehr unterstützt werden . Kann behoben werden, indem die Größe der zurückgegebenen Datei gespeichert fh.seek(0, os.SEEK_END)und auch geändert fh.seek(-offset, os.SEEK_END)wird fh.seek(file_size - offset).
Levesque
9
Nach den vorgenommenen Änderungen funktioniert dies perfekt in Python 3.5. Beste Antwort auf die Frage.
notbad.jpeg
3
Setzen Sie diese Änderung für Python 2 zurück, wo fh.seek()zurückkehrtNone
Marengaz
1
Beachten Sie, dass dies bei Textdateien möglicherweise nicht wie erwartet funktioniert. Das korrekte Abrufen von Blöcken in umgekehrter Reihenfolge funktioniert nur für Binärdateien. Das Problem ist, dass für Textdateien mit Multi-Byte-Codierung (wie utf8) seek()und read()auf verschiedene Größen verweisen. Dies ist wahrscheinlich auch der Grund, warum das erste Argument ungleich Null von seek()relativ zu os.SEEK_ENDnicht unterstützt wird.
Norok2
3
einfach: 'aöaö'.encode()ist b'a\xc3\xb6a\xc3\xb6'. Wenn Sie dies auf der Festplatte speichern und dann im Textmodus lesen, seek(2)wird es sich dabei um zwei Bytes verschieben, was seek(2); read(1)zu einem Fehler UnicodeDecodeError: 'utf-8' codec can't decode byte 0xb6 in position 0: invalid start byteführt. Wenn Sie dies jedoch tun seek(0); read(2); read(1), erhalten Sie das, was 'a'Sie erwartet haben, dh: seek()codiert nie -bewusst read()ist, wenn Sie die Datei im Textmodus öffnen. Wenn ja 'aöaö' * 1000000, werden Ihre Blöcke nicht richtig ausgerichtet.
Norok2
23

Wie wäre es mit so etwas:

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

Da die Datei zeichenweise in umgekehrter Reihenfolge gelesen wird, funktioniert sie auch bei sehr großen Dateien, solange einzelne Zeilen in den Speicher passen.

Berislav Lopac
quelle
20

Sie können auch das Python-Modul verwenden file_read_backwards.

Nach der Installation über pip install file_read_backwards(v1.2.1) können Sie die gesamte Datei speichereffizient rückwärts (zeilenweise) lesen über:

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

Es unterstützt die Codierungen "utf-8", "latin-1" und "ascii".

Unterstützung ist auch für Python3 verfügbar. Weitere Dokumentationen finden Sie unter http://file-read-backwards.readthedocs.io/en/latest/readme.html

user7321751
quelle
Danke für diese Lösung. Ich mag die obige Lösung von @srohde (und habe sie auch positiv bewertet), da sie mir geholfen hat zu verstehen, wie es gemacht wird, aber als Entwickler bevorzuge ich die Verwendung eines vorhandenen Moduls, wenn ich kann, daher bin ich froh, über dieses zu wissen.
Joanis
1
Dies funktioniert mit Multibyte-Codierung wie UTF-8. Die Such- / Leselösung lautet nicht: seek () zählt in Bytes, read () in Zeichen.
Jeremitu
9
for line in reversed(open("file").readlines()):
    print line.rstrip()

Wenn Sie unter Linux arbeiten, können Sie den tacBefehl verwenden.

$ tac file

2 Rezepte finden Sie in ActiveState hier und hier

Ghostdog74
quelle
1
Ich frage mich, ob reverse () die gesamte Sequenz vor der Iteration verbraucht. Dokumente sagen, dass eine __reversed__()Methode benötigt wird, aber Python2.5 beschwert sich nicht über eine benutzerdefinierte Klasse ohne diese.
Muhuk
@muhuk, es muss es wahrscheinlich irgendwie zwischenspeichern, ich vermute, es generiert eine neue Liste in umgekehrter Reihenfolge und gibt dann einen Iterator zurück
Matt Joiner
1
@ Matt: das wäre lächerlich. Es geht einfach von hinten nach vorne - len (L) -1 ist die Rückseite, 0 ist die Vorderseite. Sie können sich den Rest vorstellen.
Devin Jeanpierre
@muhuk: Sequenzen werden nicht sinnvoll konsumiert (Sie können die gesamte Sequenz durchlaufen, aber es spielt keine große Rolle). Eine __reversed__Methode ist auch nicht notwendig, und so etwas gab es früher nicht. Wenn ein Objekt bereitstellt __len__und __getitem__es einwandfrei funktioniert (abzüglich einiger Ausnahmefälle, wie z. B. Diktat).
Devin Jeanpierre
@ Devin Jeanpierre: Nur wenn readlines () ein Objekt zurückgibt, das bereitstellt __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
quelle
Dies scheint die falsche Ausgabe für Dateien zu erzeugen, die größer als der Puffer sind. Soweit ich weiß, werden Zeilen, die sich über die Puffergröße erstrecken, die Sie eingelesen haben, nicht korrekt behandelt. Ich habe eine andere ähnliche Antwort gepostet (auf eine andere ähnliche Frage).
Darius Bacon
@Darius: Ah ja, ich habe anscheinend ein bisschen gefehlt. Sollte jetzt behoben sein.
Ignacio Vazquez-Abrams
Sieht richtig aus. Ich würde immer noch meinen eigenen Code bevorzugen, da dies O (N ^ 2) für eine große Datei funktioniert, die nur eine lange Zeile enthält. (In den ähnlichen Antworten auf die andere Frage, die ich getestet habe, verursachte dies eine ernsthafte echte Verlangsamung solcher Dateien.)
Darius Bacon
3
Nun, in der Frage wurde die Leistung nicht erwähnt, daher kann ich die Leistungskatastrophe, die reguläre Ausdrücke sind, nicht auswählen: P
Matt Joiner
Eine weitere Erklärung wäre als Aufführung nützlich, und wenn dies tatsächlich versuchen kann, sagen wir die letzte Zeile und lesen Sie nur dieses Stück.
user1767754
7

Die akzeptierte Antwort funktioniert nicht in Fällen mit großen Dateien, die nicht in den Speicher passen (was nicht selten der Fall ist).

Wie von anderen bemerkt, sieht die Antwort von @srohde gut aus, hat aber die nächsten Probleme:

  • Das Öffnen einer Datei sieht überflüssig aus, wenn wir das Dateiobjekt übergeben und es dem Benutzer überlassen können, zu entscheiden, in welcher Codierung es gelesen werden soll.
  • Selbst wenn wir das Akzeptieren von Dateiobjekten umgestalten, funktioniert dies nicht für alle Codierungen: Wir können Dateien mit utf-8Codierung und Nicht-ASCII-Inhalten wie auswählen

    й

    Pass buf_sizegleich 1und wird haben

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

    Natürlich kann der Text größer sein, aber er buf_sizekann aufgenommen werden, so dass es zu einem verschleierten Fehler wie oben kommt.

  • Wir können kein benutzerdefiniertes Zeilentrennzeichen angeben.
  • Wir können uns nicht dafür entscheiden, das Zeilentrennzeichen beizubehalten.

In Anbetracht all dieser Bedenken habe ich separate Funktionen geschrieben:

  • eine, die mit Byte-Streams arbeitet,
  • zweite, die mit Textströmen arbeitet und den zugrunde liegenden Bytestrom an die erste delegiert und die resultierenden Zeilen dekodiert.

Zunächst definieren wir die nächsten Dienstprogrammfunktionen:

ceil_divisionfür die Teilung mit Decke (im Gegensatz zur Standardteilung //mit Boden finden Sie weitere Informationen in diesem Thread )

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

split zum Teilen des Strings durch ein gegebenes Trennzeichen vom rechten Ende mit der Fähigkeit, es zu behalten:

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 Batch vom rechten Ende des Binärstroms lesen

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)

Danach können wir die Funktion zum Lesen des Bytestroms in umgekehrter Reihenfolge wie definieren

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

und schließlich kann eine Funktion zum Umkehren einer Textdatei wie folgt definiert werden:

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

Tests

Vorbereitungen

Ich habe 4 Dateien mit dem fsutilBefehl generiert :

  1. empty.txt ohne Inhalt, Größe 0 MB
  2. tiny.txt mit einer Größe von 1 MB
  3. small.txt mit einer Größe von 10 MB
  4. large.txt mit einer Größe von 50 MB

Außerdem habe ich die @ srohde-Lösung überarbeitet, um mit dem Dateiobjekt anstelle des Dateipfads zu arbeiten.

Testskript

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

Hinweis : Ich habe collections.dequeKlasse verwendet, um den Generator abzulassen.

Ausgänge

Für PyPy 3.5 unter 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

Für CPython 3.5 unter 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

Wie wir sehen können, funktioniert es wie die ursprüngliche Lösung, ist jedoch allgemeiner und frei von den oben aufgeführten Nachteilen.


Werbung

Ich habe dies zu 0.3.0einer lzPaketversion hinzugefügt (erfordert Python 3.5 +), die viele gut getestete funktionale / iterierende Dienstprogramme enthält.

Kann wie verwendet werden

 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)

Es unterstützt alle Standardcodierungen (möglicherweise außer, utf-7da es für mich schwierig ist, eine Strategie zum Generieren von damit codierbaren Zeichenfolgen zu definieren ).

Azat Ibrakov
quelle
2

Hier finden Sie meine Implementierung. Sie können die RAM-Nutzung durch Ändern der Variablen "buffer" einschränken. Es gibt einen Fehler, dass das Programm am Anfang eine leere Zeile druckt.

Außerdem kann die RAM-Nutzung erhöht werden, wenn für mehr als Pufferbytes keine neuen Zeilen vorhanden sind. Die Variable "leak" wird erhöht, bis eine neue Zeile ("\ n") angezeigt wird.

Dies funktioniert auch für 16-GB-Dateien, die größer sind als mein Gesamtspeicher.

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
quelle
2

Danke für die Antwort @srohde. Es gibt einen kleinen Fehler bei der Überprüfung auf Zeilenumbrüche mit dem Operator 'is', und ich konnte die Antwort mit 1 Ruf nicht kommentieren. Außerdem möchte ich Dateien verwalten, die außerhalb geöffnet sind, da ich so meine Streifzüge für Luigi-Aufgaben einbetten kann.

Was ich ändern musste, hat die Form:

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

Ich würde gerne wechseln zu:

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

Hier ist eine modifizierte Antwort, die ein Dateihandle wünscht und Zeilenumbrüche enthält:

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
quelle
1

Eine einfache Funktion zum Erstellen einer zweiten Datei in umgekehrter Reihenfolge (nur Linux):

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

wie benutzt man

tac('ordered.csv', 'reversed.csv')
f = open('reversed.csv')
Alexandre Andrade
quelle
Ich denke, das Ziel war, wie man es in Python macht. Außerdem funktioniert dies nur auf * Nix-Systemen, obwohl dies eine hervorragende Lösung ist. Im Wesentlichen wird Python nur als Eingabeaufforderung zum Ausführen von Shell-Dienstprogrammen verwendet.
Alexander Huszagh
1
Dieser Code weist derzeit schwerwiegende Sicherheitslücken auf. Was ist, wenn Sie versuchen, eine Datei umzukehren, die mit mv mycontent.txt $'hello $(rm -rf $HOME) world.txt'einem Ausgabedateinamen erstellt wurde oder einen ähnlichen Namen verwendet, der von einem nicht vertrauenswürdigen Benutzer angegeben wurde? Wenn Sie mit beliebigen Dateinamen sicher umgehen möchten, ist mehr Vorsicht geboten. subprocess.Popen(['tac', file1], stdout=open(file2, 'w'))wäre zum Beispiel sicher.
Charles Duffy
Der vorhandene Code verarbeitet auch Dateien mit Leerzeichen, Platzhaltern usw. nicht korrekt.
Charles Duffy
1

mit open ("Dateiname") als f:

    print(f.read()[::-1])
JackoM
quelle
Liest dies die gesamte Datei ein? Ist dies bei großen Dateien sicher? Dies scheint eine sehr einfache und realistische Methode zu sein, ist sich aber bei den oben genannten Fragen nicht sicher. Ich möchte die Datei auf diese Weise durchsuchen (mit re).
ikwyl6
@ ikwyl6 Dies sollte äquivalent zu sein list(reversed(f.read())).
AMC
0
def reverse_lines(filename):
    y=open(filename).readlines()
    return y[::-1]
Gareema
quelle
Ist dies nicht im Wesentlichen die gleiche Lösung wie die akzeptierte Antwort ?
AMC
0

Verwenden Sie immer, withwenn Sie mit Dateien arbeiten, da alles für Sie erledigt wird:

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

Oder in Python 3:

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

Sie müssten zuerst Ihre Datei im Leseformat öffnen, in einer Variablen speichern und dann die zweite Datei im Schreibformat öffnen, in der Sie die Variable mit dem Slice [:: - 1] schreiben oder anhängen und die Datei vollständig umkehren würden. Sie können auch readlines () verwenden, um daraus eine Liste von Zeilen zu erstellen, die Sie bearbeiten können

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
quelle
0

Die meisten Antworten müssen die gesamte Datei lesen, bevor Sie etwas unternehmen können. Dieses Beispiel liest immer größere Proben vom Ende .

Ich habe Murat Yükselens Antwort nur gesehen, als ich diese Antwort geschrieben habe. Es ist fast dasselbe, was ich für eine gute Sache halte. Das folgende Beispiel befasst sich auch mit \ r und erhöht die Puffergröße bei jedem Schritt. Ich habe auch einige Unit-Tests , um diesen Code zu sichern.

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
quelle
0

Lesen Sie die Datei Zeile für Zeile und fügen Sie sie dann in umgekehrter Reihenfolge zu einer Liste hinzu.

Hier ist ein Beispiel für Code:

reverse = []
with open("file.txt", "r") as file:
    for line in file:
        line = line.strip()
         reverse[0:0] = line
willywonka
quelle
Dies scheint nur eine minderwertige Version der Lösung in der akzeptierten Antwort zu sein .
AMC
0
import sys
f = open(sys.argv[1] , 'r')
for line in f.readlines()[::-1]:
    print line
Powerup Kalifornien
quelle
Ist dies nicht im Wesentlichen die gleiche Lösung wie die akzeptierte Antwort ?
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

benutzen:

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

Ich musste dies vor einiger Zeit tun und habe den folgenden Code verwendet. Es leitet zur Schale. Ich fürchte, ich habe nicht mehr das komplette Skript. Wenn Sie unter einem unixischen Betriebssystem arbeiten, können Sie "tac" verwenden. Wenn der Befehl tac unter Mac OSX jedoch nicht funktioniert, verwenden Sie tail -r. Das folgende Code-Snippet testet, für welche Plattform Sie sich befinden, und passt den Befehl entsprechend an

# 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
quelle
Das Poster sucht nach einer Python-Antwort.
Mikemaccana
Nun, es ist eine Python-Antwort, obwohl sie unvollständig zu sein scheint.
DrDee
2
Es ist nicht, nicht plattformübergreifend, mit Systembefehlen = nicht pythonisch
Phyo Arkar Lwin
Das Poster sucht nach einer Antwort "mit Python", in die das Code-Snippet tatsächlich geschrieben ist. Aber ich stimme zu, dass dies im Vergleich zu vielen anderen veröffentlichten keine sehr gute Lösung ist.
Jeorgen
1
Das Snippet ist nicht vollständig genug, um die Richtigkeit zu überprüfen (andere Teile des Aufrufs werden nicht angezeigt), aber das Speichern von Shell-Befehlen in Zeichenfolgen ist an und für sich sehr verdächtig - es ist einfach, Shell-Injektionsfehler zu haben, wenn nicht viel unternommen wird Pflege.
Charles Duffy