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

J'ai un très gros fichier de 4 Go et lorsque j'essaie de le lire, mon ordinateur se bloque. Je veux donc le lire morceau par morceau et après le traitement de chaque morceau, stocker le morceau traité dans un autre fichier et lire le morceau suivant.

Y a-t-il une méthode pour yieldces pièces?

J'adorerais avoir une méthode paresseuse .

Pour écrire une fonction paresseuse, utilisez simplement yield:

def read_in_chunks(file_object, chunk_size=1024):
    """Lazy function (generator) to read a file piece by piece.
    Default chunk size: 1k."""
    while True:
        data = file_object.read(chunk_size)
        if not data:
            break
        yield data


with open('really_big_file.dat') as f:
    for piece in read_in_chunks(f):
        process_data(piece)

Une autre option serait d'utiliser iteret une fonction d'aide:

f = open('really_big_file.dat')
def read1k():
    return f.read(1024)

for piece in iter(read1k, ''):
    process_data(piece)

Si le fichier est basé sur des lignes, l'objet fichier est déjà un générateur de lignes paresseux:

for line in open('really_big_file.dat'):
    process_data(line)

Si votre ordinateur, votre système d'exploitation et python sont en 64 bits , vous pouvez utiliser le module mmap pour mapper le contenu du fichier en mémoire et y accéder avec des index 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, votre système d'exploitation ou python sont 32 bits , alors le mappage de gros fichiers peut réserver de grandes parties de votre espace d'adressage et affamer votre programme de mémoire.

file.readlines() prend un argument de taille facultative qui se rapproche du nombre de lignes lues dans les lignes retournées.

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)

Il existe déjà de nombreuses bonnes réponses, mais si tout votre fichier se trouve sur une seule ligne et que vous souhaitez toujours traiter les "lignes" (par opposition aux blocs de taille fixe), ces réponses ne vous seront d'aucune aide.

99% du temps, il est possible de traiter les fichiers ligne par ligne. Ensuite, comme suggéré dans cette réponse , vous pouvez utiliser l'objet fichier lui-même comme générateur paresseux:

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

Cependant, j'ai rencontré une fois un très gros fichier (presque) simple, où le séparateur de lignes n'était en fait pas '\n'mais '|'.

• La lecture ligne par ligne n'était pas une option, mais j'avais encore besoin de la traiter ligne par ligne.
• La conversion '|'en '\n'avant le traitement était également hors de question, car certains champs de ce csv contenaient '\n'(saisie utilisateur en texte libre).
• L'utilisation de la bibliothèque csv a également été exclue car le fait que, au moins dans les premières versions de la bibliothèque, il est codé en dur pour lire l'entrée ligne par ligne .

Pour ce genre de situations, j'ai créé l'extrait de code 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)
    """
    curr_row = ''
    while True:
        chunk = f.read(chunksize)
        if chunk == '': # End of file
            yield curr_row
            break
        while True:
            i = chunk.find(sep)
            if i == -1:
                break
            yield curr_row + chunk[:i]
            curr_row = ''
            chunk = chunk[i+1:]
        curr_row += chunk

J'ai pu l'utiliser avec succès pour résoudre mon problème. Il a été largement testé, avec différentes tailles de morceaux.

Suite de tests, pour ceux qui veulent se convaincre.

test_file = 'test_file'

def cleanup(func):
    def wrapper(*args, **kwargs):
        func(*args, **kwargs)
        os.unlink(test_file)
    return wrapper

@cleanup
def test_empty(chunksize=1024):
    with open(test_file, 'w') as f:
        f.write('')
    with open(test_file) as f:
        assert len(list(rows(f, chunksize=chunksize))) == 1

@cleanup
def test_1_char_2_rows(chunksize=1024):
    with open(test_file, 'w') as f:
        f.write('|')
    with open(test_file) as f:
        assert len(list(rows(f, chunksize=chunksize))) == 2

@cleanup
def test_1_char(chunksize=1024):
    with open(test_file, 'w') as f:
        f.write('a')
    with open(test_file) as f:
        assert len(list(rows(f, chunksize=chunksize))) == 1

@cleanup
def test_1025_chars_1_row(chunksize=1024):
    with open(test_file, 'w') as f:
        for i in range(1025):
            f.write('a')
    with open(test_file) as f:
        assert len(list(rows(f, chunksize=chunksize))) == 1

@cleanup
def test_1024_chars_2_rows(chunksize=1024):
    with open(test_file, 'w') as f:
        for i in range(1023):
            f.write('a')
        f.write('|')
    with open(test_file) as f:
        assert len(list(rows(f, chunksize=chunksize))) == 2

@cleanup
def test_1025_chars_1026_rows(chunksize=1024):
    with open(test_file, 'w') as f:
        for i in range(1025):
            f.write('|')
    with open(test_file) as f:
        assert len(list(rows(f, chunksize=chunksize))) == 1026

@cleanup
def test_2048_chars_2_rows(chunksize=1024):
    with open(test_file, 'w') as f:
        for i in range(1022):
            f.write('a')
        f.write('|')
        f.write('a')
        # -- end of 1st chunk --
        for i in range(1024):
            f.write('a')
        # -- end of 2nd chunk
    with open(test_file) as f:
        assert len(list(rows(f, chunksize=chunksize))) == 2

@cleanup
def test_2049_chars_2_rows(chunksize=1024):
    with open(test_file, 'w') as f:
        for i in range(1022):
            f.write('a')
        f.write('|')
        f.write('a')
        # -- end of 1st chunk --
        for i in range(1024):
            f.write('a')
        # -- end of 2nd chunk
        f.write('a')
    with open(test_file) as f:
        assert len(list(rows(f, chunksize=chunksize))) == 2

if __name__ == '__main__':
    for chunksize in [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]:
        test_empty(chunksize)
        test_1_char_2_rows(chunksize)
        test_1_char(chunksize)
        test_1025_chars_1_row(chunksize)
        test_1024_chars_2_rows(chunksize)
        test_1025_chars_1026_rows(chunksize)
        test_2048_chars_2_rows(chunksize)
        test_2049_chars_2_rows(chunksize)

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

Reportez-vous à la documentation officielle de python https://docs.python.org/zh-cn/3/library/functions.html?#iter

Peut-être que cette méthode est plus pythonique:

from functools import partial

"""A file object returned by open() is a iterator with
read method which could specify current read's block size"""
with open('mydata.db', 'r') as f_in:

    part_read = partial(f_in.read, 1024*1024)
    iterator = iter(part_read, b'')

    for index, block in enumerate(iterator, start=1):
        block = process_block(block)    # process block data
        with open(f'{index}.txt', 'w') as f_out:
            f_out.write(block)

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 faible réputation, mais la solution SilentGhosts devrait être beaucoup plus facile avec file.readlines ([sizehint])

méthodes de fichier python

edit: SilentGhost a raison, mais cela devrait être mieux que:

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

Je suis dans une situation quelque peu similaire. Il n'est pas clair si vous connaissez la taille des morceaux en octets; Je ne le fais 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. Cela fonctionne presque, sauf qu'il perd une ligne «entre» des morceaux.

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

Est-ce que l'astuce sans perdre de lignes, mais ça n'a pas l'air 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') 

open () retourne un objet fichier

puis 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)