Obtenir les n dernières lignes d'un fichier, similaire à tail.

Question

Je suis en train d'écrire un visualisateur de fichier journal pour une application web et pour cela je veux paginer à travers les lignes du fichier journal. Les éléments dans le fichier sont basés sur les lignes avec l'élément le plus récent en bas.

J'ai donc besoin d'un tail() qui peut lire n lignes à partir du bas et soutenir un décalage. C'est le chapeau que j'ai trouvé :

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:
            # woops.  apparently file is smaller than what we want
            # to step back, go to the beginning instead
            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

S'agit-il d'une approche raisonnable ? Quelle est la méthode recommandée pour mettre en queue les fichiers journaux avec des décalages ?

Answer 1

Cela peut être plus rapide que le vôtre. Il ne fait aucune supposition sur la longueur des lignes. Il revient en arrière dans le fichier, un bloc à la fois, jusqu'à ce qu'il ait trouvé le bon nombre de ' \n des personnages.

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 = [] # blocks of size BLOCK_SIZE, in reverse order starting
                # from the end of the file
    while lines_to_go > 0 and block_end_byte > 0:
        if (block_end_byte - BLOCK_SIZE > 0):
            # read the last block we haven't yet read
            f.seek(block_number*BLOCK_SIZE, 2)
            blocks.append(f.read(BLOCK_SIZE))
        else:
            # file too small, start from begining
            f.seek(0,0)
            # only read what was not read
            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:])

Je n'aime pas les hypothèses délicates sur la longueur des lignes, alors que, dans la pratique, on ne peut jamais savoir ce genre de choses.

En général, cela permet de localiser les 20 dernières lignes lors du premier ou du deuxième passage dans la boucle. Si votre truc des 74 caractères est vraiment précis, vous faites la taille de bloc 2048 et vous aurez 20 lignes de queue presque immédiatement.

De plus, je ne brûle pas beaucoup de calories cérébrales en essayant d'affiner l'alignement avec des blocs OS physiques. En utilisant ces paquets d'E/S de haut niveau, je doute que vous puissiez constater une quelconque conséquence sur les performances en essayant de vous aligner sur les limites des blocs du système d'exploitation. Si vous utilisez des E/S de plus bas niveau, vous pourriez voir un gain de vitesse.

---

UPDATE

pour Python 3.2 et plus, suivez le processus sur les octets comme dans les fichiers texte In (ceux qui sont ouverts sans l'icône "b" dans la chaîne mode), seules les recherches relatives au début du fichier sont autorisées (l'exception étant la recherche jusqu'à la toute fin du fichier avec seek(0, 2)) :

eg : f = open('C:/.../../apache_logs.txt', 'rb')

 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(b'\n')
        lines_to_go -= lines_found
        block_end_byte -= BLOCK_SIZE
        block_number -= 1
    all_read_text = b''.join(reversed(blocks))
    return b'\n'.join(all_read_text.splitlines()[-total_lines_wanted:])

Answer 2

En supposant un système de type unix sur Python 2 vous pouvez faire :

import os
def tail(f, n, offset=0):
  stdin,stdout = os.popen2("tail -n "+n+offset+" "+f)
  stdin.close()
  lines = stdout.readlines(); stdout.close()
  return lines[:,-offset]

Pour python 3, vous pouvez le faire :

import subprocess
def tail(f, n, offset=0):
    proc = subprocess.Popen(['tail', '-n', n + offset, f], stdout=subprocess.PIPE)
    lines = proc.stdout.readlines()
    return lines[:, -offset]

Answer 3

Si la lecture de l'ensemble du fichier est acceptable, utilisez un deque.

from collections import deque
deque(f, maxlen=n)

Avant la 2.6, les deques n'avaient pas d'option maxlen, mais il est assez facile de l'implémenter.

import itertools
def maxque(items, size):
    items = iter(items)
    q = deque(itertools.islice(items, size))
    for item in items:
        del q[0]
        q.append(item)
    return q

S'il est nécessaire de lire le fichier depuis la fin, utilisez une recherche galopante (aussi appelée exponentielle).

def tail(f, n):
    assert n >= 0
    pos, lines = n+1, []
    while len(lines) <= n:
        try:
            f.seek(-pos, 2)
        except IOError:
            f.seek(0)
            break
        finally:
            lines = list(f)
        pos *= 2
    return lines[-n:]

Answer 4

La réponse de S.Lott ci-dessus fonctionne presque pour moi mais finit par me donner des lignes partielles. Il s'avère qu'elle corrompt les données aux limites des blocs parce que data contient les blocs lus dans un ordre inversé. Lorsque ''.join(data) est appelé, les blocs sont dans le mauvais ordre. Ceci corrige cela.

def tail(f, window=20):
    """
    Returns the last `window` lines of file `f` as a list.
    f - a byte file-like object
    """
    if window == 0:
        return []
    BUFSIZ = 1024
    f.seek(0, 2)
    bytes = f.tell()
    size = window + 1
    block = -1
    data = []
    while size > 0 and bytes > 0:
        if bytes - BUFSIZ > 0:
            # Seek back one whole BUFSIZ
            f.seek(block * BUFSIZ, 2)
            # read BUFFER
            data.insert(0, f.read(BUFSIZ))
        else:
            # file too small, start from begining
            f.seek(0,0)
            # only read what was not read
            data.insert(0, f.read(bytes))
        linesFound = data[0].count('\n')
        size -= linesFound
        bytes -= BUFSIZ
        block -= 1
    return ''.join(data).splitlines()[-window:]

Answer 5

Le code que j'ai fini par utiliser. Je pense que c'est le meilleur jusqu'à présent :

def tail(f, n, offset=None):
    """Reads a n lines from f with an offset of offset lines.  The return
    value is a tuple in the form ``(lines, has_more)`` where `has_more` is
    an indicator that is `True` if there are more lines in the file.
    """
    avg_line_length = 74
    to_read = n + (offset or 0)

    while 1:
        try:
            f.seek(-(avg_line_length * to_read), 2)
        except IOError:
            # woops.  apparently file is smaller than what we want
            # to step back, go to the beginning instead
            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], \
                   len(lines) > to_read or pos > 0
        avg_line_length *= 1.3