Як читати файл у зворотному порядку?


128

Як читати файл у зворотному порядку за допомогою python? Я хочу прочитати файл з останнього до першого рядка.


7
Ви маєте на увазі "прочитати його у зворотному порядку" чи "обробити рядки у зворотному порядку"? Є різниця. По-перше, потенційно файл не вмістився б у пам'яті одночасно, тому ви хочете обробляти рядки у зворотному порядку, але ви не можете прочитати весь файл і повернути його назад. З другим, ви можете просто прочитати весь файл у та перевернути список рядків перед їх обробкою. Так що це?
Лассе В. Карлсен


1
Я рекомендую це - проблем із пам’яттю немає і швидко: stackoverflow.com/a/260433/1212562
Brian B

Відповіді:


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

А в Python 3:

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

192
На жаль, це не працює, якщо ви не можете вмістити весь файл у пам'яті.
vy32

3
Також, хоча розміщений код відповідає на питання, ми повинні бути обережними, щоб закрити файли, які ми відкриваємо. withЗаява, як правило , абсолютно безболісно.
Вільям

1
@MichaelDavidWatson: не без читання спочатку оригінального ітератора в пам’яті, а потім подання нового ітератора над першим у зворотному.
Метт Столяр

3
@MichaelDavidWatson: Ви можете читати файл у зворотному порядку, не читаючи його в пам’яті, але він нетривіальний і вимагає безлічі буферних шенаніганів, щоб уникнути значних втрат системних викликів. Він також буде працювати дуже погано (хоч і краще, ніж читання всієї пам'яті в пам'яті, якщо файл перевищує доступну пам'ять).
Метт Столяр

1
@William Вибачте, як я можу використовувати вищезазначене рішення, використовуючи "з відкритим" під час ітерації над файлом, а потім очистити-закрити його?
BringBackCommodore64

146

Правильна, ефективна відповідь, написана як генератор.

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
Це не працюватиме для текстових файлів у python> = 3.2, оскільки чомусь пошуки відносно кінця файлу більше не підтримуються. Це можна виправити, зберігаючи розмір файлу, що повертається, fh.seek(0, os.SEEK_END)і змінюючи fh.seek(-offset, os.SEEK_END)теж fh.seek(file_size - offset).
levesque

9
Після внесення змін, це ідеально працює в python 3.5. Найкраща відповідь на запитання.
notbad.jpeg

3
повернути цю зміну для python 2, де fh.seek()повертаєтьсяNone
marengaz

1
Слідкуйте, що це може не працювати так, як очікувалося для текстових файлів. Правильне отримання блоків у зворотному порядку працює лише для двійкових файлів. Проблема полягає в тому, що для текстових файлів з багатобайтовим кодуванням (наприклад utf8) seek()і read()посилаються на різні розміри. Це, мабуть, також причина того, що ненульовий перший аргумент seek()щодо os.SEEK_ENDне підтримується.
norok2

3
просто: 'aöaö'.encode()є b'a\xc3\xb6a\xc3\xb6'. Якщо ви збережете це на диску і потім прочитаєте в текстовому режимі, тоді, коли ви seek(2)це зробите, він переміститься на два байти, і це seek(2); read(1)призведе до помилки UnicodeDecodeError: 'utf-8' codec can't decode byte 0xb6 in position 0: invalid start byte, але якщо ви це зробите seek(0); read(2); read(1), ви отримаєте 'a'очікуване, тобто: seek()ніколи не кодується -знаємо, read()це якщо ви відкриєте файл у текстовому режимі. Тепер, якщо є 'aöaö' * 1000000, ваші блоки будуть вирівняні неправильно.
norok2

23

Як щодо щось подібне:

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

Оскільки файл читається символом за символом у зворотному порядку, він буде працювати навіть у дуже великих файлах, доки окремі рядки вписуються в пам'ять.


20

Ви також можете використовувати модуль python file_read_backwards .

Встановивши його, через pip install file_read_backwards(v1.2.1), ви можете прочитати весь файл назад (строково) в пам'яті ефективно:

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

Він підтримує кодування "utf-8", "latin-1" та "ascii".

Підтримка також доступна для python3. Додаткову документацію можна знайти на веб-сайті http://file-read-backwards.readthedocs.io/en/latest/readme.html


Дякую за це рішення. Мені подобається (і також схвалено) рішення, подане вище @srohde, оскільки воно допомогло мені зрозуміти, як це робиться, але як розробник я вважаю за краще використовувати існуючий модуль, коли можу, тому я радий дізнатися про це.
joanis

1
Це працює з багатобайтовим кодуванням, як UTF-8. Рішення "шукати / читати" не: шукати () рахується в байтах, читати () в символах.
Єреміту

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

Якщо ви перебуваєте в Linux, ви можете використовувати tacкоманду.

$ tac file

2 рецепти ви можете знайти в ActiveState тут і тут


1
Цікаво, чи споживає зворотна () ціла послідовність перед ітерацією. Документи кажуть, що потрібен __reversed__()метод, але python2.5 не скаржиться на користувацький клас без нього.
мухук

@muhuk, ймовірно, потрібно якось кешувати це, я підозрюю, що він генерує новий список у зворотному порядку, а потім повертає до цього ітератор
Matt Joiner

1
@Matt: це було б смішно. Він просто переходить зі спини вперед - len (L) -1 - це задня частина, 0 - це спереду. Ви можете зобразити решту.
Девін Жанп'єр

@muhuk: Послідовності не витрачаються значимо (ви можете перебирати всю послідовність, але це не має великого значення). __reversed__Метод теж не є необхідним, і не використовувати , щоб така річ. Якщо об'єкт забезпечує __len__і __getitem__він буде працювати тільки штраф (мінус деякі виняткові випадки, такі як Словник).
Девін Жанп'єр

@Devin Jeanpierre: Тільки якщо readlines () повертає об'єкт, який надає __reversed__?
Метт Столяр

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)

Здається, це дає неправильний вихід для файлів, більших за буфер. Він неправильно обробляє рядки, що охоплюють шматки розміру буфера, які ви читаєте, як я розумію. Я розмістив ще одну подібну відповідь (на інше подібне запитання).
Дарій Бекон

@Darius: Ага так, я, здається, трохи пропустив. Слід виправити зараз.
Ігнасіо Васкес-Абрамс

Виглядає правильно. Я все одно віддаю перевагу власний код, оскільки це робить O (N ^ 2) великим файлом, який є одним довгим рядком. (У подібних відповідях на інше питання, яке я тестував, це спричинило серйозне справжнє уповільнення таких файлів.)
Дарій Бекон

3
Ну, питання не згадувало продуктивність, тому я не можу вибирати катастрофу продуктивності, яка є регулярними виразами: P
Matt Joiner

Ще одне пояснення було б корисним як продуктивність, і якщо це насправді може прагнути сказати останній рядок і прочитати лише цей твір.
користувач1767754

7

Прийнята відповідь не буде працювати у випадках з великими файлами, які не вмістяться в пам'яті (що не є рідкісним випадком).

Як відзначили інші, відповідь @srohde виглядає добре, але у неї є наступні питання:

  • файл відкриття виглядає зайвим, коли ми можемо передати об’єкт файлу та залишити його користувачеві, щоб він вирішив, в якому кодуванні його слід читати,
  • навіть якщо ми рефактор прийняти файл-об'єкт, він не працюватиме для всіх кодувань: ми можемо вибрати файл із utf-8вмістом кодування та не-ascii вмістом, наприклад

    й

    пройти buf_sizeрівним 1і буде

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

    текст, звичайно, може бути більшим, але buf_size може бути зібраний, так що це призведе до прихованої помилки, як вище,

  • ми не можемо вказати спеціальний роздільник рядків,
  • ми не можемо вибрати, щоб зберегти роздільник рядків.

Отже, враховуючи всі ці проблеми, я написав окремі функції:

  • той, який працює з потоками байтів,
  • другий, який працює з текстовими потоками та делегує його базовий потік байтів першому та декодує отримані рядки.

Перш за все давайте визначимо наступні функції утиліти:

ceil_divisionдля виготовлення поділу з стелею (на відміну від стандартного //поділу на підлогу, більше інформації можна знайти в цій нитці )

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

split для розбиття рядка заданим роздільником від правого кінця з можливістю зберегти його:

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 читати партію з правого кінця бінарного потоку

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)

Після цього ми можемо визначити функцію для читання потоку байтів у зворотному порядку

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

і нарешті функцію для повернення текстового файлу можна визначити як:

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

Тести

Підготовка

Я створив 4 файли за допомогою fsutilкоманди :

  1. empty.txt без вмісту, розмір 0MB
  2. tiny.txt розміром 1 Мб
  3. small.txt розміром 10 Мб
  4. великий.txt розміром 50MB

також я відновив рішення @srohde для роботи з об’єктом файлу замість шляху до файлу.

Тестовий сценарій

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

Примітка : я використовував collections.dequeклас для генератора вихлопу.

Виходи

Для PyPy 3.5 в 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

Для CPython 3.5 у 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

Як ми бачимо, воно виконує як оригінальне рішення, але є більш загальним та позбавлене перелічених вище недоліків.


Реклама

Я додав це до 0.3.0версії lzпакета (потрібен Python 3.5 +), який має багато добре перевірених функціональних / ітераційних утиліт.

Можна використовувати як

 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)

Він підтримує всі стандартні кодування (можливо, за винятком випадків, utf-7коли мені важко визначити стратегію для створення рядків, що кодуються з ним).


2

Тут ви можете знайти мою реалізацію, ви можете обмежити використання оперативної пам'яті, змінивши змінну "буфер", є помилка, що програма виводить порожній рядок на початку.

А також використання барана може збільшуватися, якщо нових рядків не буде більше, ніж байт буфера, змінна "протікання" збільшуватиметься до появи нового рядка ("\ n").

Це також працює для 16 ГБ файлів, що більше моєї загальної пам'яті.

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

Дякую за відповідь @srohde. У ньому є невелика перевірка помилок у новому рядку за допомогою оператора "є", і я не зміг прокоментувати відповідь з 1 репутацією. Також я хотів би керувати файлом, відкритим назовні, тому що це дозволяє мені вставляти свої міркування для завдань Луїджі.

Що мені потрібно було змінити, має форму:

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

Я хотів би змінити:

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

Ось модифікована відповідь, яка хоче обробляти файл і зберігає нові рядки:

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

проста функція створення другого файлу, оберненого назад (лише для Linux):

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

як використовувати

tac('ordered.csv', 'reversed.csv')
f = open('reversed.csv')

Я думаю, що мета полягала в тому, як це зробити в Python. Плюс це працює лише в системах * Nix, хоча це відмінне рішення для цього. По суті, це просто використання Python як підказки для запуску утиліти оболонки.
Олександр Хузаг

1
Цей код містить основні помилки безпеки, як це написано в даний час. Що робити, якщо ви намагаєтесь змінити файл, створений за допомогою mv mycontent.txt $'hello $(rm -rf $HOME) world.txt'або подібним чином, використовуючи ім'я вихідного файлу, надане ненадійним користувачем? Якщо ви хочете безпечно обробляти довільні назви файлів, потрібно бути обережнішими. subprocess.Popen(['tac', file1], stdout=open(file2, 'w'))наприклад, було б безпечно.
Чарльз Даффі

Існуючий код також неправильно обробляє файли з пробілами, символами, & c.
Чарльз Даффі


1

з відкритим ("ім'я файлу") як f:

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

Чи читає це весь файл у? Це безпечно для великих файлів? Це здається дуже простим і реалістичним способом зробити це, але не впевнений у вищезазначених питаннях .. Я хотів би шукати файл таким чином (використовуючи повторно) ..
ikwyl6

@ ikwyl6 Це має бути еквівалентно list(reversed(f.read())).
AMC


0

Завжди використовуйте withпід час роботи з файлами, оскільки він обробляє все для вас:

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

Або в Python 3:

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

0

спочатку потрібно відкрити файл у форматі читання, зберегти його до змінної, а потім відкрити другий файл у форматі запису, де ви б писали чи додавали змінну, використовуючи фрагмент [:: - 1], повністю перевернувши файл. Ви також можете використовувати readlines (), щоб перетворити їх у список рядків, якими можна маніпулювати

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

Більшість відповідей потрібно прочитати весь файл, перш ніж щось робити. Цей зразок читає все більші зразки з кінця .

Відповідь Мурата Юкселена я бачив лише під час написання цієї відповіді. Це майже те саме, що я гадаю, це гарна річ. Зразок нижче також має справу з \ r і збільшує його буферність на кожному кроці. У мене також є кілька тестів для резервного копіювання цього коду.

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

Прочитайте файл за рядком, а потім додайте його до списку у зворотному порядку.

Ось приклад коду:

reverse = []
with open("file.txt", "r") as file:
    for line in file:
        line = line.strip()
         reverse[0:0] = line

Це просто здається неповноцінною версією рішення у прийнятій відповіді .
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

використовувати:

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

-3

Мені довелося це зробити деякий час тому і використав наведений нижче код. Це труби до оболонки. Боюся, у мене вже немає повного сценарію. Якщо ви перебуваєте в операційній системі Unixish, ви можете використовувати "tac", однак, наприклад, команда tac Mac OSX не працює, використовуйте хвіст -r. Нижче наведено фрагменти коду тестів, на якій платформі ви працюєте, і відповідно коригує команду

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

Плакат шукає відповіді пітона.
mikemaccana

Ну, це відповідь Python, хоча, здається, неповна.
DrDee

2
його немає, не є кросплатформою, використовуючи системні команди = не pythonic
Phyo

Плакат шукає відповіді "використовуючи python", про який дійсно написано фрагмент коду. Але я погоджуюся, що це не дуже вдале рішення порівняно з багатьма іншими розміщеними.
jeorgen

1
Фрагмент недостатньо повний, щоб оцінити його правильність (інші частини виклику не показані), але зберігання команд оболонки в рядках є самим підозрілим - помилки з інжекційними оболонками легко, якщо ви не приймаєте багато турботи.
Чарльз Даффі
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.