পাইথনে জেনারেটর?

জেনারেটর PEP 255 এর সাথে প্রবর্তনের পর থেকে পাইথনের একটি গুরুত্বপূর্ণ অংশ।

পাইথনে জেনারেটর হল বিশেষ রুটিন যা লুপের পুনরাবৃত্তি আচরণ নিয়ন্ত্রণ করতে ব্যবহার করা যেতে পারে। একটি জেনারেটর একটি অ্যারে ফেরত একটি ফাংশন অনুরূপ. একটি জেনারেটরের পরামিতি রয়েছে, যাকে আমরা বলতে পারি এবং এটি সংখ্যাগুলির একটি ক্রম তৈরি করে। কিন্তু ফাংশনগুলির বিপরীতে, যা একটি সম্পূর্ণ অ্যারে প্রদান করে, একটি জেনারেটর একটি সময়ে একটি মান দেয় যার জন্য কম মেমরির প্রয়োজন হয়৷

"ফলন" কীওয়ার্ড সহ যেকোন পাইথন ফাংশনকে জেনারেটর বলা যেতে পারে। একটি সাধারণ পাইথন ফাংশন প্রথম লাইন থেকে এক্সিকিউশন শুরু করে এবং চলতে থাকে যতক্ষণ না আমরা একটি রিটার্ন স্টেটমেন্ট বা একটি ব্যতিক্রম বা ফাংশনের শেষ না পাই তবে, ফাংশন স্কোপের সময় তৈরি করা স্থানীয় ভেরিয়েবলগুলির যে কোনোটি ধ্বংস হয়ে যায় এবং আর অ্যাক্সেসযোগ্য নয়। জেনারেটরের ক্ষেত্রে যখন এটি একটি ফলন কীওয়ার্ডের মুখোমুখি হয় তখন ফাংশনের অবস্থা হিমায়িত হয় এবং জেনারেটরটিকে পুনরায় কল না করা পর্যন্ত সমস্ত ভেরিয়েবল মেমরিতে সংরক্ষণ করা হয়৷

আমরা একটি ইটারেটর অনুসারে জেনারেটর ব্যবহার করতে পারি বা "পরবর্তী" কীওয়ার্ড ব্যবহার করে স্পষ্টভাবে বলা যেতে পারে।

পাইথনে সাধারণত জেনারেটর:

def কীওয়ার্ড দিয়ে সংজ্ঞায়িত
ইল্ড কীওয়ার্ড ব্যবহার করুন
অনেকগুলো ইয়েলড কীওয়ার্ড থাকতে পারে।
একটি পুনরাবৃত্তিকারী প্রদান করে।

ইটারেটর সহ জেনারেটর

def generator_thr_iter():
   yield 'xyz'
   yield 246
   yield 40.50
for i in generator_thr_iter():
   print(i)

আউটপুট

xyz
246
40.5

পরবর্তী ব্যবহার করে জেনারেটর

def generator_thr_iter():
   yield 'xyz'
   yield 246
   yield 40.50
>>> g = generator_thr_iter()
>>> g.__next__()
'xyz'
>>> g.__next__()
246
>>> g.__next__()
40.5
>>> g.__next__()
Traceback (most recent call last):
File "<pyshell#39>", line 1, in <module>
g.__next__()
StopIteration

এ

আমরা জেনারেটরকে ভাবতে পারি যেগুলি একবারে একটির পরিবর্তে একের পর এক একাধিক আইটেম ফেরত দেয় এবং পরবর্তী আইটেমটি অনুরোধ না করা পর্যন্ত জেনারেটর ফাংশনটি বিরতি দেওয়া হয়৷

1 থেকে n পর্যন্ত সংখ্যার বর্গক্ষেত্র মুদ্রণের প্রোগ্রাম

বিবেচনা করুন আমরা 1 থেকে n পর্যন্ত সংখ্যার বর্গ গণনা করতে চাই, যেখানে n আসলেই বড় সংখ্যা, যেমন 'n' পর্যন্ত সংখ্যার একটি তালিকা তৈরি করা পুরো সিস্টেম মেমরির স্থান দখল করবে।

জেনারেটর ছাড়া, আমাদের পদ্ধতি এমন কিছু হবে -

>>> n= 200000000000
>>> number_list = range(1, n+1)
>>> for i in number_list:
   print(i*i)

উপরের পদ্ধতিটি অনেক সিস্টেম মেমরি গ্রাস করবে। আরও ভাল পদ্ধতি হবে, সংখ্যার তালিকা তৈরি না করেই সংখ্যার উপর পুনরাবৃত্তি করা যাতে সিস্টেম মেমরি দখল না হয়। এখানে জেনারেটরের ব্যবহার আসে।

একই জন্য আমাদের জেনারেটর প্রোগ্রাম হবে -

def num_generator(n):
num =1
while True:
   yield num
   if num == n:
      return
   else:
      num += 1
for i in num_generator(200000000000):
   print (i*i)

সুতরাং উপরের পদ্ধতিতে, যখন for লুপটি প্রথম শুরু করা হয় তখন num_generator বলা হয় এবং n =200000000000 এর মান মেমরিতে সংরক্ষিত হয় এবং num=1 ইনিশিয়ালাইজ করা হয় এবং while loop-এ প্রবেশ করা হয় যা চিরতরে লুপ হয়ে যায়। তারপর ফলন সংখ্যার সম্মুখীন হয়, এই সময়ে যখন লুপ হিমায়িত হয় এবং সমস্ত স্থানীয় ভেরিয়েবল মেমরিতে সংরক্ষণ করা হয়। যেহেতু num=1, yield num for loop-এ ফেরত দেওয়া হয় এবং I-কে বরাদ্দ করা হয়, যেখানে 1(i*i) প্রিন্ট করা হয় এবং num_generator-এ পরবর্তী কল করা হয়।

এখন এক্সিকিউশন শুরু হয় সেই জায়গা থেকে যেখানে এটি আগে হিমায়িত হয়েছিল, তাই এটি লাইন num ==n (1 ==200000000000) চালায়, যা মিথ্যা তাই num +=1 কার্যকর হয় যা num =2 এ আসে এবং যখন লুপ হয় আবার কার্যকর করা হয়েছে এবং প্রক্রিয়া চলতে থাকে।

অবশেষে যখন n=2000000000000 পর্যন্ত লুপ কার্যকর করা হয়, যখন 200000000000 পাওয়া যায় তখন পরবর্তী লাইন ‘num ==n’(200000000000 ==200000000000) এক্সিকিউট হয়, যেহেতু এটি excuted স্টেটমেন্ট সত্য।

সুতরাং যখন জেনারেটর একটি রিটার্ন স্টেটমেন্ট এক্সিকিউট করে বা ব্যতিক্রমের সম্মুখীন হয় বা জেনারেটরের শেষ প্রান্তে পৌঁছায় তখন "স্টপ আইটারেশন" এক্সেপশন উত্থাপিত হয় এবং এই মুহূর্তে ফর লুপ পুনরাবৃত্তি বন্ধ হয়ে যায়। সুতরাং উপরে আমরা 2000000000000 পর্যন্ত সংখ্যার বর্গক্ষেত্র প্রিন্ট করতে সক্ষম হয়েছি, সংখ্যার একটি বড় তালিকা তৈরি না করেই যা বড় সিস্টেম মেমরি দখল করবে।

উপরের পরিস্থিতি বিবেচনা করুন, আমরা আরও দক্ষ প্রোগ্রাম তৈরি করতে আমাদের দৈনন্দিন প্রোগ্রামিং অনুশীলনে জেনারেটর ব্যবহার করতে পারি।>