Jak czytać plik w odwrotnej kolejności?

128

Jak odczytać plik w odwrotnej kolejności za pomocą Pythona? Chcę przeczytać plik od ostatniego wiersza do pierwszego wiersza.

Nimmy
źródło
7
Czy masz na myśli „przeczytaj to w odwrotnej kolejności” czy „przetwarzaj wiersze w odwrotnej kolejności”? Jest różnica. W przypadku pierwszego potencjalnie plik nie zmieści się w pamięci w tym samym czasie, więc chcesz przetwarzać wiersze w odwrotnej kolejności, ale nie możesz odczytać całego pliku i odwrócić go. W drugim przypadku możesz po prostu wczytać cały plik i odwrócić listę wierszy przed ich przetworzeniem. Więc o co chodzi?
Lasse V. Karlsen
1
Polecam - bez problemów z pamięcią i szybko: stackoverflow.com/a/260433/1212562
Brian B

Odpowiedzi:

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

A w Pythonie 3:

for line in reversed(list(open("filename"))):
    print(line.rstrip())
Matt Joiner
źródło
192
Niestety, to nie działa, jeśli nie możesz zmieścić całego pliku w pamięci.
vy32
3
Ponadto, chociaż opublikowany kod odpowiada na pytanie, powinniśmy uważać, aby zamknąć pliki, które otwieramy. withStwierdzenie jest zwykle dość bezbolesny.
William
1
@MichaelDavidWatson: Nie bez wczytania oryginalnego iteratora do pamięci, a następnie zaprezentowania nowego iteratora na pierwszym w odwrotnej kolejności.
Matt Joiner
3
@MichaelDavidWatson: Możesz odczytać plik w odwrotnej kolejności bez wczytywania go do pamięci, ale jest to nietrywialne i wymaga wielu shenaniganów bufora, aby uniknąć znacznego marnotrawstwa wywołań systemowych. Będzie również działać bardzo źle (choć lepiej niż wczytywanie całej pamięci do pamięci, jeśli plik przekracza dostępną pamięć).
Matt Joiner
1
@William Przepraszam, jak mam użyć powyższego rozwiązania używając "with open" podczas iteracji po pliku, a następnie wyczyść-zamknij go?
BringBackCommodore64
146

Prawidłowa, skuteczna odpowiedź zapisana jako generator.

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
źródło
4
To nie zadziała w przypadku plików tekstowych w pythonie> = 3.2, ponieważ z jakiegoś powodu wyszukiwania względem końca pliku nie są już obsługiwane. Można to naprawić, zapisując rozmiar pliku zwracanego przez fh.seek(0, os.SEEK_END)i zmieniając fh.seek(-offset, os.SEEK_END)też fh.seek(file_size - offset).
levesque
9
Po dokonanych zmianach działa to doskonale w Pythonie 3.5. Najlepsza odpowiedź na pytanie.
notbad.jpeg
3
cofnij tę zmianę dla Pythona 2, gdzie fh.seek()zwracaNone
marengaz
1
Uważaj, że może to nie działać zgodnie z oczekiwaniami w przypadku plików tekstowych. Prawidłowe pobieranie bloków w odwrotnej kolejności działa tylko dla plików binarnych. Problem polega na tym, że w przypadku plików tekstowych z kodowaniem wielobajtowym (takim jak utf8) seek()i read()odnoszą się do różnych rozmiarów. Prawdopodobnie jest to również powód, dla którego niezerowy pierwszy argument funkcji seek()względnej os.SEEK_ENDnie jest obsługiwany.
norok2
3
proste: 'aöaö'.encode()jest b'a\xc3\xb6a\xc3\xb6'. Jeśli zapiszesz to na dysku, a następnie przeczytasz w trybie tekstowym, kiedy to zrobisz seek(2), przesunie się o dwa bajty, co seek(2); read(1)spowoduje błąd UnicodeDecodeError: 'utf-8' codec can't decode byte 0xb6 in position 0: invalid start byte, ale jeśli to zrobisz seek(0); read(2); read(1), otrzymasz 'a'oczekiwany, czyli: seek()nigdy nie koduje -aware, read()oznacza otwarcie pliku w trybie tekstowym. Teraz, jeśli tak 'aöaö' * 1000000, twoje bloki nie zostaną poprawnie wyrównane.
norok2
23

Co powiesz na coś takiego:

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

Ponieważ plik jest odczytywany znak po znaku w odwrotnej kolejności, będzie działać nawet na bardzo dużych plikach, o ile poszczególne wiersze mieszczą się w pamięci.

Berislav Lopac
źródło
20

Możesz także użyć modułu Python file_read_backwards.

Po zainstalowaniu, za pomocą pip install file_read_backwards(v1.2.1), można odczytać cały plik wstecz (wierszowo) w sposób efektywny dla pamięci poprzez:

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

Obsługuje kodowanie „utf-8”, „latin-1” i „ascii”.

Wsparcie jest również dostępne dla Python3. Dalszą dokumentację można znaleźć pod adresem http://file-read-backwards.readthedocs.io/en/latest/readme.html

user7321751
źródło
Dzięki za to rozwiązanie. Podoba mi się (i również zaopiekowałem się) powyższe rozwiązanie autorstwa @srohde, ponieważ pomogło mi zrozumieć, jak to się robi, ale jako programista wolę używać istniejącego modułu, kiedy mogę, więc jestem szczęśliwy, że o tym wiem.
joanis
1
Działa to z kodowaniem wielobajtowym, takim jak UTF-8. Rozwiązanie seek / read nie: seek () liczy w bajtach, read () w znakach.
Jeremitu
9
for line in reversed(open("file").readlines()):
    print line.rstrip()

Jeśli korzystasz z Linuksa, możesz użyć tacpolecenia.

$ tac file

2 przepisy można znaleźć w ActiveState tutaj i tutaj

ghostdog74
źródło
1
Zastanawiam się, czy reverse () pochłania całą sekwencję przed iteracją. Dokumenty mówią, że __reversed__()metoda jest potrzebna, ale python2.5 nie narzeka na niestandardową klasę bez niej.
muhuk,
@muhuk, prawdopodobnie musi to jakoś zapisać w pamięci podręcznej, podejrzewam, że generuje nową listę w odwrotnej kolejności, a następnie zwraca do niej iterator
Matt Joiner
1
@Matt: to byłoby śmieszne. Po prostu biegnie od tyłu do przodu - len (L) -1 to tył, 0 to przód. Możesz sobie wyobrazić resztę.
Devin Jeanpierre,
@muhuk: Sekwencje nie są w znaczący sposób konsumowane (możesz iterować po całej sekwencji, ale nie ma to większego znaczenia). __reversed__Metoda nie jest również konieczne, a nie używaliśmy być coś takiego. Jeśli obiekt zapewnia __len__i __getitem__będzie działał dobrze (bez niektórych wyjątkowych przypadków, takich jak dict).
Devin Jeanpierre,
@Devin Jeanpierre: Tylko jeśli readlines () zwraca obiekt, który dostarcza __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
źródło
Wydaje się, że daje to nieprawidłowe dane wyjściowe dla plików większych niż bufor. Jak rozumiem, nie obsługuje poprawnie wierszy obejmujących fragmenty rozmiaru bufora, które czytasz. Opublikowałem inną podobną odpowiedź (na inne podobne pytanie).
Darius Bacon
@Darius: Ach tak, wydaje mi się, że trochę przegapiłem. Powinien zostać naprawiony teraz.
Ignacio Vazquez-Abrams
Wygląda dobrze. Nadal wolałbym własny kod, ponieważ działa to O (N ^ 2) na dużym pliku, który składa się z jednej długiej linii. (W podobnych odpowiedziach na inne pytanie, które testowałem, spowodowało to poważne, prawdziwe spowolnienie na takich plikach.)
Darius Bacon,
3
Cóż, pytanie nie wspominało o wydajności, więc nie mogę podejrzeć katastrofy występu, czyli wyrażeń regularnych: P
Matt Joiner
Trochę więcej wyjaśnień przydałoby się jako wykonanie i jeśli to faktycznie może próbować powiedzieć ostatnią linijkę i przeczytać tylko ten kawałek.
user1767754
7

Zaakceptowana odpowiedź nie będzie działać w przypadkach z dużymi plikami, które nie zmieszczą się w pamięci (co nie jest rzadkim przypadkiem).

Jak zauważyli inni, odpowiedź @srohde wygląda dobrze, ale ma kolejne problemy:

  • otwieranie pliku wygląda na zbędne, kiedy możemy przekazać obiekt pliku i pozostawić użytkownikowi decyzję w jakim kodowaniu ma zostać odczytany,
  • nawet jeśli refaktoryzujemy, aby akceptować obiekt pliku, nie będzie to działać dla wszystkich kodowań: możemy wybrać plik z utf-8kodowaniem i treścią nie-ASCII, taką jak

    й

    przejść buf_sizerówne 1i będzie mieć

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

    oczywiście tekst może być większy, ale buf_size może zostać pobrany, więc spowoduje to zaciemniony błąd, jak powyżej,

  • nie możemy określić niestandardowego separatora linii,
  • nie możemy wybrać zachowania separatora linii.

Biorąc więc pod uwagę wszystkie te obawy, napisałem osobne funkcje:

  • taki, który działa ze strumieniami bajtów,
  • drugi, który pracuje ze strumieniami tekstu i deleguje swój podstawowy strumień bajtów do pierwszego i dekoduje wynikowe wiersze.

Przede wszystkim zdefiniujmy kolejne funkcje narzędziowe:

ceil_divisiondo wykonania podziału stropem (w odróżnieniu od standardowego //podziału stropem więcej informacji w tym temacie )

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

split do dzielenia napisu przez dany separator z prawego końca z możliwością jego zachowania:

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 aby odczytać wsad z prawego końca strumienia binarnego

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)

Następnie możemy zdefiniować funkcję odczytującą strumień bajtów w odwrotnej kolejności

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

wreszcie można zdefiniować funkcję odwracania pliku tekstowego, taką jak:

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

Testy

Przygotowania

Wygenerowałem 4 pliki fsutilpoleceniem :

  1. pusty.txt bez zawartości, rozmiar 0 MB
  2. tiny.txt o rozmiarze 1MB
  3. small.txt o rozmiarze 10 MB
  4. large.txt o rozmiarze 50 MB

również refaktoryzowałem rozwiązanie @srohde do pracy z obiektem pliku zamiast ścieżki do pliku.

Skrypt testowy

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

Uwaga : użyłemcollections.deque klasę do wyczerpania generatora.

Wyjścia

PyPy 3.5 w systemie 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

Dla CPython 3.5 w systemie 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

Jak więc widzimy, zachowuje się jak oryginalne rozwiązanie, ale jest bardziej ogólne i wolne od wymienionych powyżej wad.


Reklama

Dodałem to do 0.3.0wersji lzpakietu (wymaga Pythona 3.5 +), która ma wiele dobrze przetestowanych narzędzi funkcjonalnych / iteracyjnych.

Może być używany jak

 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)

Obsługuje wszystkie standardowe kodowania (może z wyjątkiem utf-7tego, że trudno mi zdefiniować strategię generowania ciągów kodowanych za jego pomocą).

Azat Ibrakov
źródło
2

Tutaj możesz znaleźć moją implementację, możesz ograniczyć użycie pamięci RAM poprzez zmianę zmiennej "buffer", jest błąd, że program wypisuje pustą linię na początku.

A także użycie pamięci RAM może wzrosnąć, jeśli nie ma nowych linii dla więcej niż bajtów bufora, zmienna „wyciek” będzie rosła, aż pojawi się nowa linia („\ n”).

Działa to również dla plików 16 GB, które są większe niż moja całkowita pamięć.

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
źródło
2

Dzięki za odpowiedź @srohde. Ma mały błąd sprawdzający znak nowej linii z operatorem „is” i nie mogłem skomentować odpowiedzi z 1 reputacją. Chciałbym również zarządzać plikami otwartymi na zewnątrz, ponieważ pozwala mi to osadzać moje wędrowanie dla zadań Luigi.

To, co musiałem zmienić, ma postać:

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

Chciałbym zmienić na:

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

Oto zmodyfikowana odpowiedź, która wymaga uchwytu pliku i zachowuje nowe linie:

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
źródło
1

prosta funkcja do stworzenia drugiego odwróconego pliku (tylko Linux):

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

jak używać

tac('ordered.csv', 'reversed.csv')
f = open('reversed.csv')
Alexandre Andrade
źródło
Myślę, że celem było to, jak to zrobić w Pythonie. Poza tym działa to tylko w systemach * Nix, chociaż jest to doskonałe rozwiązanie. Zasadniczo jest to po prostu użycie Pythona jako zachęty do uruchamiania narzędzi powłoki.
Alexander Huszagh
1
Ten kod ma poważne błędy bezpieczeństwa, tak jak obecnie napisano. Co zrobić, jeśli próbujesz cofnąć plik utworzony za pomocą mv mycontent.txt $'hello $(rm -rf $HOME) world.txt'lub w podobny sposób używając nazwy pliku wyjściowego podanej przez niezaufanego użytkownika? Jeśli chcesz bezpiecznie obsługiwać dowolne nazwy plików, musisz zachować większą ostrożność. subprocess.Popen(['tac', file1], stdout=open(file2, 'w'))byłoby na przykład bezpieczne.
Charles Duffy
Istniejący kod również nie obsługuje poprawnie plików ze spacjami, znakami wieloznacznymi itp.
Charles Duffy
1

z open („nazwa pliku”) jako f:

    print(f.read()[::-1])
JackoM
źródło
Czy to odczytuje cały plik? Czy to jest bezpieczne w przypadku dużych plików? Wydaje się, że jest to bardzo łatwy i realistyczny sposób na zrobienie tego, ale nie jestem pewien co do powyższych pytań .. Chciałbym przeszukać plik w ten sposób (używając re) ..
ikwyl6
@ ikwyl6 To powinno być równoważne z list(reversed(f.read())).
AMC
0
def reverse_lines(filename):
    y=open(filename).readlines()
    return y[::-1]
Gareema
źródło
Czy nie jest to zasadniczo to samo rozwiązanie, co przyjęta odpowiedź ?
AMC
0

Zawsze używaj withpodczas pracy z plikami, ponieważ obsługuje wszystko za Ciebie:

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

Lub w Pythonie 3:

with open('filename', 'r') as f:
    for line in reversed(list(f.readlines())):
        print(line)
Carlos Afonso
źródło
0

musiałbyś najpierw otworzyć plik w formacie do odczytu, zapisać go w zmiennej, a następnie otworzyć drugi plik w formacie do zapisu, w którym zapisałbyś lub dołączył zmienną za pomocą wycinka [:: - 1], całkowicie odwracając plik. Możesz także użyć readlines (), aby utworzyć listę wierszy, którymi możesz manipulować

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
źródło
0

Większość odpowiedzi wymaga przeczytania całego pliku, zanim cokolwiek zrobisz. Ta próbka odczytuje coraz większe próbki od końca .

Odpowiedź Murata Yükselena widziałem tylko podczas pisania tej odpowiedzi. Jest prawie taki sam, co, jak sądzę, jest dobre. Poniższy przykład dotyczy również \ r i zwiększa rozmiar bufora na każdym kroku. Mam też kilka testów jednostkowych, aby wykonać kopię zapasową tego kodu.

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
źródło
0

Przeczytaj plik wiersz po wierszu, a następnie dodaj go do listy w odwrotnej kolejności.

Oto przykład kodu:

reverse = []
with open("file.txt", "r") as file:
    for line in file:
        line = line.strip()
         reverse[0:0] = line
Willy Wonka
źródło
Wydaje się, że to gorsza wersja rozwiązania w przyjętej odpowiedzi .
AMC
0
import sys
f = open(sys.argv[1] , 'r')
for line in f.readlines()[::-1]:
    print line
Powerup California
źródło
Czy nie jest to zasadniczo to samo rozwiązanie, co przyjęta odpowiedź ?
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

używać:

opened_file = open(filepath, "rb")
iterator = self.previous_line(opened_file)
line = next(iterator) #one step
close(opened_file)
Wiaczesław
źródło
-3

Musiałem to zrobić jakiś czas temu i użyłem poniższego kodu. Ruruje do powłoki. Obawiam się, że nie mam już pełnego scenariusza. Jeśli korzystasz z uniksowego systemu operacyjnego, możesz użyć "tac", jednak np. Na Mac OSX komenda tac nie działa, użyj tail -r. Poniższy fragment kodu sprawdza, na której platformie jesteś, i odpowiednio dostosowuje polecenie

# 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
źródło
Plakat szuka odpowiedzi w Pythonie.
mikemaccana
Cóż, jest to odpowiedź Pythona, chociaż wydaje się niekompletna.
DrDee
2
to nie, nie crossplatform, używając poleceń systemowych = nie python
Phyo Arkar Lwin
Plakat szuka odpowiedzi „używając pythona”, w której rzeczywiście znajduje się fragment kodu. Zgadzam się jednak, że nie jest to zbyt dobre rozwiązanie w porównaniu z wieloma innymi opublikowanymi.
jeorgen,
1
Fragment nie jest wystarczająco kompletny, aby ocenić poprawność (inne części wywołania nie są pokazane), ale przechowywanie poleceń powłoki w łańcuchach jest samo w sobie wysoce podejrzane - łatwo o błędy związane z wstrzykiwaniem powłoki, chyba że zajmie się dużo Opieki.
Charles Duffy