¿Método perezoso para leer archivos grandes en Python?

Tengo un archivo muy grande de 4GB y cuando intento leerlo, mi computadora se cuelga. Así que quiero leerlo pieza por pieza y después de procesar cada pieza, almacene la pieza procesada en otro archivo y lea la siguiente pieza.

¿Hay algún método para yieldestas piezas?

Me encantaría tener un método perezoso .

Para escribir una función perezosa, solo use 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)

Otra opción sería usar iteruna función auxiliar:

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

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

Si el archivo está basado en líneas, el objeto del archivo ya es un generador de líneas diferido:

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

Si su computadora, sistema operativo y python son de 64 bits , entonces puede usar el módulo mmap para mapear el contenido del archivo en la memoria y acceder a él con índices y sectores. Aquí un ejemplo de la documentación:

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 su computadora, sistema operativo o python son de 32 bits , entonces el mapeo de archivos grandes puede reservar grandes partes de su espacio de direcciones y privar a su programa de memoria.

file.readlines() toma un argumento de tamaño opcional que se aproxima al número de líneas leídas en las líneas devueltas.

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)

Ya hay muchas buenas respuestas, pero si su archivo completo está en una sola línea y aún desea procesar "filas" (en lugar de bloques de tamaño fijo), estas respuestas no lo ayudarán.

El 99% del tiempo, es posible procesar archivos línea por línea. Luego, como se sugiere en esta respuesta , puede usar el objeto de archivo en sí mismo como generador diferido:

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

Sin embargo, una vez me encontré con un archivo muy, muy grande (casi) de una sola línea, donde el separador de filas no era '\n'sino '|'.

• Leer línea por línea no era una opción, pero aún necesitaba procesarlo fila por fila.
• La conversión '|'a '\n'antes del procesamiento también estaba fuera de discusión, porque algunos de los campos de este csv contenían '\n'(entrada del usuario de texto libre).
• El uso de la biblioteca csv también se descartó porque el hecho de que, al menos en las primeras versiones de la lib, está codificado para leer la entrada línea por línea .

Para este tipo de situaciones, creé el siguiente fragmento:

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

Pude usarlo con éxito para resolver mi problema. Ha sido ampliamente probado, con varios tamaños de trozos.

Test suite, para aquellos que quieran convencerse a sí mismos.

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

ACTUALIZACIÓN: El enfoque se explica mejor en https://stackoverflow.com/a/4566523/38592

Consulte la documentación oficial de Python https://docs.python.org/zh-cn/3/library/functions.html?#iter

Quizás este método sea más pitónico:

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)

Creo que podemos escribir así:

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)

No puedo comentar debido a mi baja reputación, pero la solución SilentGhosts debería ser mucho más fácil con file.readlines ([sizehint])

métodos de archivo de Python

editar: SilentGhost tiene razón, pero esto debería ser mejor que:

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

Estoy en una situación algo similar. No está claro si conoce el tamaño del fragmento en bytes; Usualmente no, pero se conoce la cantidad de registros (líneas) que se requiere:

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

Actualización : Gracias nosklo. Esto es lo que quise decir. Casi funciona, excepto que pierde una línea 'entre' trozos.

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

¿El truco sin perder ninguna línea, pero no se ve muy bien?

Para procesar línea por línea, esta es una solución elegante:

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

Mientras no haya líneas en blanco.

Puedes usar el siguiente código.

file_obj = open('big_file') 

open () devuelve un objeto de archivo

luego use os.stat para obtener el tamaño

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

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