¿Cuál es la forma más eficiente de obtener la primera y la última línea de un archivo de texto?

Puede abrir el archivo para leer y leer la primera línea usando el builtin readline(), luego busque el final del archivo y retroceda hasta encontrar la línea anterior EOL y lea la última línea desde allí.

with open(file, "rb") as f:
    first = f.readline()        # Read the first line.
    f.seek(-2, os.SEEK_END)     # Jump to the second last byte.
    while f.read(1) != b"\n":   # Until EOL is found...
        f.seek(-2, os.SEEK_CUR) # ...jump back the read byte plus one more.
    last = f.readline()         # Read last line.

Saltar al penúltimo byte en lugar del último evita que regrese directamente debido a un EOL final. Mientras que usted está dando un paso atrás también querrá paso dos bytes ya que la lectura y comprobación de EOL empuja el posición hacia adelante un paso.

Cuando se utiliza seek el formato es fseek(offset, whence=0) donde whence significa que lo que el desplazamiento es relativo. Cita de docs.python.org:

• SEEK_SET o 0 = buscar desde el inicio de la secuencia (el valor predeterminado); desplazamiento debe ser un número devuelto por TextIOBase.tell () , o cero. Cualquier otro valor de compensación produce comportamiento indefinido.
• SEEK_CUR o 1 = "buscar" a la posición actual; desplazamiento debe ser cero, que es una no-operación (todos los demás valores son sin soporte).
• SEEK_END o 2 = buscar al final de la secuencia; el desplazamiento debe ser cero (todos los demás valores no son compatibles).

Ejecutarlo a través de timeit 10k veces en un archivo con líneas 6k que suman 200kB me dio 1.62 s vs 6.92 s cuando se compara con el bucle for debajo del que se sugirió antes. Usando un archivo de tamaño 1.3 GB, aún con líneas de 6k, cien veces resultó en 8.93 vs 86.95.

with open(file, "rb") as f:
    first = f.readline()     # Read the first line.
    for last in f: pass      # Loop through the whole file reading it all.

Aquí hay una versión modificada de la respuesta de SilentGhost que hará lo que quieras.

with open(fname, 'rb') as fh:
    first = next(fh)
    offs = -100
    while True:
        fh.seek(offs, 2)
        lines = fh.readlines()
        if len(lines)>1:
            last = lines[-1]
            break
        offs *= 2
    print first
    print last

No hay necesidad de un límite superior para la longitud de la línea aquí.

¿Puede usar comandos unix? Creo que usar head -1 y tail -n 1 son probablemente los métodos más eficientes. Alternativamente, puede usar un simple fid.readline() para obtener la primera línea y fid.readlines()[-1], pero eso puede tomar demasiada memoria.

Esta es mi solución, compatible también con Python3. También gestiona casos fronterizos, pero no admite utf-16:

def tail(filepath):
    """
    @author Marco Sulla ([email protected])
    @date May 31, 2016
    """

    try:
        filepath.is_file
        fp = str(filepath)
    except AttributeError:
        fp = filepath

    with open(fp, "rb") as f:
        size = os.stat(fp).st_size
        start_pos = 0 if size - 1 < 0 else size - 1

        if start_pos != 0:
            f.seek(start_pos)
            char = f.read(1)

            if char == b"\n":
                start_pos -= 1
                f.seek(start_pos)

            if start_pos == 0:
                f.seek(start_pos)
            else:
                char = ""

                for pos in range(start_pos, -1, -1):
                    f.seek(pos)

                    char = f.read(1)

                    if char == b"\n":
                        break

        return f.readline()

Es emitido por La respuesta de Traspas y el comentario de otro interlocutor.

Primero abra el archivo en modo de lectura.Luego use el método readlines () para leer línea por línea.Todas las líneas almacenadas en una lista.Ahora puede usar list slices para obtener la primera y la última línea del archivo.

    a=open('file.txt','rb')
    lines = a.readlines()
    if lines:
        first_line = lines[:1]
        last_line = lines[-1]

w=open(file.txt, 'r')
print ('first line is : ',w.readline())
for line in w:  
    x= line
print ('last line is : ',x)
w.close()

El bucle for corre a través de las líneas y x obtiene la última línea en la iteración final.

with open("myfile.txt") as f:
    lines = f.readlines()
    first_row = lines[0]
    print first_row
    last_row = lines[-1]
    print last_row

Aquí hay una extensión de la respuesta de @Traspas que tiene lógica adicional para manejar el caso de esquina de un archivo que tiene solo una línea. Puede ser útil manejar este caso si desea leer repetidamente la última línea de un archivo que se actualiza continuamente. Sin esto, si intenta agarrar la última línea de un archivo que acaba de ser creado y tiene solo una línea, IOError: [Errno 22] Invalid argument se levantará.

def tail(filepath):
    with open(filepath, "rb") as f:
        first = f.readline()      # Read the first line.
        f.seek(-2, 2)             # Jump to the second last byte.
        while f.read(1) != b"\n": # Until EOL is found...
            try:
                f.seek(-2, 1)     # ...jump back the read byte plus one more.
            except IOError:
                f.seek(-1, 1)
                if f.tell() == 0:
                    break
        last = f.readline()       # Read last line.
    return last

Nadie mencionó usar reversed:

f=open(file,"r")
r=reversed(f.readlines())
last_line_of_file = r.next()

Obtener la primera línea es trivialmente fácil. Para la última línea, suponiendo que conoce un límite superior aproximado en la longitud de la línea, os.lseek alguna cantidad de SEEK_END encuentra el final de la penúltima línea y luego readline() la última línea.

with open(filename, "r") as f:
    first = f.readline()
    if f.read(1) == '':
        return first
    f.seek(-2, 2)  # Jump to the second last byte.
    while f.read(1) != b"\n":  # Until EOL is found...
        f.seek(-2, 1)  # ...jump back the read byte plus one more.
    last = f.readline()  # Read last line.
    return last

La respuesta anterior es una versión modificada de las respuestas anteriores que maneja el caso de que solo haya una línea en el archivo