Wie kann ich die letzten N Zeilen einer großen Datei effizient abrufen?

Letzte N Zeilen einer Datei abrufen und „Ende“ simulieren

Einführung:

Bei der Analyse großer Protokolldateien Oft ist es erforderlich, die letzten N Zeilen zur Paginierung oder Überprüfung abzurufen. Dies wirft die Frage auf, wie man eine Protokolldatei effizient mit einem Offset versehen kann.

Kandidatenlösung 1:

def tail(f, n, offset=0):
    avg_line_length = 74
    to_read = n + offset
    while 1:
        try:
            f.seek(-(avg_line_length * to_read), 2)
        except IOError:
            f.seek(0)
        pos = f.tell()
        lines = f.read().splitlines()
        if len(lines) >= to_read or pos == 0:
            return lines[-to_read:offset and -offset or None]
        avg_line_length *= 1.3

Bewertung:

Dies Der Ansatz geht von Annahmen über die durchschnittliche Zeilenlänge aus und sucht schrittweise rückwärts, bis er genügend Zeilen findet. Aufgrund der anfänglichen Schätzung muss möglicherweise mehrmals gesucht werden, was möglicherweise zu Leistungseinbußen führt.

Kandidatenlösung 2:

def tail(f, lines=20):
    BLOCK_SIZE = 1024
    f.seek(0, 2)
    block_end_byte = f.tell()
    lines_to_go = lines
    block_number = -1
    blocks = []
    while lines_to_go > 0 and block_end_byte > 0:
        if (block_end_byte - BLOCK_SIZE > 0):
            f.seek(block_number * BLOCK_SIZE, 2)
            blocks.append(f.read(BLOCK_SIZE))
        else:
            f.seek(0, 0)
            blocks.append(f.read(block_end_byte))
        lines_found = blocks[-1].count('\n')
        lines_to_go -= lines_found
        block_end_byte -= BLOCK_SIZE
        block_number -= 1
    all_read_text = ''.join(reversed(blocks))
    return '\n'.join(all_read_text.splitlines()[-lines:])

Erklärung:

Diese Methode geht Block für Block durch die Datei zurück, bis sie die gewünschte Anzahl von Zeilenumbrüchen findet. Es werden keine Annahmen über die Zeilenlänge getroffen und von Anfang an gelesen, wenn die Datei zu klein ist, um sie zurückzuverfolgen.

Vergleich:

Kandidatenlösung 2 ist im Allgemeinen effizienter und robuster als Kandidatenlösung 1 , da es nicht auf Schätzungen beruht und die Datei nacheinander liest. Dies ist ein zuverlässigerer Ansatz für das Tailing von Protokolldateien mit Offsets.

Das obige ist der detaillierte Inhalt vonWie kann ich die letzten N Zeilen einer großen Datei effizient abrufen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!