প্লেনের টিকিট

একটি generator হলো এমন একটি ফাংশন বা এক্সপ্রেশন, যা এক বিশেষ ধরনের ইটারেটর রিটার্ন করে, যাকে বলা হয় generator iterator। Generator-iterators হলো লেজি: এরা তাদের values মেমোরিতে জমা রাখে না, বরং দরকার হলে তাদের মান জেনারেট করে।

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

একটি জেনারেটর তৈরি করা

জেনারেটর তৈরি করা হয় অন্য লুপিং বা রিকার্সিভ ফাংশনের মতোই, তবে এতে একটি yield এক্সপ্রেশন লাগে, যা আমরা একটু পরে বিস্তারিত দেখব।

একটি উদাহরণ হলো এমন একটি ফাংশন, যা সংখ্যার একটি নির্দিষ্ট অ্যারে থেকে বর্গ রিটার্ন করে। বর্তমানে যেভাবে লেখা আছে, সেখানে কোনো মান রিটার্ন করার আগে সব ইনপুট প্রসেস করতে হয়:

>>> def squares(list_of_numbers):
...     squares = []
...     for number in list_of_numbers:
...         squares.append(number ** 2)
...     return squares

আপনি ওই ফাংশনটিকে এভাবে একটি জেনারেটরে রূপান্তর করতে পারেন:

>>> def squares_generator(list_of_numbers):
...     for number in list_of_numbers:
...         yield number ** 2

এর পেছনের যুক্তি হলো, যখন আপনার সব মান একসাথে তৈরি করার দরকার নেই, তখন আপনি জেনারেটর ব্যবহার করেন। এতে মেমোরি ও প্রসেসিং পাওয়ার বাঁচে, কারণ শুধু যে মানটি নিয়ে আপনি এই মুহূর্তে কাজ করছেন সেটিই হিসাব করা হয়।

একটি জেনারেটর ব্যবহার করা

পাইথনে বেশিরভাগ iterables-এর জায়গায় জেনারেটর ব্যবহার করা যায়। এর মধ্যে আছে সেইসব ফাংশন বা অবজেক্ট, যেগুলো আর্গুমেন্ট হিসেবে একটি iterable/iterator চায়।

squares_generator() জেনারেটরটি ব্যবহার করতে:

>>> squared_numbers = squares_generator([1, 2, 3, 4])

>>> for square in squared_numbers:
...     print(square)
...
1
4
9
16

একটি generator-এর ভেতরের মানও next() ফাংশনের মাধ্যমে তৈরি বা অ্যাক্সেস করা যায়। next() একটি জেনারেটর-ইটারেটর অবজেক্টের __next__() মেথড কল করে, কোডটিকে তার yield এক্সপ্রেশন পর্যন্ত "এগিয়ে নেয়" বা মূল্যায়ন করে, এরপর সেটি একটি মান "ইল্ড" বা রিটার্ন করে:

>>> squared_numbers = squares_generator([1, 2])

>>> next(squared_numbers)
1
>>> next(squared_numbers)
4

একটি generator-iterator সম্পূর্ণভাবে ব্যবহৃত হয়ে গেলে এবং রিটার্ন করার মতো আর কোনো মান না থাকলে, এটি একটি StopIteration এরর ছোড়ে।

>>> next(squared_numbers)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

yield এক্সপ্রেশন

yield এক্সপ্রেশন আর return এক্সপ্রেশনের সাথে বেশ মিল। return এক্সপ্রেশনের বিপরীতে, yield একটি নির্দিষ্ট বিন্দুতে কলারকে মান দিয়ে দেয়, আর বাকি মানগুলোর মূল্যায়ন বা রিটার্ন স্থগিত রাখে যতক্ষণ না সেগুলো চাওয়া হয়। yield মূল্যায়িত হলে, এটি যে ফাংশনের ভেতরে আছে তার এক্সিকিউশন থামিয়ে দেয় এবং সেই সময়ে ফাংশনের যেকোনো মান রিটার্ন করে। এরপর ফাংশনটি স্কোপে থেকে যায়, এবং __next__() কল করা হলে আবার yield-এর দেখা না পাওয়া পর্যন্ত এক্সিকিউশন চলতে থাকে।

>>> def infinite_sequence():
...     current_number = 0
...     while True:
...         yield current_number
...         current_number += 1

>>> lets_try = infinite_sequence()
>>> lets_try.__next__()
0
>>> lets_try.__next__()
1

কেন জেনারেটর তৈরি করবেন?

জেনারেটর অনেক ধরনের কাজে দরকারি।

সম্ভাব্য বিশাল মানের সংগ্রহ নিয়ে কাজ করার সময়, আপনি হয়তো সেগুলোর সবগুলো মেমোরিতে রাখতে চাইবেন না। বড় ডেটার উপর টুকরো টুকরো কাজ করতে জেনারেটর ব্যবহার করা যায়, যা মেমোরি বাঁচায় ও পারফরম্যান্স বাড়ায়।

কোনো প্রক্রিয়া বা হিসাব জটিল, ব্যয়বহুল বা অসীম হলে জেনারেটর খুবই সহায়ক:

>>> def infinite_sequence():
...     current_number = 0
...     while True:
...         yield current_number
...         current_number += 1

এখন infinite_sequence অবজেক্টে যখনই __next__() কল করা হয়, এটি আগের সংখ্যা + 1 রিটার্ন করবে।