Comment lire fichier N lignes à la fois en Python?

J'ai besoin de lire un gros fichier en lecture à N lignes à la fois, jusqu'à ce que les expressions du FOLKLORE. Quel est le moyen le plus efficace de le faire en Python? Quelque chose comme:

with open(filename, 'r') as infile:
    while not EOF:
        lines = [get next N lines]
        process(lines)

Rapide très bête question: est-ce que vous allez faire à l'intérieur de process(lines) travail si N == 1? Si pas, vous avez un problème avec une seule ligne dans la dernière tas. Si cela fonctionne avec N == 1, alors il serait beaucoup plus efficace que de faire seulement for line in infile: work_on(line).

InformationsquelleAutor madprogrammer | 2011-04-29

33

Une solution serait une compréhension de liste et la tranche de l'opérateur:
```
with open(filename, 'r') as infile:
    lines = [line for line in infile][:N]
```
Après cette lines est un tuple de lignes. Cependant, ce serait de charger l'intégralité du fichier en mémoire. Si vous ne voulez pas que cela (c'est à dire si le fichier est peut-être vraiment grand) il y a une autre solution à l'aide d'un générateur d'expression et islice de la itertools package:
```
from itertools import islice
with open(filename, 'r') as infile:
    lines_gen = islice(infile, N)
```
lines_gen est un générateur de l'objet, qui vous donne chaque ligne du fichier, et peut être utilisé dans une boucle comme ceci:
```
for line in lines_gen:
    print line
```
Deux solutions vous donner jusqu'à N lignes (ou moins, si le fichier n'a pas beaucoup d').
- Simplifiée à lines = islice(infile, N)
- Remarque: il lit les N lignes et des arrêts. Pour lire le prochain N lignes, vous pouvez envelopper votre code dans une boucle (jusqu'à ce que EOF) ou utiliser le mérou recette comme indiqué dans ma réponse.
- Cette solution ne répond pas à la question "comment puis-je lire les N lignes à la fois jusqu'à ce que les expressions du FOLKLORE". Il ne va pas plus loin que de fournir un mécanisme pour la lecture de N lignes à un moment, mais ensuite seulement témoigne de lecture N lignes une à une (pour la boucle à la fin).
InformationsquelleAutor Martin Thurau
11

Un objet de fichier est un itérateur sur les lignes en Python. Pour parcourir le fichier N lignes à la fois, vous pouvez utiliser loches() itertools' recette (voir Qu'est-ce que la plupart des “pythonic” chemin à parcourir une liste en morceaux?):
```
#!/usr/bin/env python2

from itertools import izip_longest

def grouper(iterable, n, fillvalue=None):
    args = [iter(iterable)] * n
    return izip_longest(*args, fillvalue=fillvalue)
```
Exemple
```
with open(filename) as f:
     for lines in grouper(f, N, ''):
         assert len(lines) == N
         # process N lines here
```
- J. Chase: 1 - fichier binaire est un itérateur sur b'\n'-lignes 2- itertools.izip_longest n'est pas supprimé en Python 3, il est renommé pour itertools.zip_longest
- Je voulais surtout mettre à jour le lien, étant donné que le code ne fonctionne que comme écrit. en Python 2, et non précisées des liens vers d'docs.python.org semblent par défaut à 3 au lieu de 2 actuellement. 1: c'est Vrai. 2: On peut se demander qui de la zip / izip fonctions a "enlevé" en Python 3 --- le code de l'un est absent, le nom de l'autre.
- Je n'ai pas l'esprit de la modifier. Le commentaire est à votre avantage. itertools.zip_longest() en Python 3 et itertools.izip_longest() en Python 2 sont sur le même objet.
InformationsquelleAutor jfs

Ce code fonctionnera avec n'importe quel nombre de lignes dans le fichier et tout N. Si vous avez 1100 lines dans le fichier et N = 200, vous obtiendrez 5 fois pour traiter des morceaux de 200 lignes et une fois avec 100 lignes.

with open(filename, 'r') as infile:
    lines = []
    for line in infile:
        lines.append(line)
        if len(lines) >= N:
            process(lines)
            lines = []
    if len(lines) > 0:
        process(lines)

InformationsquelleAutor Anatolij

peut-être:

for x in range(N):
  lines.append(f.readline())

InformationsquelleAutor yurib

1

Je pense que vous devriez être à l'aide de morceaux au lieu de spécifier le nombre de lignes à lire. Il rend votre code plus robuste et générique. Même si les lignes sont de gros, à l'aide de morceau de charger uniquement la quantité attribuée de données en mémoire.

Reportez-vous à cette lien

InformationsquelleAutor Konstant
0

Comment sur une boucle for?
```
with open(filename, 'r') as infile:
    while not EOF:
        lines = []
        for i in range(next N lines):
            lines.append(infile.readline())
        process(lines)
```
- qu'est-ce que cette syntaxe "les N prochaines lignes", de pseudo? python noob ici
- c'est juste le nombre de lignes que vous le souhaitez. Par exemple 7 lignes serait for i in range(7)
InformationsquelleAutor Spencer Rathbun
0

Vous pourriez avoir à faire quelque chose d'aussi simple que:
```
lines = [infile.readline() for _ in range(N)]
```
Mise à jour après les commentaires:
```
lines = [line for line in [infile.readline() for _ in range(N)] if len(line) ]
```
- Votre code ont aucune vérification sur nombre de lignes. Par exemple, si la ligne de couns est plus petit que N - vous obtiendrez une erreur.
- Vous avez raison, il n'y a pas de vérification - mais vous venez de passer les cordes à vide après EOF et pas d'erreur.
- Vous aurez besoin de vérifier chaque élément dans process(), si ce n'est les frais généraux.
InformationsquelleAutor quamrana

Si vous pouvez lire le dossier complet à l'avance;

infile = open(filename, 'r').readlines()
my_block = [line.strip() for line in infile[:N]]
cur_pos = 0
while my_block:
    print (my_block)
    cur_pos +=1
    my_block = [line.strip() for line in infile[cur_pos*N:(cur_pos +1)*N]]

InformationsquelleAutor ChrisEisenhart

0

J'avais besoin de lire dans le n lignes à la fois à partir de fichiers pour les très gros fichiers (~1 TO) et a écrit un package simple pour ce faire. Si vous pip install bigread, vous pouvez le faire:
```
from bigread import Reader

stream = Reader(file='large.txt', block_size=10) 
for i in stream:
  print(i)
```
block_size est le nombre de lignes à lire à la fois.

InformationsquelleAutor duhaime

Je cherchais une réponse à la même question, mais n'aime pas vraiment tout de la proposition de trucs plus tôt, donc j'ai fini par écrire un peu laid chose qui fait exactement ce que je voulais ~~sans utiliser étrange bibliothèques~~.

def test(filename, N):
    with open(filename, 'r') as infile:
        lines = []
        for line in infile:
            line = line.strip()
            if len(lines) < N-1:
                lines.append(line)
            else:
                lines.append(line)
                res = lines
                lines = []
            yield res
        else:
            if len(lines) != 0:
                yield lines

itertools est en Python standard library
juste assez, itertools est très bien, je ne me sentais pas à l'aise sur islice.

InformationsquelleAutor Haromn

Vous devez vous connecter pour publier un commentaire.

Exemple