Lire un fichier dans l'ordre inverse à l'aide de python

Une bonne, réponse efficace à l'écrit comme un 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

Vous pouvez également utiliser le module python file_read_backwards.

Après l'installation, via pip install file_read_backwards (v1.2.1), vous pouvez lire l'intégralité du fichier vers l'arrière (en ligne-sage), dans une mémoire de manière efficace par le biais de:

#!/usr/bin/env python2.7

from file_read_backwards import FileReadBackwards

with FileReadBackwards("/path/to/file", encoding="utf-8") as frb:
    for l in frb:
         print l

Il prend en charge "utf-8","latin-1", et "ascii" encodages.

Est également disponible pour python3. La documentation complémentaire peut être trouvé à 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)

Merci pour la réponse @srohde. Il a un petit bug vérification de caractère de saut de ligne avec " est " de l'opérateur, et je ne pouvais pas commenter la réponse avec 1 réputation. Je tiens aussi à gérer un fichier ouvert à l'extérieur, car cela me permet d'intégrer mes divagations pour luigi tâches.

Ce que j'avais besoin de changer est de 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)

Ici est une modification de la réponse qui se veut un descripteur de fichier et de garde des retours à la ligne:

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

Accepté de répondre ne fonctionne pas pour les cas avec de gros fichiers qui ne tiennent pas en mémoire (ce qui n'est pas un cas rare).

Comme il a été noté par les autres, @srohde répondre semble bon, mais il a prochaines questions:

• ouverture de fichier semble redondant, quand on peut passer de l'objet fichier & laisser à l'utilisateur de décider dans quel encodage il faut le lire,

• même si nous refactoriser à accepter de fichier de l'objet, il ne fonctionnera pas pour tous les encodages: on peut choisir fichier avec utf-8 d'encodage et de non-ascii contenu comme

  й

  passer buf_size égal à 1 et aura

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

  bien sûr, le texte peut être plus grande, mais buf_size peut être ramassé, donc il va conduire à d'obfuscation d'erreur comme ci-dessus,

• nous ne pouvons préciser la coutume de séparateur de ligne,
• nous ne pouvons pas choisir de garder séparateur de ligne.

Si l'on considère l'ensemble de ces préoccupations que j'ai écrit des fonctions distinctes:

• qui fonctionne avec l'octet de ruisseaux, de
• second qui fonctionne avec du texte des ruisseaux et des délégués de la sous-jacentes de ses flux d'octets à la première et décode les lignes résultantes.

Tout d'abord nous allons définir ensuite les fonctions de l'utilitaire:

ceil_division pour la fabrication de division avec le plafond (en contraste avec la norme // division avec le plancher, plus d'informations peuvent être trouvées dans ce fil)

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

split pour le fractionnement de la chaîne par le séparateur d'extrémité droite avec la possibilité de le garder:

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 le lot de lecture à partir de l'extrémité droite de 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 la fonction de lecture de 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 = object_.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: int) -> bytes:
result = read_batch_from_end(object_,
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(object_,
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

et enfin une fonction d'inversion de fichier texte peut être défini 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))

---

Tests

Préparations

J'ai généré 4 fichiers à l'aide de fsutil commande:

1. empty.txt sans contenu, la taille 0MB
2. tiny.txt avec une taille de 1 MO
3. small.txt avec une taille de 10 MO
4. large.txt avec une taille de 50 MO

aussi j'ai refait @srohde solution pour travailler avec des fichiers objet au lieu de le chemin d'accès au fichier.

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é collections.deque classe d'échappement de la génératrice.

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

Ainsi, comme nous pouvons le voir se comporte comme solution originale, mais elle est plus générale et sans ses inconvénients énumérés ci-dessus.

---

Annonce

J'ai ajouté ceci à 0.3.0 version de lz le paquet (nécessite Python 3.5+) qui ont bien testé fonctionnel/itération utilitaires.

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 prend en charge tous les encodages standard (peut-être à l'exception de utf-7 car il est difficile pour moi de définir une stratégie pour générer des chaînes de encodable avec elle).

avec open("filename") comme f:

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

Toujours utiliser with lorsque vous travaillez avec des fichiers comme il s'occupe de 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)

La plupart des réponses ont besoin de lire le fichier en entier avant de faire quoi que ce soit. Cet exemple lit de plus en plus de grands échantillons à partir de la fin.

Je n'ai vu Murat Yükselen de réponse lors de l'écriture de cette réponse. C'est presque le même, qui, je suppose, est une bonne chose. L'exemple ci-dessous traite aussi avec \r et augmente sa taille de tampon à chaque étape. J'ai aussi quelques les tests unitaires pour 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

import sys
f = open(sys.argv[1] , 'r')
for line in f.readlines()[::-1]:
print line

J'ai dû le faire il y a quelques temps et utilisé le code ci-dessous. Il des tuyaux pour le shell. Je crains de ne pas avoir le script complet plus. Si vous êtes sur un unixish système d'exploitation, vous pouvez utiliser "tac", mais, par exemple, Mac OSX tac commande ne fonctionne pas, l'utilisation de la queue -r. Ci-dessous l'extrait de code de tests pour la plate-forme sur laquelle vous êtes, et ajuste la commande en conséquence

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