Lesen Sie eine Datei in umgekehrter Reihenfolge mit Python
Wie liest man eine Datei in umgekehrter Reihenfolge mit Python? Ich möchte eine Datei von der letzten bis zur ersten Zeile lesen.
for line in reversed(open("filename").readlines()):
print line.rstrip()
Und in Python 3:
for line in reversed(list(open("filename"))):
print(line.rstrip())
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
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 __== '__main__':
for qline in readlines_reverse(raw_input()):
print qline
Da die Datei in umgekehrter Reihenfolge zeichenweise gelesen wird, funktioniert sie auch bei sehr großen Dateien, solange einzelne Zeilen in den Speicher passen.
Sie können auch das Python-Modul file_read_backwards verwenden.
Nach der Installation können Sie über pip install file_read_backwards (v1.2.1) die gesamte Datei speichereffizient (zeilenweise) rückwärts lesen.
#!/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 Kodierung "utf-8", "latin-1" und "ascii".
Unterstützung ist auch für Python3 verfügbar. Weitere Dokumentation finden Sie unter http://file-read-backwards.readthedocs.io/de/latest/readme.html
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)
Hier finden Sie meine Implementierung, Sie können die RAM-Nutzung einschränken, indem Sie die Variable "buffer" ändern. Es gibt einen Fehler, dass das Programm am Anfang eine leere Zeile ausgibt.
Die RAM-Nutzung kann auch erhöht werden, wenn für mehr als Pufferbytes keine neuen Zeilen vorhanden sind. Die Variable "leak" nimmt zu, bis eine neue Zeile ("\ n") angezeigt wird.
Dies funktioniert auch für 16 GB-Dateien, was größer ist 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
Danke für die Antwort @srohde. Es gibt einen kleinen Fehler auf Newline-Zeichen mit 'is' Operator, und ich konnte die Antwort nicht mit 1 Ruf kommentieren. Außerdem möchte ich das Öffnen von Dateien außerhalb verwalten, da ich damit meine Wackelköpfe 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 neue Zeilen 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
eine einfache Funktion zum Erstellen einer zweiten Datei (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')
Wenn Sie sich über die Dateigröße/Speicherauslastung Gedanken machen, ist die Speicherzuordnung der Datei und das Rückwärtsscannen nach Zeilenumbrüchen eine Lösung:
mit open ("filename") als f:
print(f.read()[::-1])
Die akzeptierte Antwort funktioniert nicht für Fälle mit großen Dateien, die nicht in den Arbeitsspeicher passen (was nicht selten der Fall ist).
Wie von anderen bemerkt, sieht @srohde answer gut aus, aber es gibt folgende Probleme:
- die Datei sieht überflüssig aus, wenn wir das Dateiobjekt übergeben können und es dem Benutzer überlassen, zu entscheiden, in welcher Kodierung es gelesen werden soll.
selbst wenn wir das Akzeptieren von Dateiobjekten ändern, funktioniert es nicht für alle Kodierungen: Wir können Dateien mit
utf-8-Kodierung und Nicht-ASCII-Inhalten auswählenйpass
buf_sizegleich1und mussUnicodeDecodeError: 'utf8' codec can't decode byte 0xb9 in position 0: invalid start bytenatürlich kann der Text größer sein, aber
buf_sizekann aufgenommen werden, so dass es zu einem verschleierten Fehler wie oben kommt.- wir können kein benutzerdefiniertes Trennzeichen angeben.
- wir können uns nicht für ein Trennzeichen entscheiden.
In Anbetracht all dieser Bedenken habe ich separate Funktionen geschrieben:
- eine, die mit Byte-Streams arbeitet,
- die zweite, die mit Text-Streams arbeitet und ihren zugrunde liegenden Byte-Stream an den ersten delegiert und die resultierenden Zeilen dekodiert.
Zunächst definieren wir die nächsten Hilfsfunktionen:
ceil_division für die Unterteilung mit Decke (im Gegensatz zur Standard //-Unterteilung 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 für die Aufteilung der Zeichenkette durch ein angegebenes Trennzeichen mit der Fähigkeit, es beizubehalten:
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, um den Stapel vom rechten Ende des binären Streams zu 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 eine Funktion zum Lesen des Bytestroms in umgekehrter Reihenfolge 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
batch = read_batch_from_end(byte_stream,
size=batch_size,
end_position=remaining_bytes_count)
segment, *lines = lines_splitter(batch)
# for Python 3.2 or earlier versions next statement can be replaced with
# for line in reversed(lines): yield line
yield from reversed(lines)
for remaining_bytes_count in remaining_bytes_indicator:
batch = read_batch_from_end(byte_stream,
size=batch_size,
end_position=remaining_bytes_count)
lines = lines_splitter(batch)
if batch.endswith(lines_separator):
yield segment
else:
lines[-1] += segment
segment, *lines = lines
# for Python 3.2 or earlier versions next statement can be replaced with
# for line in reversed(lines): yield line
yield from reversed(lines)
yield segment
und schließlich kann eine Funktion zum Umkehren einer Textdatei 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 fsutil Befehl erzeugt:
- empty.txt ohne Inhalt, Größe 0 MB
- tiny.txt mit einer Größe von 1 MB
- small.txt mit einer Größe von 10 MB
- large.txt mit einer Größe von 50 MB
ich habe auch eine @srohde-Lösung überarbeitet, um mit dem Dateiobjekt anstelle des Dateipfads zu arbeiten.
Skript testen
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)))
Note: Ich habe collections.deque-Klasse verwendet, um den Generator zu erschöpfen.
Ausgaben
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 aber allgemeiner und frei von den oben aufgeführten Nachteilen.
Werbung
Ich habe dies zur 0.3.0-Version von lz package (erfordert Python 3.5 +) hinzugefügt, die viele bewährte Funktions-/Iterations-Dienstprogramme enthält.
Kann gerne benutzt 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 Standardkodierungen (vielleicht außer utf-7, da es mir schwer fällt, eine Strategie für die Erzeugung von damit kodierbaren Strings zu definieren).
def reverse_lines(filename):
y=open(filename).readlines()
return y[::-1]
Lesen Sie die Datei Zeile für Zeile und fügen Sie sie in umgekehrter Reihenfolge in eine Liste ein.
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
Die meisten Antworten müssen die gesamte Datei lesen, bevor sie etwas tun. Dieses Beispiel liest immer größere Samples vom Ende.
Ich habe nur Murat Yükselens Antwort gesehen, als ich diese Antwort schrieb. Es ist fast das Gleiche, was ich für eine gute Sache halte. Das Beispiel unten behandelt auch\r und erhöht bei jedem Schritt die Puffergröße. 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
Verwenden Sie immer with, wenn 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)
sie müssten Ihre Datei zuerst im Leseformat öffnen, in einer Variablen speichern und dann die zweite Datei im Schreibformat öffnen, in dem Sie die Variable schreiben oder mit einem [:: - 1] -Segment anhängen und die Datei vollständig umkehren würden. Sie können readlines () auch 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])
import sys
f = open(sys.argv[1] , 'r')
for line in f.readlines()[::-1]:
print line