मेरे पास एक बहुत बड़ी फाइल 4GB है और जब मैं इसे पढ़ने की कोशिश करता हूं तो मेरा कंप्यूटर हैंग हो जाता है। इसलिए मैं इसे टुकड़े से पढ़ना चाहता हूं और प्रत्येक टुकड़े को संसाधित करने के बाद संसाधित टुकड़े को दूसरी फ़ाइल में संग्रहीत करता हूं और अगले टुकड़े को पढ़ता हूं।
क्या yieldइन टुकड़ों की कोई विधि है ?
मुझे एक आलसी तरीका पसंद आएगा ।
जवाबों:
एक आलसी फ़ंक्शन लिखने के लिए, बस उपयोग करें 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)एक अन्य विकल्प का उपयोग करना iterऔर एक सहायक कार्य करना होगा:
f = open('really_big_file.dat')
def read1k():
return f.read(1024)
for piece in iter(read1k, ''):
process_data(piece)यदि फ़ाइल लाइन-आधारित है, तो फ़ाइल ऑब्जेक्ट पहले से ही लाइनों का एक आलसी जनरेटर है:
for line in open('really_big_file.dat'):
process_data(line)rb@Tal Weiss के रूप में गुम ; और एक file.close()कथन याद आ रहा है ( with open('really_big_file.dat', 'rb') as f:उसी को पूरा करने के लिए उपयोग किया जा सकता है ; एक और संक्षिप्त कार्यान्वयन के लिए यहां
'rb'है नहीं याद आ रही।
'b'अपने डेटा जाएगा बहुत संभावना दूषित हो । डॉक्स से -Python on Windows makes a distinction between text and binary files; [...] it’ll corrupt binary data like that in JPEG or EXE files. Be very careful to use binary mode when reading and writing such files.
यदि आपका कंप्यूटर, OS और अजगर 64-बिट हैं , तो आप फ़ाइल की सामग्री को मेमोरी में मैप करने और इसे सूचक और स्लाइस के साथ एक्सेस करने के लिए mmap मॉड्यूल का उपयोग कर सकते हैं । यहाँ प्रलेखन से एक उदाहरण है:
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()यदि या तो आपका कंप्यूटर, OS या अजगर 32-बिट है , तो mmap-ing बड़ी फाइलें आपके एड्रेस स्पेस के बड़े हिस्से को आरक्षित कर सकती हैं और आपके मेमोरी के प्रोग्राम को भूखा कर सकती हैं ।
file.readlines() एक वैकल्पिक आकार के तर्क में लेता है जो लाइनों की संख्या को पढ़ता है जो वापस लौटी लाइनों में पढ़ता है।
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).read()नहीं करने की सलाह दूंगा .readlines()। यदि फ़ाइल बाइनरी है तो इसमें लाइन ब्रेक नहीं है।
पहले से ही कई अच्छे उत्तर हैं, लेकिन अगर आपकी पूरी फ़ाइल एक ही पंक्ति में है और आप अभी भी "पंक्तियों" को संसाधित करना चाहते हैं (जैसा कि निश्चित आकार के ब्लॉक के विपरीत है), ये उत्तर आपकी मदद नहीं करेंगे।
99% समय, फाइलों की लाइन को लाइन से प्रोसेस करना संभव है। फिर, जैसा कि इस उत्तर में सुझाया गया है , आप फ़ाइल ऑब्जेक्ट को आलसी जनरेटर के रूप में उपयोग कर सकते हैं:
with open('big.csv') as f:
for line in f:
process(line)हालांकि, मैं एक बार एक बहुत ही बहुत बड़ा (लगभग) एक पंक्ति फ़ाइल में भाग है, जहां पंक्ति विभाजक वास्तव में था नहीं '\n'लेकिन '|'।
'|'से '\n'पहले परिवर्तित करना भी सवाल से बाहर था, क्योंकि इस csv के कुछ क्षेत्र निहित थे'\n' (मुक्त पाठ उपयोगकर्ता इनपुट) ।इस तरह की स्थितियों के लिए, मैंने निम्नलिखित स्निपेट बनाया:
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मैं अपनी समस्या को हल करने के लिए इसका सफलतापूर्वक उपयोग करने में सक्षम था। यह बड़े पैमाने पर विभिन्न चंक आकारों के साथ परीक्षण किया गया है।
टेस्ट सूट, उन लोगों के लिए जो खुद को मनाना चाहते हैं।
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अद्यतन: दृष्टिकोण को https://stackoverflow.com/a/4566523/38592 में सबसे अच्छा समझाया गया है
अजगर के आधिकारिक दस्तावेज देखें https://docs.python.org/zh-cn/3/library/functions.html?#iter
हो सकता है कि यह विधि अधिक पाइथोनिक हो:
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)मुझे लगता है कि हम इस तरह लिख सकते हैं:
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)मुझे अपनी कम प्रतिष्ठा के कारण टिप्पणी करने की अनुमति नहीं है, लेकिन फाइल-ट्रेडलाइन ([sizehint]) के साथ साइलेंटगॉस्ट्स समाधान बहुत आसान होना चाहिए
संपादित करें: साइलेंटगॉस्ट सही है, लेकिन इससे बेहतर होना चाहिए:
s = ""
for i in xrange(100):
s += file.next()मैं कुछ इसी तरह की स्थिति में हूं। यह स्पष्ट नहीं है कि आप बाइट्स में चंक आकार जानते हैं; मैं आमतौर पर नहीं, लेकिन रिकॉर्ड की संख्या (लाइनों) की आवश्यकता है कि जाना जाता है:
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))]अद्यतन : धन्यवाद nosklo। यहाँ मेरा मतलब है। यह लगभग काम करता है, सिवाय इसके कि यह 'चूजों' के बीच एक लाइन खो देता है।
chunk = [next(gen) for i in range(lines_required)]क्या ट्रिक w / o किसी भी लाइन को खोती है, लेकिन यह बहुत अच्छी नहीं लगती है।
लाइन से लाइन को संसाधित करने के लिए, यह एक सुरुचिपूर्ण समाधान है:
def stream_lines(file_name):
file = open(file_name)
while True:
line = file.readline()
if not line:
file.close()
break
yield lineजब तक कोई खाली लाइनें नहीं हैं।
openपहले से ही आपको देता है उसके बराबर धीमा है । एक फ़ाइल पहले से ही इसकी तर्ज पर एक पुनरावृत्ति है।
आप निम्नलिखित कोड का उपयोग कर सकते हैं।
file_obj = open('big_file') खुला () फ़ाइल ऑब्जेक्ट लौटाता है
फिर आकार पाने के लिए os.stat का उपयोग करें
file_size = os.stat('big_file').st_size
for i in range( file_size/1024):
print file_obj.read(1024)
f = open('really_big_file.dat')सिर्फ एक संकेतक है बिना किसी मेमोरी खपत के? (मेरा मतलब है कि खपत की गई मेमोरी फ़ाइल आकार की परवाह किए बिना समान है?) अगर मैं f.readline () के बजाय urllib.readline () का उपयोग करूं तो यह प्रदर्शन को कैसे प्रभावित करेगा?