Metode Malas untuk Membaca File Besar dengan Python?

Saya memiliki file 4GB yang sangat besar dan ketika saya mencoba membacanya komputer saya hang. Jadi saya ingin membacanya sepotong demi sepotong dan setelah memproses masing-masing menyimpan potongan diproses ke file lain dan membaca bagian selanjutnya.

Apakah ada metode untuk yield potongan-potongan ini?

Saya ingin sekali memiliki metode yang malas .

Untuk menulis fungsi malas, cukup gunakan 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)

Opsi lain adalah menggunakan iterdan fungsi pembantu:

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

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

Jika file berbasis baris, objek file sudah menjadi generator baris yang malas:

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

Jika komputer Anda, OS dan python adalah 64-bit , maka Anda dapat menggunakan modul mmap untuk memetakan isi file ke dalam memori dan mengaksesnya dengan indeks dan irisan. Berikut ini contoh dari dokumentasi:

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

Jika komputer, OS, atau python Anda 32-bit , maka mmap-ing file besar dapat memesan sebagian besar ruang alamat Anda dan membuat program Anda kelaparan .

file.readlines() mengambil argumen ukuran opsional yang mendekati jumlah baris yang dibaca di baris yang dikembalikan.

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)

Sudah ada banyak jawaban bagus, tetapi jika seluruh file Anda berada pada satu baris dan Anda masih ingin memproses "baris" (sebagai lawan dari blok ukuran tetap), jawaban ini tidak akan membantu Anda.

99% dari waktu, adalah mungkin untuk memproses file baris demi baris. Kemudian, seperti yang disarankan dalam jawaban ini , Anda bisa menggunakan objek file itu sendiri sebagai lazy generator:

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

Namun, saya pernah bertemu dengan file baris tunggal yang sangat besar (hampir), di mana pemisah baris sebenarnya tidak '\n'tetapi '|'.

• Membaca baris demi baris bukanlah pilihan, tetapi saya masih perlu memprosesnya baris demi baris.
• Konversi '|'ke '\n'sebelum pemrosesan juga keluar dari pertanyaan, karena beberapa bidang csv ini berisi '\n'(input pengguna teks gratis).
• Menggunakan perpustakaan csv juga dikesampingkan karena fakta bahwa, setidaknya dalam versi awal lib, hardcoded untuk membaca input baris demi baris .

Untuk situasi seperti ini, saya membuat cuplikan berikut:

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

Saya berhasil menggunakannya untuk menyelesaikan masalah saya. Ini telah diuji secara luas, dengan berbagai ukuran potongan.

Test suite, bagi mereka yang ingin meyakinkan diri mereka sendiri.

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

UPDATE: Pendekatan ini paling baik dijelaskan di https://stackoverflow.com/a/4566523/38592

Lihat dokumentasi resmi python, https://docs.python.org/zh-cn/3/library/functions.html?#iter

Mungkin metode ini lebih pythonic:

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)

Saya pikir kita bisa menulis seperti ini:

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)

saya tidak diperbolehkan berkomentar karena reputasi saya yang rendah, tetapi solusi SilentGhosts harus lebih mudah dengan file.readlines ([sizehint])

metode file python

sunting: SilentGhost benar, tetapi ini harus lebih baik daripada:

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

Saya dalam situasi yang agak mirip. Tidak jelas apakah Anda tahu ukuran chunk dalam byte; Saya biasanya tidak, tetapi jumlah catatan (baris) yang diperlukan diketahui:

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

Pembaruan : Terima kasih nosklo. Inilah yang saya maksud. Ini hampir berhasil, kecuali bahwa ia kehilangan garis 'antara' potongan.

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

Apakah triknya tanpa kehilangan garis, tetapi tidak terlihat bagus.

Untuk memproses baris demi baris, ini adalah solusi elegan:

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

Selama tidak ada garis kosong.

Anda dapat menggunakan kode berikut.

file_obj = open('big_file') 

open () mengembalikan objek file

lalu gunakan os.stat untuk mendapatkan ukuran

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

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