Comment puis-je récupérer efficacement les N dernières lignes d'un fichier en Python (avec prise en charge du décalage) ?

Obtenir les N dernières lignes d'un fichier, similaire à Tail

Introduction

L'analyse des fichiers journaux implique souvent la possibilité de afficher les entrées les plus récentes. Ceci est généralement réalisé à l'aide de la commande "tail", qui récupère les n dernières lignes d'un fichier. Dans cet article, nous explorerons une implémentation d'une méthode Python qui émule la commande tail, avec prise en charge des décalages.

Implémentation de Tail

La méthode tail() proposée fonctionne comme suit :

1. Il lit n lignes à partir du bas du fichier.
2. Il fournit un paramètre de décalage à ignorer un nombre spécifié de lignes à partir du bas.

def tail(f, n, offset=0):
    """Reads a n lines from f with an offset of offset lines."""
    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

Cette méthode estime la longueur moyenne des lignes et l'ajuste dynamiquement pour optimiser les performances.

Approche alternative

L'implémentation originale fait des hypothèses sur la longueur des lignes, qui ne sont pas toujours vraies. Voici une approche alternative qui évite de telles hypothèses :

def tail(f, lines=20):
    total_lines_wanted = lines

    BLOCK_SIZE = 1024
    f.seek(0, 2)
    block_end_byte = f.tell()
    lines_to_go = total_lines_wanted
    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()[-total_lines_wanted:])

Cette méthode recherche en arrière dans le fichier un bloc à la fois, en comptant les sauts de ligne pour trouver les lignes souhaitées.

Conclusion

Les deux méthodes fournissent des solutions viables pour récupérer les n dernières lignes d'un fichier avec prise en charge du décalage. L'approche alternative évite les hypothèses sur la longueur des lignes et pourrait être plus efficace pour les fichiers volumineux.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!