Comment lire un fichier dans l'ordre inverse?


128

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.


7
Voulez-vous dire "lire dans l'ordre inverse" ou "traiter les lignes dans l'ordre inverse"? Il y a une différence. Avec le premier, potentiellement le fichier ne rentrerait pas dans la mémoire en même temps, vous voulez donc traiter les lignes dans l'ordre inverse, mais vous ne pouvez pas lire le fichier entier et l'inverser. Avec le second, vous pouvez simplement lire l'intégralité du fichier et inverser la liste des lignes avant de les traiter. Alors qu'est-ce que c'est?
Lasse V.Karlsen


1
Je recommande ceci - pas de problèmes de mémoire et rapide: stackoverflow.com/a/260433/1212562
Brian B

Réponses:


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

Et en Python 3:

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

192
Hélas, cela ne fonctionne pas si vous ne pouvez pas mettre le fichier entier en mémoire.
vy32

3
De plus, bien que le code publié réponde à la question, nous devons faire attention à fermer les fichiers que nous ouvrons. La withdéclaration est généralement assez indolore.
William

1
@MichaelDavidWatson: Non sans lire d'abord l'itérateur d'origine en mémoire, puis en présentant un nouvel itérateur sur le premier à l'envers.
Matt Joiner

3
@MichaelDavidWatson: Vous pouvez lire un fichier à l'envers sans le lire en mémoire, mais ce n'est pas trivial et nécessite beaucoup de manigances de tampon pour éviter un gaspillage considérable d'appels système. Il fonctionnera également très mal (bien que mieux que de lire toute la mémoire en mémoire si le fichier dépasse la mémoire disponible).
Matt Joiner

1
@William Désolé, comment puis-je utiliser la solution ci-dessus en utilisant "with open" tout en itérant sur le fichier, puis nettoyer-le fermer?
BringBackCommodore64

146

Une réponse correcte et efficace écrite 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

4
Cela ne fonctionnera pas pour les fichiers texte en python> = 3.2, car pour une raison quelconque, les recherches relatives à la fin du fichier ne sont plus prises en charge. Peut être fixé en enregistrant la taille du fichier retourné par fh.seek(0, os.SEEK_END)et en changeant le fh.seek(-offset, os.SEEK_END)trop fh.seek(file_size - offset).
levesque

9
Une fois les modifications effectuées, cela fonctionne parfaitement en python 3.5. Meilleure réponse à la question.
notbad.jpeg

3
annuler ce changement pour python 2 où fh.seek()retourneNone
marengaz

1
Attention, cela peut ne pas fonctionner comme prévu pour les fichiers texte. Obtenir correctement les blocs dans l'ordre inverse ne fonctionne que pour les fichiers binaires. Le problème est que pour les fichiers texte avec un codage multi-octets (tel que utf8), seek()et se read()réfèrent à des tailles différentes. C'est probablement aussi la raison pour laquelle le premier argument non nul de seek()relatif à os.SEEK_ENDn'est pas pris en charge.
norok2

3
simple: 'aöaö'.encode()est b'a\xc3\xb6a\xc3\xb6'. Si vous enregistrez ceci sur le disque puis lisez en mode texte, lorsque vous le faites, seek(2)il se déplacera de deux octets, ce qui seek(2); read(1)entraînera une erreur UnicodeDecodeError: 'utf-8' codec can't decode byte 0xb6 in position 0: invalid start byte, mais si vous le faites seek(0); read(2); read(1), vous obtiendrez ce que 'a'vous attendiez, c'est-à-dire: seek()n'est jamais encodé -aware, read()c'est si vous ouvrez le fichier en mode texte. Maintenant, si c'est le cas 'aöaö' * 1000000, vos blocs ne seront pas alignés correctement.
norok2

23

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 __name__ == '__main__':
    for qline in readlines_reverse(raw_input()):
        print qline

Puisque le fichier est lu caractère par caractère dans l'ordre inverse, il fonctionnera même sur des fichiers très volumineux, tant que des lignes individuelles tiennent en mémoire.


20

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 à l'envers (ligne par ligne) de manière efficace en 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 prend en charge les encodages «utf-8», «latin-1» et «ascii».

Le support est également disponible pour python3. Une documentation supplémentaire peut être trouvée sur http://file-read-backwards.readthedocs.io/en/latest/readme.html


Merci pour cette solution. J'aime (et j'ai également voté pour) la solution ci-dessus par @srohde car elle m'a aidé à comprendre comment cela fonctionne, mais en tant que développeur, je préfère utiliser un module existant lorsque je le peux, donc je suis heureux de savoir celui-ci.
joanis

1
Cela fonctionne avec un encodage multi-octets comme UTF-8. La solution de recherche / lecture ne fonctionne pas: seek () compte en octets, read () en caractères.
Jeremitu

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

Si vous êtes sous Linux, vous pouvez utiliser la taccommande.

$ tac file

2 recettes que vous pouvez trouver dans ActiveState ici et ici


1
Je me demande si reverse () consomme toute la séquence avant l'itération. Les documents disent qu'une __reversed__()méthode est nécessaire, mais python2.5 ne se plaint pas d'une classe personnalisée sans elle.
muhuk

@muhuk, il doit probablement le mettre en cache d'une manière ou d'une autre, je soupçonne qu'il génère une nouvelle liste dans l'ordre inverse, puis renvoie un itérateur à cela
Matt Joiner

1
@Matt: ce serait ridicule. Il va simplement de l'arrière vers l'avant - len (L) -1 est l'arrière, 0 est l'avant. Vous pouvez imaginer le reste.
Devin Jeanpierre

@muhuk: Les séquences ne sont pas consommées de manière significative (vous pouvez itérer sur toute la séquence, mais cela n'a pas beaucoup d'importance). Une __reversed__méthode n'est pas non plus nécessaire, et il n'y en avait pas avant. Si un objet fournit __len__et __getitem__qu'il fonctionnera très bien (moins certains cas exceptionnels, tels que dict).
Devin Jeanpierre

@Devin Jeanpierre: Seulement si readlines () retourne un objet qui fournit __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)

Cela semble produire une sortie incorrecte pour les fichiers plus volumineux que la mémoire tampon. Il ne gérera pas correctement les lignes qui couvrent les morceaux de la taille de la mémoire tampon que vous lisez, si je comprends bien. J'ai posté une autre réponse similaire (à une autre question similaire).
Darius Bacon

@Darius: Ah oui, il me semble avoir raté un peu. Devrait être corrigé maintenant.
Ignacio Vazquez-Abrams

Ça a l'air bien. Je préférerais toujours mon propre code parce que cela fonctionne O (N ^ 2) sur un gros fichier qui est tout une longue ligne. (Dans les réponses similaires à l'autre question que j'ai testée, cela a provoqué un véritable ralentissement sérieux sur ces fichiers.)
Darius Bacon

3
Eh bien, la question ne mentionnait pas la performance, donc je ne peux pas pinailler le désastre de performance qui est les expressions régulières: P
Matt Joiner

Quelques explications supplémentaires seraient utiles comme performance et si cela peut réellement chercher à dire la dernière ligne et ne lire que cette pièce.
user1767754

7

La réponse acceptée ne fonctionnera pas pour les cas avec des fichiers volumineux qui ne rentrent pas dans la mémoire (ce qui n'est pas un cas rare).

Comme d'autres l'ont noté, la réponse @srohde semble bonne, mais elle a des problèmes suivants:

  • l'ouverture du fichier semble redondante, lorsque nous pouvons passer l'objet fichier et laisser l'utilisateur décider dans quel encodage il doit être lu,
  • même si nous refactorisons pour accepter l'objet fichier, cela ne fonctionnera pas pour tous les encodages: nous pouvons choisir un fichier avec un utf-8encodage et un contenu non-ascii comme

    й

    passer buf_sizeégal à 1et aura

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

    bien sûr, le texte peut être plus grand mais buf_sizepeut être récupéré, ce qui entraînera une erreur masquée comme ci-dessus,

  • nous ne pouvons pas spécifier de séparateur de ligne personnalisé,
  • nous ne pouvons pas choisir de conserver le séparateur de ligne.

Donc, compte tenu de toutes ces préoccupations, j'ai écrit des fonctions séparées:

  • celui qui fonctionne avec les 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 prochaines fonctions utilitaires:

ceil_divisionpour faire une division avec plafond (contrairement à la //division standard avec sol, 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 diviser la chaîne par un séparateur donné de l'extrémité droite avec la 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 à partir de 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 la fonction de lecture du 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

    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

et enfin une fonction pour inverser le 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 en utilisant la fsutilcommande :

  1. empty.txt sans contenu, taille 0MB
  2. tiny.txt d'une taille de 1 Mo
  3. small.txt d'une taille de 10 Mo
  4. large.txt d'une taille de 50 Mo

J'ai également remanié la solution @srohde pour qu'elle fonctionne avec l'objet fichier au lieu du 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)))

Remarque : j'ai utilisé la collections.dequeclasse pour évacuer le générateur.

Les sorties

Pour PyPy 3.5 sous 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

Donc, comme nous pouvons le voir, il fonctionne comme une solution originale, mais est plus général et exempt de ses inconvénients énumérés ci-dessus.


Publicité

J'ai ajouté cela à la 0.3.0version du lzpackage (nécessite Python 3.5 +) qui contient 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 prend en charge tous les encodages standard (sauf peut-être utf-7car il m'est difficile de définir une stratégie pour générer des chaînes encodables avec lui).


2

Ici vous pouvez trouver mon implémentation, vous pouvez limiter l'utilisation de la RAM en changeant la variable "buffer", il y a un bogue que le programme imprime une ligne vide au début.

Et aussi l'utilisation de la RAM peut être augmentée s'il n'y a pas de nouvelles lignes pour plus que des octets de tampon, la variable "fuite" augmentera jusqu'à voir 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

2

Merci pour la réponse @srohde. Il y a un petit bug qui vérifie le caractère de nouvelle ligne avec l'opérateur «est», et je ne pourrais pas commenter la réponse avec 1 réputation. J'aimerais également gérer les fichiers ouverts à l'extérieur car cela me permet d'intégrer mes divagations pour les tâches luigi.

Ce que j'avais besoin de changer a la forme:

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

J'adorerais 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 handle 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

1

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

Je pense que l'objectif était de savoir comment le faire en Python. De plus, cela ne fonctionne que sur les systèmes * Nix, bien que ce soit une excellente solution pour cela. Il s'agit essentiellement d'utiliser Python comme invite pour exécuter les utilitaires shell.
Alexander Huszagh

1
Ce code présente des bogues de sécurité majeurs tels qu'ils sont actuellement écrits. Que faire si vous essayez d'inverser un fichier créé avec mv mycontent.txt $'hello $(rm -rf $HOME) world.txt', ou de manière similaire, en utilisant un nom de fichier de sortie donné par un utilisateur non approuvé? Si vous souhaitez gérer les noms de fichiers arbitraires en toute sécurité, il faut plus de prudence. subprocess.Popen(['tac', file1], stdout=open(file2, 'w'))serait sûr, par exemple.
Charles Duffy

Le code existant ne gère pas non plus correctement les fichiers avec des espaces, des caractères génériques, etc.
Charles Duffy


1

avec open ("filename") comme f:

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

Cela lit-il tout le fichier? Est-ce sûr sur les gros fichiers? Cela semble être un moyen très simple et réaliste de le faire, mais je ne suis pas sûr des questions ci-dessus. Je voudrais rechercher le fichier de cette façon (en utilisant re) ..
ikwyl6

@ ikwyl6 Cela devrait être équivalent à list(reversed(f.read())).
AMC


0

Utilisez toujours withlorsque vous travaillez avec des fichiers car il 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)

0

vous devrez d'abord ouvrir votre fichier au format lecture, l'enregistrer dans une variable, puis ouvrir le deuxième fichier au format écriture où vous écririez ou ajouteriez la variable en utilisant une tranche [:: - 1], 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])

0

La plupart des réponses doivent lire l'intégralité du fichier avant de faire quoi que ce soit. Cet échantillon lit des échantillons de plus en plus volumineux à la fin .

Je n'ai vu que la réponse de Murat Yükselen en écrivant 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 tampon à chaque étape. J'ai également 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

0

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

Cela semble être une version inférieure de la solution dans la réponse acceptée .
AMC le


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

utiliser:

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

-3

J'ai dû le faire il y a quelque temps et j'ai utilisé le code ci-dessous. Il conduit vers la coque. J'ai peur de ne plus avoir le script complet. Si vous êtes sur un système d'exploitation unixish, vous pouvez utiliser "tac", par exemple sur Mac OSX, la commande tac ne fonctionne pas, utilisez tail -r. L'extrait de code ci-dessous teste la plate-forme sur laquelle vous vous trouvez 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)

L'affiche cherche une réponse python.
mikemaccana

Eh bien, c'est une réponse Python bien qu'elle semble incomplète.
DrDee du

2
son pas, pas CrossPlatform, en utilisant les commandes du système = non pythonique
Phyo Arkar Lwin

L'affiche cherche une réponse "en utilisant python", dans laquelle est effectivement écrit l'extrait de code. Mais je suis d'accord que ce n'est pas une très bonne solution par rapport à la plupart des autres publiées.
jeorgen

1
L'extrait de code n'est pas assez complet pour évaluer l'exactitude (les autres parties de l'invocation ne sont pas affichées), mais le stockage des commandes shell dans des chaînes est en soi hautement suspect - il est facile d'avoir des bogues d'injection shell à moins d'en prendre beaucoup de soins.
Charles Duffy
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.