Méthode paresseuse pour lire un gros fichier en Python?

si votre ordinateur, OS et python sont 64 bits , alors vous pouvez utiliser le module mmap pour mapper le contenu du fichier en mémoire et y accéder avec des indices et des tranches. Voici un exemple tiré de la documentation:

import mmap
with open("hello.txt", "r+") as f:
    # memory-map the file, size 0 means whole file
    map = mmap.mmap(f.fileno(), 0)
    # read content via standard file methods
    print map.readline()  # prints "Hello Python!"
    # read content via slice notation
    print map[:5]  # prints "Hello"
    # update content using slice notation;
    # note that new content must have same size
    map[6:] = " world!\n"
    # ... and read again using standard file methods
    map.seek(0)
    print map.readline()  # prints "Hello  world!"
    # close the map
    map.close()

si votre ordinateur, OS ou python sont 32 bits , alors mmap-ing grands fichiers peuvent réserver de grandes parties de votre espace d'adresse et starve votre programme de la mémoire.

bigfile = open('bigfilename','r')
tmp_lines = bigfile.readlines(BUF_SIZE)
while tmp_lines:
    process([line for line in tmp_lines])
    tmp_lines = bigfile.readlines(BUF_SIZE)

regardez ce post sur Neopythonic : "Trier un million d'entiers 32 bits en 2MB de RAM en utilisant Python"

il y a déjà beaucoup de bonnes réponses, mais j'ai rencontré un problème similaire récemment et la solution dont j'avais besoin n'est pas listée ici, donc j'ai pensé que je pourrais compléter ce fil.

80% du temps, je dois lire les fichiers ligne par ligne. Ensuite, comme suggéré dans ce réponse , vous voulez utiliser l'objet de fichier lui - même comme générateur paresseux:

with open('big.csv') as f:
    for line in f:
        process(line)

cependant, j'ai récemment rencontré une très grande (presque) ligne simple csv, où le séparateur de rangée était en fait pas '\n' mais '|' .

• Lire ligne par ligne n'était pas une option, mais j'avais encore besoin de le traiter ligne par ligne.
• conversion '|' en '\n' avant traitement était également hors de question, parce que certains des champs de cette csv contenait '\n' (Entrée libre de l'utilisateur de texte).
• utilisant la bibliothèque csv a également été exclue parce que le fait que, à moins dans les premières versions de la lib, il est difficile de lire la ligne d'entrée par la ligne .

j'ai trouvé l'extrait suivant:

def rows(f, chunksize=1024, sep='|'):
    """
    Read a file where the row separator is '|' lazily.

    Usage:

    >>> with open('big.csv') as f:
    >>>     for r in rows(f):
    >>>         process(row)
    """
    incomplete_row = None
    while True:
        chunk = f.read(chunksize)
        if not chunk: # End of file
            if incomplete_row is not None:
                yield incomplete_row
                break
        # Split the chunk as long as possible
        while True:
            i = chunk.find(sep)
            if i == -1:
                break
            # If there is an incomplete row waiting to be yielded,
            # prepend it and set it back to None
            if incomplete_row is not None:
                yield incomplete_row + chunk[:i]
                incomplete_row = None
            else:
                yield chunk[:i]
            chunk = chunk[i+1:]
        # If the chunk contained no separator, it needs to be appended to
        # the current incomplete row.
        if incomplete_row is not None:
            incomplete_row += chunk
        else:
            incomplete_row = chunk

Je l'ai testé avec succès sur de grands fichiers et avec différentes tailles de morceaux (j'ai même essayé un chunksize de 1 octet, juste pour s'assurer que l'algorithme ne dépend pas de la taille).

f = ... # file-like object, i.e. supporting read(size) function and 
        # returning empty string '' when there is nothing to read

def chunked(file, chunk_size):
    return iter(lambda: file.read(chunk_size), '')

for data in chunked(f, 65536):
    # process the data

mise à jour: l'approche est mieux expliquée dans https://stackoverflow.com/a/4566523/38592

je pense que nous pouvons écrire comme ceci:

def read_file(path, block_size=1024): 
    with open(path, 'rb') as f: 
        while True: 
            piece = f.read(block_size) 
            if piece: 
                yield piece 
            else: 
                return

for piece in read_file(path):
    process_piece(piece)

Je ne suis pas autorisé à commenter en raison de ma mauvaise réputation, mais Solution SilentGhosts devrait être beaucoup plus facile avec le fichier.readlines ([sizehint])

fichier python méthodes

edit: SilentGhost est à droite, mais cela devrait être mieux que:

s = "" 
for i in xrange(100): 
   s += file.next()

je suis dans une situation un peu similaire. Il n'est pas clair si vous connaissez la taille des morceaux en octets; Je ne le sais généralement pas, mais le nombre d'enregistrements (lignes) requis est connu:

def get_line():
     with open('4gb_file') as file:
         for i in file:
             yield i

lines_required = 100
gen = get_line()
chunk = [i for i, j in zip(gen, range(lines_required))]

mise à Jour : Merci nosklo. Voici ce que je voulais dire. Il fonctionne presque, sauf qu'il perd une ligne entre deux morceaux.

chunk = [next(gen) for i in range(lines_required)]

fait le tour sans perdre aucune ligne, mais il ne semble pas très agréable.

Pour traiter ligne par ligne, c'est une solution élégante:

  def stream_lines(file_name):
    file = open(file_name)
    while True:
      line = file.readline()
      if not line:
        file.close()
        break
      yield line

tant Qu'il n'y a pas de lignes vides.

vous pouvez utiliser le code suivant.

file_obj = open('big_file') 

ouvrir () retourne un objet de fichier

alors utilisez os.stat pour obtenir la taille

file_size = os.stat('big_file').st_size

for i in range( file_size/1024):
    print file_obj.read(1024)