Lire un fichier dans l'ordre inverse en utilisant python
Comment lire un fichier dans l'ordre inverse en utilisant python? Je veux lire un fichier de la dernière ligne à la première ligne.
for line in reversed(open("filename").readlines()):
print line.rstrip()
Et en Python 3:
for line in reversed(list(open("filename"))):
print(line.rstrip())
Une réponse correcte et efficace écrite en générateur.
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
Que diriez-vous quelque chose comme ça:
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
Étant donné que le fichier est lu caractère par caractère dans l’ordre inverse, il fonctionnera même sur des fichiers très volumineux, à condition que des lignes individuelles tiennent dans la mémoire.
Vous pouvez également utiliser le module python file_read_backwards.
Après l'avoir installé, via pip install file_read_backwards (v1.2.1), vous pouvez lire l'intégralité du fichier (ligne par ligne) de manière efficace en termes de mémoire via:
#!/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
Il supporte les encodages "utf-8", "latin-1" et "ascii".
Un support est également disponible pour python3. Une documentation supplémentaire est disponible sur http://file-read-backwards.readthedocs.io/en/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)
Ici vous pouvez trouver mon application, vous pouvez limiter l’utilisation de la RAM en changeant la variable "tampon", il ya un bogue qui indique que le programme affiche une ligne vide au début.
De plus, l'utilisation de la mémoire RAM peut augmenter si aucune nouvelle ligne ne dépasse les octets de mémoire tampon. La variable "leak" augmentera jusqu'à l'affichage d'une nouvelle ligne ("\ n").
Cela fonctionne également pour les fichiers de 16 Go, ce qui est plus grand que ma mémoire 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
Merci pour la réponse @rohde. Il y a un petit bug qui vérifie le caractère de nouvelle ligne avec l'opérateur 'est', et je ne pouvais pas commenter la réponse avec 1 réputation. De plus, j'aimerais gérer les fichiers ouverts à l'extérieur, car cela me permet d'intégrer mes divagations aux tâches en luigi.
Ce que je devais changer a la forme:
with open(filename) as fp:
for line in fp:
#print line, # contains new line
print '>{}<'.format(line)
J'aimerais changer pour:
with open(filename) as fp:
for line in reversed_fp_iter(fp, 4):
#print line, # contains new line
print '>{}<'.format(line)
Voici une réponse modifiée qui veut un descripteur de fichier et conserve les nouvelles lignes:
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
une fonction simple pour créer un deuxième fichier inversé (linux uniquement):
import os
def tac(file1, file2):
print(os.system('tac %s > %s' % (file1,file2)))
comment utiliser
tac('ordered.csv', 'reversed.csv')
f = open('reversed.csv')
Si vous êtes préoccupé par la taille du fichier/l'utilisation de la mémoire, le mappage de la mémoire du fichier et la recherche arrière d'une nouvelle ligne constituent une solution:
avec open ("nom de fichier") comme f:
print(f.read()[::-1])
La réponse acceptée ne fonctionnera pas pour les cas avec des fichiers volumineux qui ne tiendront pas dans la mémoire (ce qui n'est pas un cas rare).
Comme cela a été noté par d’autres, @srohde répond a l’air beau, mais les problèmes suivants se posent:
- le fichier d'ouverture semble redondant, quand on peut passer un objet de fichier et laisser à l'utilisateur le soin de décider dans quel encodage il doit être lu,
même si nous refactionnons pour accepter un objet fichier, cela ne fonctionnera pas pour tous les encodages: nous pouvons choisir un fichier avec un encodage
utf-8et un contenu non ascii commeйpassez
buf_sizeégal à1et auraUnicodeDecodeError: 'utf8' codec can't decode byte 0xb9 in position 0: invalid start bytebien sûr, le texte peut être plus gros, mais
buf_sizepeut être récupéré, ce qui entraînera une erreur obscurcie comme ci-dessus,- nous ne pouvons pas spécifier de séparateur de ligne personnalisé,
- nous ne pouvons pas choisir de garder le séparateur de ligne.
Donc, compte tenu de toutes ces préoccupations, j’ai écrit des fonctions distinctes:
- celui qui fonctionne avec des flux d'octets,
- le second qui fonctionne avec les flux de texte et délègue son flux d'octets sous-jacent au premier et décode les lignes résultantes.
Tout d’abord, définissons les fonctions d’utilité suivantes:
ceil_division pour créer une division avec plafond (contrairement au // standard avec division au sol, vous trouverez plus d’informations dans ce fil de discussion )
def ceil_division(left_number, right_number):
"""
Divides given numbers with ceiling.
"""
return -(-left_number // right_number)
split pour séparer une chaîne donnée par un séparateur avec possibilité de la conserver:
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 pour lire le lot à l'extrémité droite du flux binaire
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)
Après cela, nous pouvons définir une fonction pour lire le flux d'octets dans l'ordre inverse, comme
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
et enfin une fonction pour inverser un fichier texte peut être définie comme:
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))
Des tests
Les préparatifs
J'ai généré 4 fichiers avec la commande fsutil :
- empty.txt sans contenu, taille 0Mo
- tiny.txt d'une taille de 1 Mo
- small.txt avec une taille de 10 Mo
- large.txt avec une taille de 50 Mo
j'ai également refactored la solution @srohde pour utiliser un objet fichier au lieu d'un chemin d'accès.
Script de test
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: J'ai utilisé la classe collections.deque pour épuiser le générateur.
Les sorties
Pour PyPy 3.5 sur 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
Pour CPython 3.5 sur 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
Comme on peut le constater, elle fonctionne comme la solution originale, mais est plus générale et ne présente pas les inconvénients énumérés ci-dessus.
Publicité
J'ai ajouté ceci à la version 0.3.0 du package lz (requiert Python 3.5 +) qui comportent de nombreux utilitaires fonctionnels/itératifs bien testés.
Peut être utilisé comme
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)
Il supporte tous les encodages standard (peut-être à l'exception de utf-7 car il m'est difficile de définir une stratégie pour générer des chaînes de caractères pouvant être encodées avec elle).
def reverse_lines(filename):
y=open(filename).readlines()
return y[::-1]
Lisez le fichier ligne par ligne, puis ajoutez-le sur une liste dans l'ordre inverse.
Voici un exemple de code:
reverse = []
with open("file.txt", "r") as file:
for line in file:
line = line.strip()
reverse[0:0] = line
La plupart des réponses nécessitent de lire tout le fichier avant de faire quoi que ce soit. Cet exemple lit des échantillons de plus en plus volumineux à partir de la fin.
Je n'ai vu que la réponse de Murat Yükselen lors de l'écriture de cette réponse. C'est presque la même chose, ce qui, je suppose, est une bonne chose. L'exemple ci-dessous traite également de\r et augmente sa taille de mémoire tampon à chaque étape. J'ai aussi quelques tests unitaires pour sauvegarder ce code.
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
Utilisez toujours with lorsque vous travaillez avec des fichiers, car cela gère tout pour vous:
with open('filename', 'r') as f:
for line in reversed(f.readlines()):
print line
Ou en Python 3:
with open('filename', 'r') as f:
for line in reversed(list(f.readlines())):
print(line)
vous devez d'abord ouvrir votre fichier au format lecture, l'enregistrer dans une variable, puis ouvrir le second fichier au format écriture dans lequel vous pouvez écrire ou ajouter la variable à l'aide de la tranche [:: - 1], en inversant complètement le fichier. Vous pouvez également utiliser readlines () pour en faire une liste de lignes que vous pouvez manipuler.
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