আমার কাছে খুব বড় ফাইল 4 জিবি রয়েছে এবং আমি যখন এটি পড়ার চেষ্টা করি তখন আমার কম্পিউটার স্তব্ধ হয়ে যায়। সুতরাং আমি এটি টুকরো টুকরো করে পড়তে চাই এবং প্রতিটি টুকরো প্রক্রিয়া করার পরে প্রক্রিয়াজাত টুকরোটি অন্য একটি ফাইলে সংরক্ষণ করুন এবং পরবর্তী অংশটি পড়ুন read
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@ ট্যাল ওয়েইস উল্লিখিত হিসাবে অনুপস্থিত ; এবং একটি 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.
যদি আপনার কম্পিউটার, ওএস এবং পাইথন 64৪-বিট হয় , তবে আপনি ফাইলের বিষয়বস্তুগুলিকে মেমরিতে ম্যাপ করতে এবং সূচক এবং টুকরো দিয়ে এটি অ্যাক্সেস করতে এমএমএপ মডিউলটি ব্যবহার করতে পারেন । এখানে ডকুমেন্টেশন থেকে একটি উদাহরণ:
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()যদি আপনার কম্পিউটার, ওএস বা পাইথন 32-বিট হয় , তবে এমএমএপ-ইন বড় ফাইলগুলি আপনার ঠিকানার জায়গার বড় অংশ সংরক্ষণ করতে পারে এবং আপনার মেমরির প্রোগ্রামটি অনাহারে রাখতে পারে ।
file.readlines() একটি alচ্ছিক আকারের আর্গুমেন্ট গ্রহণ করে যা প্রত্যাবর্তিত রেখাগুলিতে পাঠানো লাইনের সংখ্যার সমান করে।
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/function.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)আমার কম সুনামের কারণে আমাকে মন্তব্য করার অনুমতি নেই তবে সাইলেন্টহোস্টস সমাধান ফাইল.রেডলাইনগুলির সাথে খুব সহজ হওয়া উচিত ([সাইজহিন্ট])
সম্পাদনা করুন: সাইলেন্টগোস্ট সঠিক, তবে এটি এর থেকে ভাল হওয়া উচিত:
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)]কৌতুকটি কোনও লাইন হারাতে পারে তবে এটি খুব সুন্দর দেখাচ্ছে না।
লাইনে লাইন প্রক্রিয়াজাত করতে, এটি একটি মার্জিত সমাধান:
def stream_lines(file_name):
file = open(file_name)
while True:
line = file.readline()
if not line:
file.close()
break
yield lineযতক্ষণ না কোনও ফাঁকা লাইন নেই।
openইতিমধ্যে আপনাকে যা দেবে তার চেয়ে মাত্রাতিরিক্ত জটিল, কম শক্তিশালী এবং ধীর সমতুল্য । একটি ফাইল ইতিমধ্যে তার রেখাগুলিতে একটি পুনরাবৃত্তি।
f = open('really_big_file.dat')কোনও পয়েন্টার ছাড়া কোনও স্মৃতি ব্যয় না করে? (আমি বোঝাতে চাইছি যে মেমরিটি ফাইলের আকার নির্বিশেষে একই রকম?) আমি যদি f.readline () এর পরিবর্তে urllib.readline () ব্যবহার করি তবে এটি কীভাবে পারফরম্যান্সে প্রভাব ফেলবে?