จะอ่านไฟล์ในลำดับย้อนกลับได้อย่างไร?


129

วิธีอ่านไฟล์ในลำดับย้อนกลับโดยใช้ python ฉันต้องการอ่านไฟล์จากบรรทัดสุดท้ายถึงบรรทัดแรก


7
คุณหมายถึง "อ่านในลำดับย้อนกลับ" หรือ "ประมวลผลบรรทัดตามลำดับย้อนกลับ"? มีความแตกต่าง ประการแรกไฟล์อาจไม่พอดีกับหน่วยความจำทั้งหมดในเวลาเดียวกันดังนั้นคุณจึงต้องการประมวลผลบรรทัดในลำดับย้อนกลับ แต่คุณไม่สามารถอ่านไฟล์ทั้งหมดและย้อนกลับได้ ประการที่สองคุณอาจอ่านทั้งไฟล์และย้อนกลับรายการบรรทัดก่อนประมวลผล มันคืออะไร?
Lasse V.Karlsen


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คำสั่งมักจะไม่เจ็บปวดค่อนข้าง
William

1
@MichaelDavidWatson: ไม่ใช่โดยไม่อ่านตัววนซ้ำเดิมในหน่วยความจำก่อนจากนั้นจึงนำเสนอตัววนซ้ำใหม่ในตัวแรกในทางกลับกัน
Matt Joiner

3
@MichaelDavidWatson: คุณสามารถอ่านไฟล์ย้อนกลับได้โดยไม่ต้องอ่านลงในหน่วยความจำ แต่มันไม่สำคัญและต้องใช้บัฟเฟอร์จำนวนมากเพื่อหลีกเลี่ยงการเสียการโทรระบบจำนวนมาก นอกจากนี้ยังทำงานได้แย่มาก (แม้ว่าจะดีกว่าการอ่านหน่วยความจำทั้งหมดลงในหน่วยความจำหากไฟล์มีหน่วยความจำเกินกว่าที่มีอยู่)
Matt Joiner

1
@ วิลเลียมขออภัยฉันจะใช้วิธีแก้ปัญหาข้างต้นโดยใช้ "with open" ได้อย่างไรในขณะที่ทำซ้ำบนไฟล์จากนั้นล้าง - ปิด
BringBackC Commodore64

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

file_read_backwardsนอกจากนี้คุณยังสามารถใช้โมดูลหลาม

หลังจากติดตั้งผ่านpip install file_read_backwards(v1.2.1) คุณสามารถอ่านไฟล์ทั้งหมดย้อนหลัง (line-wise) ในหน่วยความจำอย่างมีประสิทธิภาพผ่าน:

#!/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 โซลูชันการค้นหา / อ่านไม่ได้: การค้นหา () นับเป็นไบต์อ่าน () เป็นอักขระ
Jeremitu

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

หากคุณใช้ linux คุณสามารถใช้tacคำสั่ง

$ tac file

2 สูตรที่คุณสามารถพบได้ใน ActiveState ที่นี่และที่นี่


1
ฉันสงสัยว่าการย้อนกลับ () กินลำดับทั้งหมดก่อนที่จะวนซ้ำ เอกสารบอกว่า__reversed__()จำเป็นต้องใช้วิธีการ แต่ python2.5 ไม่บ่นในคลาสที่กำหนดเองหากไม่มีมัน
muhuk

@muhuk มันอาจจะต้องแคชมันอย่างใดฉันสงสัยว่ามันสร้างรายการใหม่ในลำดับย้อนกลับจากนั้นส่งคืนตัววนซ้ำไปที่
Matt Joiner

1
@ แมท: คงจะไร้สาระ มันเคลื่อนจากด้านหลังไปด้านหน้า - len (L) -1 คือด้านหลัง, 0 คือด้านหน้า คุณสามารถวาดภาพส่วนที่เหลือ
Devin Jeanpierre

@muhuk: ลำดับไม่ได้ถูกใช้อย่างมีความหมาย (คุณสามารถวนซ้ำได้ทั้งลำดับ แต่มันไม่สำคัญมากนัก) __reversed__วิธีการยังไม่จำเป็นและมีไม่ได้ใช้จะเป็นสิ่งที่ดังกล่าว หากออบเจ็กต์จัดเตรียม__len__และ__getitem__มันจะทำงานได้ดี (ลบด้วยกรณีพิเศษบางอย่างเช่น dict)
Devin Jeanpierre

@Devin Jeanpierre: เฉพาะเมื่อ readlines () ส่งคืนอ็อบเจ็กต์ที่ให้__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)

ดูเหมือนว่าจะสร้างเอาต์พุตที่ไม่ถูกต้องสำหรับไฟล์ที่มีขนาดใหญ่กว่าบัฟเฟอร์ มันไม่สามารถจัดการบรรทัดที่ขยายส่วนขนาดบัฟเฟอร์ที่คุณอ่านได้อย่างถูกต้องตามที่ฉันเข้าใจ ฉันโพสต์คำตอบอื่นที่คล้ายกัน (สำหรับคำถามอื่นที่คล้ายกัน)
Darius Bacon

@Darius: อ่าใช่ดูเหมือนฉันจะพลาดไปหน่อย ควรได้รับการแก้ไขในขณะนี้
Ignacio Vazquez-Abrams

ดูเหมาะสม ฉันยังคงชอบรหัสของตัวเองเพราะ O (N ^ 2) ทำงานกับไฟล์ขนาดใหญ่ที่มีบรรทัดยาวทั้งหมด (ในคำตอบที่คล้ายกันสำหรับคำถามอื่น ๆ ที่ฉันทดสอบนี้ทำให้ไฟล์ดังกล่าวชะลอตัวลงอย่างมาก)
Darius Bacon

3
คำถามไม่ได้กล่าวถึงประสิทธิภาพดังนั้นฉันจึงไม่สามารถระบุความหายนะของประสิทธิภาพที่เป็นนิพจน์ทั่วไปได้: P
Matt Joiner

คำอธิบายเพิ่มเติมบางส่วนจะมีประโยชน์ในฐานะประสิทธิภาพและหากสิ่งนี้สามารถพยายามพูดบรรทัดสุดท้ายและอ่านเฉพาะส่วนนั้นได้
user1767754

7

คำตอบที่ยอมรับจะใช้ไม่ได้กับกรณีที่มีไฟล์ขนาดใหญ่ที่ไม่พอดีกับหน่วยความจำ (ซึ่งไม่ใช่กรณีที่หายาก)

ตามที่ผู้อื่นระบุไว้คำตอบของ @srohdeดูดี แต่มีปัญหาต่อไป:

  • ไฟล์ที่เปิดดูซ้ำซ้อนเมื่อเราสามารถส่งไฟล์ออบเจ็กต์และปล่อยให้ผู้ใช้ตัดสินใจว่าควรอ่านการเข้ารหัสใด
  • แม้ว่าเราจะ refactor เพื่อยอมรับไฟล์ object แต่ก็ไม่สามารถใช้ได้กับการเข้ารหัสทั้งหมด: เราสามารถเลือกไฟล์ที่มีการ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ขนาด 1MB
  3. small.txtขนาด 10MB
  4. large.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

คุณสามารถค้นหาการใช้งานของฉันได้ที่นี่คุณสามารถ จำกัด การใช้งานแรมได้โดยการเปลี่ยนตัวแปร "บัฟเฟอร์" มีข้อผิดพลาดที่โปรแกรมพิมพ์บรรทัดว่างในตอนเริ่มต้น

และการใช้ ram อาจเพิ่มขึ้นหากไม่มีบรรทัดใหม่เกินกว่าบัฟเฟอร์ไบต์ตัวแปร "รั่ว" จะเพิ่มขึ้นจนกว่าจะเห็นบรรทัดใหม่ ("\ n")

สิ่งนี้ใช้ได้กับไฟล์ 16 GB ซึ่งใหญ่กว่าหน่วยความจำทั้งหมดของฉัน

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 มีการตรวจสอบข้อผิดพลาดเล็กน้อยสำหรับอักขระขึ้นบรรทัดใหม่ด้วยตัวดำเนินการ 'is' และฉันไม่สามารถแสดงความคิดเห็นกับคำตอบด้วยชื่อเสียง 1 รายการ นอกจากนี้ฉันต้องการจัดการไฟล์ที่เปิดอยู่ภายนอกเพราะนั่นทำให้ฉันสามารถฝังแรมบลอนด์สำหรับงาน luigi ได้

สิ่งที่ฉันต้องการเปลี่ยนแปลงมีรูปแบบ:

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 เพื่อเรียกใช้ยูทิลิตี้เชลล์
Alexander Huszagh

1
รหัสนี้มีจุดบกพร่องด้านความปลอดภัยที่สำคัญตามที่เขียนไว้ในปัจจุบัน จะเกิดอะไรขึ้นถ้าคุณกำลังพยายามย้อนกลับไฟล์ที่สร้างด้วยmv mycontent.txt $'hello $(rm -rf $HOME) world.txt'หรือในทำนองเดียวกันโดยใช้ชื่อไฟล์เอาต์พุตที่กำหนดโดยผู้ใช้ที่ไม่น่าเชื่อถือ หากคุณต้องการจัดการชื่อไฟล์ตามอำเภอใจอย่างปลอดภัยต้องใช้ความระมัดระวังมากขึ้น subprocess.Popen(['tac', file1], stdout=open(file2, 'w'))จะปลอดภัยเช่น
Charles Duffy

โค้ดที่มีอยู่ยังจัดการไฟล์ที่มีช่องว่างอักขระตัวแทนและ c ไม่ถูกต้อง
Charles Duffy

1

หากคุณกังวลเกี่ยวกับขนาดไฟล์ / การใช้หน่วยความจำการแมปหน่วยความจำไฟล์และการสแกนไปข้างหลังเพื่อขึ้นบรรทัดใหม่เป็นวิธีแก้ปัญหา:

จะค้นหาสตริงในไฟล์ข้อความได้อย่างไร?


1

โดยเปิด ("filename") เป็น f:

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

สิ่งนี้อ่านทั้งไฟล์หรือไม่ ปลอดภัยกับไฟล์ขนาดใหญ่หรือไม่? ดูเหมือนจะเป็นวิธีที่ง่ายและทำได้จริง แต่ไม่แน่ใจเกี่ยวกับคำถามข้างต้น .. ฉันต้องการค้นหาไฟล์ด้วยวิธีนี้ (โดยใช้ re) ..
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

คำตอบส่วนใหญ่ต้องอ่านทั้งไฟล์ก่อนทำอะไร ตัวอย่างนี้อ่านตัวอย่างที่มีขนาดใหญ่มากขึ้นจากปลาย

ฉันเห็นเพียงคำตอบของ Murat Yükselenในขณะที่เขียนคำตอบนี้ เกือบจะเหมือนกันซึ่งฉันคิดว่าเป็นสิ่งที่ดี ตัวอย่างด้านล่างยังเกี่ยวข้องกับ \ 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" ได้อย่างไรก็ตามในเช่นคำสั่ง Mac OSX tac ไม่ทำงานให้ใช้ tail -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 Arkar Lwin

ผู้โพสต์กำลังหาคำตอบ "โดยใช้ python" ซึ่งข้อมูลโค้ดนั้นถูกเขียนขึ้นมา แต่ฉันยอมรับว่านั่นไม่ใช่วิธีแก้ปัญหาที่ดีมากนักเมื่อเทียบกับอีกหลาย ๆ คนที่โพสต์
jeorgen

1
ข้อมูลโค้ดไม่สมบูรณ์เพียงพอที่จะประเมินความถูกต้อง (ส่วนอื่น ๆ ของการเรียกใช้ไม่ได้แสดง) แต่การจัดเก็บคำสั่งเชลล์ในสตริงนั้นเป็นเรื่องที่น่าสงสัยอย่างยิ่ง - มันง่ายที่จะมีบั๊กการฉีดเชลล์เว้นแต่จะดำเนินการอย่างมาก ของการดูแล
Charles Duffy
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.