Lire les N premières lignes d'un fichier en python

N=10
f=open("file")
for i in range(N):
    line=f.next().strip()
    print line
f.close()

Si vous voulez lire les premières lignes rapidement et que vous ne vous souciez pas des performances, vous pouvez utiliser .readlines() qui renvoie l'objet list, puis découper la liste.

Par exemple pour les 5 premières lignes:

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

Remarque:, l'ensemble du fichier est en lecture est donc pas la meilleure du point de vue des performances, mais il est facile à utiliser, rapide à écrire et facile à retenir donc si vous voulez juste effectuer un calcul ponctuel est très pratique

print firstNlines

Il n'y a pas de méthode spécifique pour lire le nombre de lignes exposées par fichier objet.

Je suppose que le moyen le plus simple serait de suivre:

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

Basé sur gnibbler top voted answer (Nov 20 ' 09 à 0: 27): cette classe ajoute la méthode head() et tail() à l'objet file.

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:]

Utilisation:

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

Ce que je fais est d'appeler les N lignes en utilisant pandas. Je pense que la performance n'est pas la meilleure, mais par exemple si N=1000:

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

Les deux façons les plus intuitives de le faire seraient:

1. Itérer sur le fichier ligne par ligne, et break après N lignes.

2. Itérer sur le fichier ligne par ligne en utilisant la méthode next() N fois. (Ceci est essentiellement juste une syntaxe différente pour ce que fait la réponse supérieure.)

Voici le code:

# 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 ligne de fond est, tant que vous n'utilisez pas readlines() ou enumerate ing le fichier entier dans la mémoire, vous avez beaucoup d'options.

À partir de python 2.6, vous pouvez profiter de fonctions plus sophistiquées dans le clase de base IO. Ainsi, la réponse la mieux notée ci-dessus peut être réécrite comme:

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

(vous n'avez pas à vous soucier de votre fichier ayant moins de n Lignes car aucune exception StopIteration n'est levée.)

Si vous voulez quelque chose qui évidemment (sans chercher des choses ésotériques dans les manuels) fonctionne sans importations et try / except et fonctionne sur une gamme équitable de Python 2.X versions (2.2 à 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)

Façon la plus convinient sur mon propre:

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

Solution basée sur Liste compréhension La fonction open() prend en charge une interface d'itération. L'enumerate () couvre les tuples open() et return (index, item), puis nous vérifions que nous sommes dans une plage acceptée (si i

Profitez du Python. ;)

Pour les 5 premières lignes, faites simplement:

N=5
with open("data_file", "r") as file:
    for i in range(N):
       print file.next()

Si vous avez un très gros fichier, et en supposant que vous voulez que la sortie soit un tableau numpy, en utilisant np.genfromtxt va geler votre ordinateur. C'est tellement mieux dans mon expérience:

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

#!/usr/bin/python

import subprocess

p = subprocess.Popen(["tail", "-n 3", "passlist"], stdout=subprocess.PIPE)

output, err = p.communicate()

print  output

Cette méthode a fonctionné pour moi