Lee las primeras N líneas de un archivo en python

Tenemos un gran archivo de datos sin procesar que nos gustaría recortar a un tamaño específico. Tengo experiencia en .net c #, sin embargo, me gustaría hacer esto en Python para simplificar las cosas y por interés.

¿Cómo haría para obtener las primeras N líneas de un archivo de texto en python? ¿Tendrá algún efecto el sistema operativo en uso en la implementación?

Python 2

with open("datafile") as myfile: head = [next(myfile) for x in xrange(N)] print head 

Python 3

 with open("datafile") as myfile: head = [next(myfile) for x in range(N)] print(head) 

Aquí hay otra manera (tanto Python 2 y 3)

 from itertools import islice with open("datafile") as myfile: head = list(islice(myfile, N)) print head 
 N = 10 file = open("file.txt", "a")#the a opens it in append mode for i in range(N): line = file.next().strip() print line file.close() 

Si desea leer las primeras líneas rápidamente y no le importa el rendimiento, puede usar .readlines() que devuelve el objeto de la lista y luego la divide.

Por ejemplo, para las primeras 5 líneas:

 with open("pathofmyfileandfileandname") as myfile: firstNlines=myfile.readlines()[0:5] #put here the interval you want 

Nota: todo el archivo se lee, por lo que no es el mejor desde el punto de vista del rendimiento, pero es fácil de usar, rápido de escribir y fácil de recordar, por lo que si desea realizar un cálculo único es muy conveniente

 print firstNlines 

Lo que hago es llamar a las líneas N usando pandas . Creo que el rendimiento no es el mejor, pero por ejemplo si N=1000 :

 import pandas as pd yourfile = pd.read('path/to/your/file.csv',nrows=1000) 

No hay un método específico para leer el número de líneas expuestas por objeto de archivo.

Supongo que la forma más fácil sería seguir:

 lines =[] with open(file_name) as f: lines.extend(f.readline() for i in xrange(N)) 

Basado en la respuesta más votada de gnibbler (20 de noviembre de 2009 a las 0:27): esta clase agrega el método head () y tail () al objeto de archivo.

 class File(file): def head(self, lines_2find=1): self.seek(0) #Rewind file return [self.next() for x in xrange(lines_2find)] def tail(self, lines_2find=1): self.seek(0, 2) #go to end of file bytes_in_file = self.tell() lines_found, total_bytes_scanned = 0, 0 while (lines_2find+1 > lines_found and bytes_in_file > total_bytes_scanned): byte_block = min(1024, bytes_in_file-total_bytes_scanned) self.seek(-(byte_block+total_bytes_scanned), 2) total_bytes_scanned += byte_block lines_found += self.read(1024).count('\n') self.seek(-total_bytes_scanned, 2) line_list = list(self.readlines()) return line_list[-lines_2find:] 

Uso:

 f = File('path/to/file', 'r') f.head(3) f.tail(3) 

Las dos formas más intuitivas de hacer esto serían:

  1. Iterar en el archivo línea por línea y break después de N líneas.

  2. Iterar en el archivo línea por línea usando el método next() N veces. (Esta es esencialmente una syntax diferente para lo que hace la respuesta principal).

Aquí está el código:

 # Method 1: with open("fileName", "r") as f: counter = 0 for line in f: print line counter += 1 if counter == N: break # Method 2: with open("fileName", "r") as f: for i in xrange(N): line = f.next() print line 

La conclusión es que, siempre que no use readlines() o que enumerate todo el archivo en la memoria, tiene muchas opciones.

forma más conveniente por mi cuenta:

 LINE_COUNT = 3 print [s for (i, s) in enumerate(open('test.txt')) if i < LINE_COUNT] 

Solución basada en la comprensión de lista La función open () admite una interfaz de iteración. La enumeración () cubre las tuplas abiertas () y de retorno (índice, elemento), luego verificamos que estamos dentro de un rango aceptado (si i

Disfruta del python. 😉

Si quieres algo que obviamente (sin buscar elementos esotéricos en los manuales) funciona sin importar y prueba / exceptúa y funciona en un rango razonable de versiones de Python 2.x (2.2 a 2.6):

 def headn(file_name, n): """Like *x head -N command""" result = [] nlines = 0 assert n >= 1 for line in open(file_name): result.append(line) nlines += 1 if nlines >= n: break return result if __name__ == "__main__": import sys rval = headn(sys.argv[1], int(sys.argv[2])) print rval print len(rval) 

A partir de Python 2.6, puede aprovechar funciones más sofisticadas en la clase de base IO. Por lo tanto, la respuesta mejor clasificada arriba puede ser reescrita como:

  with open("datafile") as myfile: head = myfile.readlines(N) print head 

(No tiene que preocuparse por que su archivo tenga menos de N líneas ya que no se lanza una excepción StopIteration).

Si tiene un archivo realmente grande, y suponiendo que desea que la salida sea una matriz numpy, el uso de np.genfromtxt congelará su computadora. Esto es mucho mejor en mi experiencia:

 def load_big_file(fname,maxrows): '''only works for well-formed text file of space-separated doubles''' rows = [] # unknown number of lines, so use list with open(fname) as f: j=0 for line in f: if j==maxrows: break else: line = [float(s) for s in line.split()] rows.append(np.array(line, dtype = np.double)) j+=1 return np.vstack(rows) # convert list of vectors to array 

Para las primeras 5 líneas, simplemente haz:

 N=5 with open("data_file", "r") as file: for i in range(N): print file.next() 
 #!/usr/bin/python import subprocess p = subprocess.Popen(["tail", "-n 3", "passlist"], stdout=subprocess.PIPE) output, err = p.communicate() print output 

Este método funcionó para mi