Tìm dòng cuối cùng trong một tệp văn bản

Question

Tôi cần trích xuất dòng cuối cùng từ một số tệp văn bản rất lớn (vài trăm megabyte) để nhận dữ liệu nhất định. Hiện tại, tôi đang sử dụng python để chuyển qua tất cả các dòng cho đến khi tệp rỗng và sau đó tôi xử lý dòng cuối cùng được trả về, nhưng tôi chắc chắn có một cách hiệu quả hơn để thực hiện việc này.

Cách tốt nhất để truy xuất dòng cuối cùng của tệp văn bản bằng python là gì?

Answer 1

lines = file.readlines() 
fileHandle.close() 
last_line = lines[-1] 

Answer 2

Bạn không cần phải lặp qua tất cả các dòng. Bạn có thể chỉ đọc các tập tin vào một danh sách và chỉ mục dòng cuối cùng?

tôi thấy ví dụ này:

http://www.daniweb.com/software-development/python/threads/121557

Answer 3

Không cách thẳng về phía trước, nhưng có lẽ nhanh hơn nhiều so với một thực hiện Python đơn giản:

line = subprocess.check_output(['tail', '-1', filename]) 

Answer 4

Sử dụng phương pháp seek của tập tin với một tiêu cực bù đắp và whence=os.SEEK_END để đọc một khối từ cuối tệp. Tìm kiếm khối đó cho (các) ký tự cuối dòng cuối cùng và lấy tất cả các ký tự sau nó. Nếu không có dòng kết thúc, sao lưu xa hơn và lặp lại quá trình.

def last_line(in_file, block_size=1024, ignore_ending_newline=False): 
    suffix = "" 
    in_file.seek(0, os.SEEK_END) 
    in_file_length = in_file.tell() 
    seek_offset = 0 

    while(-seek_offset < in_file_length): 
     # Read from end. 
     seek_offset -= block_size 
     if -seek_offset > in_file_length: 
      # Limit if we ran out of file (can't seek backward from start). 
      block_size -= -seek_offset - in_file_length 
      if block_size == 0: 
       break 
      seek_offset = -in_file_length 
     in_file.seek(seek_offset, os.SEEK_END) 
     buf = in_file.read(block_size) 

     # Search for line end. 
     if ignore_ending_newline and seek_offset == -block_size and buf[-1] == '\n': 
      buf = buf[:-1] 
     pos = buf.rfind('\n') 
     if pos != -1: 
      # Found line end. 
      return buf[pos+1:] + suffix 

     suffix = buf + suffix 

    # One-line file. 
    return suffix 

Lưu ý rằng điều này sẽ không hoạt động trên những thứ không hỗ trợ seek, như stdin hoặc ổ cắm. Trong những trường hợp đó, bạn bị mắc kẹt khi đọc toàn bộ nội dung (như lệnh tail).

Answer 5

Nếu bạn biết chiều dài tối đa của một dòng, bạn có thể làm

def getLastLine(fname, maxLineLength=80): 
    fp=file(fname, "rb") 
    fp.seek(-maxLineLength-1, 2) # 2 means "from the end of the file" 
    return fp.readlines()[-1] 

này hoạt động trên máy tính của cửa sổ của tôi. Nhưng tôi không biết điều gì xảy ra trên các nền tảng khác nếu bạn mở tệp văn bản ở chế độ nhị phân. Chế độ nhị phân là cần thiết nếu bạn muốn sử dụng tìm kiếm().

Answer 6

Tìm kiếm ở cuối tệp trừ 100 byte. Hãy đọc và tìm kiếm một dòng mới. Nếu đây không phải là dòng mới, hãy tìm kiếm thêm 100 byte nữa. Lót, rửa sạch, lặp lại. Cuối cùng bạn sẽ tìm thấy một dòng mới. Dòng cuối cùng bắt đầu ngay sau dòng mới đó.

Kịch bản trường hợp tốt nhất bạn chỉ thực hiện một lần đọc 100 byte.

Answer 7

Nếu bạn có thể chọn độ dài dòng tối đa hợp lý, bạn có thể tìm đến gần cuối tập tin trước khi bắt đầu đọc.

myfile.seek(-max_line_length, os.SEEK_END) 
line = myfile.readlines()[-1] 

Answer 8

bạn thể tải các tập tin vào một mmap, sau đó sử dụng mmap.rfind (string [, bắt đầu [, kết thúc]]) để tìm nhân vật EOL cuối cùng thứ hai trong file? Việc tìm kiếm điểm đó trong tệp sẽ hướng bạn đến dòng cuối cùng mà tôi nghĩ.

Answer 9

Tính không hiệu quả ở đây không thực sự là do Python, nhưng về bản chất của cách đọc tệp. Cách duy nhất để tìm dòng cuối cùng là đọc tệp và tìm dòng kết thúc. Tuy nhiên, hoạt động tìm kiếm có thể được sử dụng để bỏ qua bất kỳ bù đắp byte nào trong tệp.Do đó, bạn có thể bắt đầu rất gần cuối tệp và lấy các đoạn lớn hơn và lớn hơn khi cần cho đến khi dòng cuối cùng kết thúc được tìm thấy:

from os import SEEK_END 

def get_last_line(file): 
    CHUNK_SIZE = 1024 # Would be good to make this the chunk size of the filesystem 

    last_line = "" 

    while True: 
    # We grab chunks from the end of the file towards the beginning until we 
    # get a new line 
    file.seek(-len(last_line) - CHUNK_SIZE, SEEK_END) 
    chunk = file.read(CHUNK_SIZE) 

    if not chunk: 
     # The whole file is one big line 
     return last_line 

    if not last_line and chunk.endswith('\n'): 
     # Ignore the trailing newline at the end of the file (but include it 
     # in the output). 
     last_line = '\n' 
     chunk = chunk[:-1] 

    nl_pos = chunk.rfind('\n') 
    # What's being searched for will have to be modified if you are searching 
    # files with non-unix line endings. 

    last_line = chunk[nl_pos + 1:] + last_line 

    if nl_pos == -1: 
     # The whole chunk is part of the last line. 
     continue 

    return last_line 

Answer 10

Đây là một giải pháp hơi khác. Thay vì đa dòng, tôi chỉ tập trung vào dòng cuối cùng và thay vì kích thước khối không đổi, tôi có kích thước khối động (gấp đôi). Xem nhận xét để biết thêm thông tin.

# Get last line of a text file using seek method. Works with non-constant block size. 
# IDK if that speed things up, but it's good enough for us, 
# especially with constant line lengths in the file (provided by len_guess), 
# in which case the block size doubling is not performed much if at all. Currently, 
# we're using this on a textfile format with constant line lengths. 
# Requires that the file is opened up in binary mode. No nonzero end-rel seeks in text mode. 
REL_FILE_END = 2 
def lastTextFileLine(file, len_guess=1): 
    file.seek(-1, REL_FILE_END)  # 1 => go back to position 0; -1 => 1 char back from end of file 
    text = file.read(1) 
    tot_sz = 1    # store total size so we know where to seek to next rel file end 
    if text != b'\n':  # if newline is the last character, we want the text right before it 
     file.seek(0, REL_FILE_END) # else, consider the text all the way at the end (after last newline) 
     tot_sz = 0 
    blocks = []   # For storing succesive search blocks, so that we don't end up searching in the already searched 
    j = file.tell()   # j = end pos 
    not_done = True 
    block_sz = len_guess 
    while not_done: 
     if j < block_sz: # in case our block doubling takes us past the start of the file (here j also = length of file remainder) 
      block_sz = j 
      not_done = False 
     tot_sz += block_sz 
     file.seek(-tot_sz, REL_FILE_END)   # Yes, seek() works with negative numbers for seeking backward from file end 
     text = file.read(block_sz) 
     i = text.rfind(b'\n') 
     if i != -1: 
      text = text[i+1:].join(reversed(blocks)) 
      return str(text) 
     else: 
      blocks.append(text) 
      block_sz <<= 1 # double block size (converge with open ended binary search-like strategy) 
      j = j - block_sz  # if this doesn't work, try using tmp j1 = file.tell() above 
    return str(b''.join(reversed(blocks)))  # if newline was never found, return everything read 

Lý tưởng nhất, bạn nên bọc nó trong một lớp LastTextFileLine và theo dõi độ dài trung bình di chuyển. Điều này sẽ cho bạn một len_guess tốt có thể. !

Answer 11

/usr/bin/python

count = 0

f = open ('last_line1', 'r')

cho dòng trong f.readlines():

line = line.strip() 

count = count + 1 

print line 

count in

f.close()

count1 = 0

h = open ('last_line1', 'r')

cho dòng trong h.readlines():

line = line.strip() 

count1 = count1 + 1 

if count1 == count: 

    print line   #------------------------- this is the last line 

h.close()

Answer 12

with open('output.txt', 'r') as f: 
    lines = f.read().splitlines() 
    last_line = lines[-1] 
    print last_line