অধ্যায় ৪.৩: পাইথনের লিস্ট, টাপল ও ফাংশন

কী-ওয়ার্ড: অপরিবর্তনযোগ্য, নিরাপদ, দ্রুত, কম মেমরি, ডিকশনারির কী হিসেবে ব্যবহারযোগ্য

লিস্টের তুলনায় টাপলের সুবিধাসমূহ:

1. টাপল অপরিবর্তনযোগ্য (Immutable), তাই ভুলবশত ডাটা পরিবর্তনের ঝুঁকি নেই।
2. লিস্টের তুলনায় টাপল দ্রুত প্রক্রিয়া হয়।
3. টাপল কম মেমরি নেয়।
4. টাপলকে ডিকশনারির কী হিসেবে ব্যবহার করা যায়, লিস্টকে যায় না।
5. স্থির ডাটা (সপ্তাহের দিন, মাসের নাম, স্থানাঙ্ক) রাখার জন্য উপযুক্ত।
6. ফাংশন থেকে একাধিক মান ফেরত দিতে টাপল ব্যবহৃত হয়।

point = (10, 20)
days = ("শনি", "রবি", "সোম")
single = (5,)          # এক উপাদানের টাপলে কমা লাগে
print(days[1], len(days))
# days[0] = "শুক্র"   → TypeError: টাপল পরিবর্তন করা যায় না

নমুনা আউটপুট:

রবি 3

কী-ওয়ার্ড: প্যারামিটার: ফাংশন সংজ্ঞায় ভেরিয়েবল; আর্গুমেন্ট: কলের সময় পাঠানো মান

প্যারামিটার: ফাংশন সংজ্ঞায়িত করার সময় বন্ধনীর ভেতরে যে ভেরিয়েবলগুলো লেখা হয়, যারা ফাংশনে আসা মান গ্রহণ করে, তাদের প্যারামিটার বলে।

আর্গুমেন্ট: ফাংশন কল করার সময় বন্ধনীর ভেতরে যে প্রকৃত মান পাঠানো হয়, তাকে আর্গুমেন্ট বলে।

def greet(name):              # name হলো প্যারামিটার
    return "স্বাগতম, " + name

msg = greet("রহিম")           # "রহিম" হলো আর্গুমেন্ট
print(msg)

নমুনা আউটপুট:

স্বাগতম, রহিম

কী-ওয়ার্ড: নামের পরে ( ), def দিয়ে সংজ্ঞা, নাম ধরে কল, return মান

পাইথনে ফাংশন চেনার উপায়:

1. ফাংশনের নামের পরে সবসময় প্রথম বন্ধনী ( ) থাকে, যেমন print(), len(), area(5, 3)।
2. ইউজার ডিফাইন্ড ফাংশন def কী-ওয়ার্ড দিয়ে সংজ্ঞায়িত হয় এবং লাইনের শেষে কোলন (:) থাকে।
3. ফাংশনের দেহ ইনডেন্টেড থাকে এবং প্রায়ই return দিয়ে মান ফেরত দেয়।
4. ভেরিয়েবলের পরে বন্ধনী থাকে না, কিন্তু ফাংশন কল করতে বন্ধনী লাগে।

কী-ওয়ার্ড: ফাংশনের ঘোষণা, নাম, প্যারামিটার, রিটার্ন টাইপ, C ভাষা, পাইথনে signature ও টাইপ হিন্ট

ফাংশন প্রটোটাইপ: ফাংশনের মূল দেহ লেখার আগে তার নাম, প্যারামিটারের সংখ্যা ও ধরন এবং রিটার্ন টাইপ জানিয়ে যে ঘোষণা (Declaration) দেওয়া হয়, তাকে ফাংশন প্রটোটাইপ বলে। এটি মূলত C/C++ ভাষায় ব্যবহৃত হয়।

C-তে উদাহরণ: int sum(int a, int b);

পাইথনে আলাদা প্রটোটাইপ লাগে না; def লাইনটিই (ফাংশন সিগনেচার) এ কাজ করে। টাইপ হিন্ট দিয়ে একই তথ্য দেওয়া যায়: def sum(a: int, b: int) -> int:

কী-ওয়ার্ড: কম্পাইলারকে আগে জানানো, ধরন ও সংখ্যা যাচাই, সংজ্ঞার আগে কল, ভুল দ্রুত ধরা

ফাংশন প্রটোটাইপের সুবিধা:

1. ফাংশনের সংজ্ঞা পরে লিখলেও আগে থেকে ফাংশন কল করা যায়।
2. কম্পাইলার আর্গুমেন্টের সংখ্যা ও ধরন সঠিক কিনা যাচাই করতে পারে।
3. ভুল ধরনের ডাটা পাঠালে কম্পাইলের সময়ই ত্রুটি ধরা পড়ে।
4. ফাংশন কী ইনপুট নেয় ও কী ফেরত দেয় তা এক নজরে বোঝা যায় (ডকুমেন্টেশন)।
5. বড় প্রোগ্রাম একাধিক ফাইলে ভাগ করে লেখা সহজ হয়।

পাইথনে টাইপ হিন্ট একই সুবিধা দেয়, যা mypy-এর মতো টুল দিয়ে যাচাই করা যায়।

কী-ওয়ার্ড: datetime, time, calendar মডিউল

পাইথনে তারিখ ও সময় নিয়ে কাজের জন্য প্রধানত তিনটি মডিউল রয়েছে:

মডিউল	কাজ	উদাহরণ
datetime	তারিখ, সময়, তারিখের ব্যবধান (timedelta) নিয়ে কাজ	datetime.date.today()
time	সময় মাপা, বিরতি দেওয়া, epoch সময়	time.sleep(1)
calendar	ক্যালেন্ডার প্রদর্শন, অধিবর্ষ যাচাই	calendar.isleap(2028)

এছাড়া টাইম জোনের জন্য zoneinfo মডিউল ব্যবহৃত হয়।

কী-ওয়ার্ড: মডুলারিটি, পুনঃব্যবহার, কোড ছোট, ডিবাগিং সহজ, রক্ষণাবেক্ষণ সহজ

ফাংশন ব্যবহারের সুবিধাসমূহ:

1. বড় প্রোগ্রামকে ছোট ছোট অংশে (মডিউল) ভাগ করা যায়, ফলে বোঝা সহজ হয়।
2. একবার লিখে বারবার ব্যবহার (Reusability) করা যায়; একই কোড বারবার লিখতে হয় না।
3. প্রোগ্রামের দৈর্ঘ্য কমে।
4. ভুল খুঁজে বের করা (Debugging) ও সংশোধন সহজ হয়।
5. একটি ফাংশন পরিবর্তন করলে সব জায়গায় তার প্রভাব পড়ে, তাই রক্ষণাবেক্ষণ সহজ।
6. একাধিক প্রোগ্রামার আলাদা আলাদা ফাংশনে একসাথে কাজ করতে পারেন।
7. কোড পরিচ্ছন্ন ও সুসংগঠিত হয়।

কী-ওয়ার্ড: নিজস্ব প্রয়োজন অনুযায়ী, পুনঃব্যবহার, পুনরাবৃত্তি হ্রাস, মডুলার, পরীক্ষা সহজ

ইউজার ডিফাইন্ড ফাংশন ব্যবহারের সুবিধাসমূহ:

1. প্রোগ্রামার নিজের নির্দিষ্ট প্রয়োজন অনুযায়ী ফাংশন তৈরি করতে পারেন, যা বিল্ট-ইন ফাংশনে নেই।
2. একবার লিখে একই প্রোগ্রামে বা অন্য প্রোগ্রামে বারবার ব্যবহার করা যায়।
3. একই কোড বারবার লিখতে হয় না, ফলে প্রোগ্রাম ছোট হয়।
4. জটিল সমস্যাকে ছোট ছোট ফাংশনে ভাগ করে সমাধান করা যায়।
5. প্রতিটি ফাংশন আলাদাভাবে পরীক্ষা ও সংশোধন করা যায়।
6. অর্থবহ নাম দিলে কোড পড়া ও বোঝা সহজ হয়।

def area_of_rectangle(length, width):
    """আয়তক্ষেত্রের ক্ষেত্রফল ফেরত দেয়"""
    area = length * width
    return area

# ফাংশন কল
result = area_of_rectangle(8, 5)
print("ক্ষেত্রফল =", result)
print(area_of_rectangle(3, 4))

নমুনা আউটপুট:

ক্ষেত্রফল = 40
12

কী-ওয়ার্ড: প্রোগ্রামারের তৈরি বনাম পাইথনে আগে থেকে তৈরি, def, পরিবর্তনযোগ্যতা

User-defined function ও Built-in function-এর পার্থক্য:

বিষয়	User-defined function	Built-in function
সংজ্ঞা	প্রোগ্রামার নিজে প্রয়োজন অনুযায়ী তৈরি করেন	পাইথনে আগে থেকেই তৈরি থাকে
তৈরি	def কী-ওয়ার্ড দিয়ে সংজ্ঞায়িত করতে হয়	সংজ্ঞায়িত করতে হয় না, সরাসরি ব্যবহার
নাম	প্রোগ্রামার নিজে নাম দেন	নাম নির্দিষ্ট (print, len, max)
পরিবর্তন	প্রয়োজনমতো পরিবর্তন করা যায়	পরিবর্তন করা যায় না
উদাহরণ	def area(l, w): return l * w	len(), print(), max(), sum()

কী-ওয়ার্ড: ক্রমানুসারী, পরিবর্তনযোগ্য, [ ], বিভিন্ন ধরনের উপাদান, ইনডেক্স 0 থেকে

লিস্ট: পাইথনে একাধিক উপাদানকে ক্রমানুসারে একটি ভেরিয়েবলে সংরক্ষণের পরিবর্তনযোগ্য (Mutable) ডাটা টাইপকে লিস্ট বলে। এটি তৃতীয় বন্ধনী [ ] দিয়ে লেখা হয় এবং উপাদানগুলো কমা দিয়ে আলাদা করা হয়। একটি লিস্টে বিভিন্ন ধরনের ডাটা রাখা যায় এবং প্রতিটি উপাদানের অবস্থান (ইনডেক্স) 0 থেকে শুরু হয়।

marks = [85, 72, 90, 64]
info = ["Rahim", 17, 4.75, True]   # ভিন্ন ধরনের উপাদান
print(marks[0], marks[-1])
print(len(info))

নমুনা আউটপুট:

85 64
4

লিস্টের ইনডেক্স

কী-ওয়ার্ড: int, float, str, bool, nested list, tuple, dict, মিশ্র

পাইথনের লিস্টে যেকোনো ধরনের ডাটা উপাদান হিসেবে রাখা যায়:

উপাদানের ধরন	উদাহরণ
পূর্ণসংখ্যা (int)	[10, 20, 30]
দশমিক (float)	[12.5, 99.9]
স্ট্রিং (str)	["আম", "কলা"]
বুলিয়ান (bool)	[True, False]
মিশ্র (Mixed)	[1, "Dhaka", 3.5, True]
নেস্টেড লিস্ট	[[1, 2], [3, 4]]
টাপল ও ডিকশনারি	[(1, 2), {"a": 1}]

numbers = [10, 20, 30]                 # int
prices = [12.5, 99.9]                  # float
names = ["আম", "কলা"]                  # str
flags = [True, False]                  # bool
mixed = [1, "Dhaka", 3.5, True]        # মিশ্র
nested = [[1, 2], [3, 4]]              # লিস্টের ভেতরে লিস্ট
others = [(1, 2), {"a": 1}]            # টাপল ও ডিকশনারি
print(nested[1][0], mixed[1])

নমুনা আউটপুট:

3 Dhaka

কী-ওয়ার্ড: অ্যাক্সেসিং, স্লাইসিং, আপডেটিং, যোগ, মুছে ফেলা, কনক্যাটেনেশন, রিপিটেশন, মেম্বারশিপ, সর্টিং

পাইথনের লিস্টে প্রধানত নিচের অপারেশনগুলো করা যায়:

অপারেশন	উদাহরণ
অ্যাক্সেসিং (ইনডেক্সিং)	a[0], a[-1]
স্লাইসিং	a[1:3]
আপডেটিং	a[0] = 5
উপাদান যোগ	append(), insert(), extend()
উপাদান মুছে ফেলা	remove(), pop(), del, clear()
কনক্যাটেনেশন (জোড়া)	a + b
রিপিটেশন	a * 2
মেম্বারশিপ	3 in a
ট্রাভার্সিং (লুপ)	for x in a:
সর্টিং	a.sort(), sorted(a)

a = [3, 1, 2]
b = [5, 4]
print(a + b)          # কনক্যাটেনেশন
print(a * 2)          # রিপিটেশন
print(2 in a)         # মেম্বারশিপ
print(a[0:2])         # স্লাইসিং
a.append(9); a.insert(0, 7)     # যোগ করা
a.remove(1); a.pop()            # মুছে ফেলা
print(a)
a.sort()                        # সাজানো
print(a, len(a))

নমুনা আউটপুট:

[3, 1, 2, 5, 4]
[3, 1, 2, 3, 1, 2]
True
[3, 1]
[7, 3, 2]
[2, 3, 7] 3

কী-ওয়ার্ড: append: শেষে একটি উপাদান; insert: নির্দিষ্ট ইনডেক্সে; আর্গুমেন্ট সংখ্যা

append() ও insert() মেথডের পার্থক্য:

বিষয়	append()	insert()
কাজ	লিস্টের একেবারে শেষে উপাদান যোগ করে	নির্দিষ্ট ইনডেক্সে উপাদান যোগ করে
আর্গুমেন্ট	একটি: যোগ করার মান	দুটি: ইনডেক্স ও মান
সিনট্যাক্স	list.append(item)	list.insert(index, item)
অন্য উপাদানের অবস্থান	অপরিবর্তিত থাকে	পরের উপাদানগুলো এক ঘর ডানে সরে যায়
গতি	দ্রুত	বড় লিস্টে তুলনামূলক ধীর

nums = [10, 20, 30]
nums.append(40)       # শেষে যোগ
print(nums)
nums.insert(1, 15)    # ইনডেক্স 1-এ যোগ
print(nums)

নমুনা আউটপুট:

[10, 20, 30, 40]
[10, 15, 20, 30, 40]

কী-ওয়ার্ড: list.extend(iterable), অন্য লিস্ট/টাপলের প্রতিটি উপাদান শেষে যোগ, append থেকে ভিন্ন

extend() মেথড অন্য একটি লিস্ট, টাপল বা যেকোনো সিকোয়েন্সের প্রতিটি উপাদানকে আলাদাভাবে মূল লিস্টের শেষে যোগ করে।

সিনট্যাক্স: list.extend(iterable)

a = [1, 2, 3]
b = [4, 5]
a.extend(b)           # b-এর প্রতিটি উপাদান a-এর শেষে
print(a)
a.extend((6, 7))      # টাপলও দেওয়া যায়
print(a)
c = [1, 2]
c.append([3, 4])      # তুলনা: append পুরো লিস্টকে একটি উপাদান হিসেবে যোগ করে
print(c)

নমুনা আউটপুট:

[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 6, 7]
[1, 2, [3, 4]]

লক্ষণীয়: append() পুরো লিস্টকে একটি উপাদান হিসেবে যোগ করে, কিন্তু extend() উপাদানগুলো আলাদাভাবে যোগ করে।

কী-ওয়ার্ড: অপরিবর্তনযোগ্য, ক্রমানুসারী, ( ), কমা, ইনডেক্স

টাপল: পাইথনে একাধিক উপাদানকে ক্রমানুসারে সংরক্ষণের অপরিবর্তনযোগ্য (Immutable) ডাটা টাইপকে টাপল বলে। এটি প্রথম বন্ধনী ( ) দিয়ে লেখা হয় এবং একবার তৈরির পর এর উপাদান পরিবর্তন, যোগ বা মুছে ফেলা যায় না।

point = (10, 20)
days = ("শনি", "রবি", "সোম")
single = (5,)          # এক উপাদানের টাপলে কমা লাগে
print(days[1], len(days))
# days[0] = "শুক্র"   → TypeError: টাপল পরিবর্তন করা যায় না

নমুনা আউটপুট:

রবি 3

কী-ওয়ার্ড: উপাদান সাজিয়ে নতুন লিস্ট ফেরত, মূল টাপল অপরিবর্তিত, reverse=True

sorted() ফাংশন টাপলের উপাদানগুলোকে ঊর্ধ্বক্রমে সাজিয়ে একটি নতুন লিস্ট ফেরত দেয়; মূল টাপল অপরিবর্তিত থাকে (কারণ টাপল পরিবর্তন করা যায় না)। reverse=True দিলে অধঃক্রমে সাজায়, আর ফলাফল টাপল হিসেবে চাইলে tuple() দিয়ে রূপান্তর করতে হয়।

t = (40, 10, 30, 20)
s = sorted(t)
print(s)                     # নতুন লিস্ট
print(t)                     # মূল টাপল অপরিবর্তিত
print(tuple(sorted(t, reverse=True)))

নমুনা আউটপুট:

[10, 20, 30, 40]
(40, 10, 30, 20)
(40, 30, 20, 10)

কী-ওয়ার্ড: কী-মান (key: value) জোড়া, { }, অনন্য কী, পরিবর্তনযোগ্য, dict

ডিকশনারি: পাইথনে কী-মান (key: value) জোড়া আকারে ডাটা সংরক্ষণের পরিবর্তনযোগ্য (Mutable) ডাটা টাইপকে ডিকশনারি বলে। এটি দ্বিতীয় বন্ধনী { } দিয়ে লেখা হয়; প্রতিটি কী অনন্য এবং কী দিয়েই মান খুঁজে পাওয়া যায়।

student = {"roll": 101, "name": "রহিম", "gpa": 4.75}
print(student["name"])
print(len(student))

নমুনা আউটপুট:

রহিম
3

এখানে "roll", "name", "gpa" হলো কী এবং 101, "রহিম", 4.75 হলো তাদের মান।

কী-ওয়ার্ড: কী দিয়ে দ্রুত খোঁজা, অর্থবহ লেবেল, সম্পর্কিত তথ্য একসাথে, JSON

পাইথন প্রোগ্রামে ডিকশনারি ব্যবহারের কারণ:

1. ইনডেক্সের বদলে অর্থবহ কী (যেমন "name") দিয়ে ডাটা খোঁজা যায়, ফলে কোড বোঝা সহজ।
2. কী দিয়ে মান খোঁজা অত্যন্ত দ্রুত (হ্যাশিং পদ্ধতিতে)।
3. একটি বস্তুর সম্পর্কিত তথ্য (যেমন শিক্ষার্থীর রোল, নাম, GPA) একসাথে রাখা যায়।
4. সহজে নতুন তথ্য যোগ, পরিবর্তন ও মুছে ফেলা যায়।
5. ওয়েব API ও JSON ডাটার কাঠামোর সাথে মিলে যায়।
6. শব্দ গণনা, ফোনবুক, ডাটাবেজ রেকর্ডের মতো কাজে উপযোগী।

student = {"roll": 101, "name": "রহিম", "gpa": 4.75}
print(student["roll"])                 # কী দিয়ে সরাসরি
print(student.get("gpa"))              # get() দিয়ে
print(student.get("phone", "নেই"))     # কী না থাকলে বিকল্প মান
for key, value in student.items():     # লুপ দিয়ে
    print(key, ":", value)

নমুনা আউটপুট:

101
4.75
নেই
roll : 101
name : রহিম
gpa : 4.75

কী-ওয়ার্ড: d[key] = নতুন মান, নতুন কী যোগ, update() মেথড

ডিকশনারির উপাদান আপডেট করার পদ্ধতি:

1. বিদ্যমান মান পরিবর্তন: dict[key] = new_value — কী আগে থাকলে মান বদলে যায়।
2. নতুন উপাদান যোগ: একই পদ্ধতিতে নতুন কী দিলে নতুন কী-মান জোড়া যুক্ত হয়।
3. update() মেথড: একসাথে একাধিক কী-মান পরিবর্তন বা যোগ করা যায়।

student = {"roll": 101, "name": "রহিম"}
student["name"] = "রহিম উদ্দিন"          # বিদ্যমান মান পরিবর্তন
student["gpa"] = 4.75                    # নতুন কী-মান যোগ
student.update({"roll": 102, "city": "ঢাকা"})   # একসাথে একাধিক
print(student)

নমুনা আউটপুট:

{'roll': 102, 'name': 'রহিম উদ্দিন', 'gpa': 4.75, 'city': 'ঢাকা'}

কী-ওয়ার্ড: নির্দিষ্ট কাজের কোড ব্লক, নাম দিয়ে কল, পুনঃব্যবহার, built-in ও user-defined

ফাংশন: কোনো নির্দিষ্ট কাজ সম্পাদনের জন্য লেখা একগুচ্ছ স্টেটমেন্টের নামযুক্ত ব্লককে ফাংশন বলে, যা নাম ধরে কল করলে চলে এবং প্রয়োজনে ফলাফল ফেরত দেয়। একবার লিখে বারবার ব্যবহার করা যায়।

উদাহরণ: বিল্ট-ইন ফাংশন print(), len(); ইউজার ডিফাইন্ড ফাংশন def area(l, w): return l * w

কী-ওয়ার্ড: def নাম(প্যারামিটার):, ইনডেন্টেড দেহ, return

পাইথনে ফাংশন তৈরির সিনট্যাক্স:

def function_name(parameter1, parameter2, ...):
    """ডকস্ট্রিং (ঐচ্ছিক)"""
    statement(s)
    return value      # ঐচ্ছিক

def area_of_rectangle(length, width):
    """আয়তক্ষেত্রের ক্ষেত্রফল ফেরত দেয়"""
    area = length * width
    return area

# ফাংশন কল
result = area_of_rectangle(8, 5)
print("ক্ষেত্রফল =", result)
print(area_of_rectangle(3, 4))

নমুনা আউটপুট:

ক্ষেত্রফল = 40
12

কী-ওয়ার্ড: নাম ও বন্ধনী দিয়ে ফাংশন চালানো, আর্গুমেন্ট পাঠানো, return মান গ্রহণ

Function Calling: সংজ্ঞায়িত কোনো ফাংশনকে তার নাম ও বন্ধনী লিখে (প্রয়োজনে আর্গুমেন্টসহ) চালানোর প্রক্রিয়াকে ফাংশন কলিং বলে। ফাংশন কল হলে নিয়ন্ত্রণ ফাংশনের দেহে যায়, কাজ শেষে return-এর মান নিয়ে কল করার স্থানে ফিরে আসে।

উদাহরণ: result = area_of_rectangle(8, 5)

ফাংশন কলিং প্রক্রিয়া

কী-ওয়ার্ড: print(), input(), len(), max(), sum(), round(), math.sqrt()

পাঁচটি লাইব্রেরি (বিল্ট-ইন) ফাংশন ও তাদের কাজ:

ফাংশন	কাজ	উদাহরণ → ফলাফল
print()	স্ক্রিনে আউটপুট দেখায়	print("Hi") → Hi
input()	ব্যবহারকারীর কাছ থেকে ইনপুট নেয়	input("নাম: ")
len()	উপাদানের সংখ্যা দেয়	len([4, 9, 1]) → 3
max()	সর্বোচ্চ মান দেয়	max(4, 9, 1) → 9
sum()	যোগফল দেয়	sum([4, 9, 1]) → 14
round()	নির্দিষ্ট দশমিক ঘরে রাউন্ড করে	round(3.14159, 2) → 3.14
math.sqrt()	বর্গমূল দেয় (math মডিউল)	math.sqrt(16) → 4.0

import math
nums = [4, 9, 1]
print(len(nums))          # উপাদান সংখ্যা → 3
print(max(nums))          # সর্বোচ্চ → 9
print(sum(nums))          # যোগফল → 14
print(round(3.14159, 2))  # রাউন্ড → 3.14
print(math.sqrt(16))      # বর্গমূল → 4.0

নমুনা আউটপুট:

3
9
14
3.14
4.0

কী-ওয়ার্ড: পজিটিভ ইনডেক্স, নেগেটিভ ইনডেক্স, স্লাইসিং, লুপ

লিস্টের উপাদান অ্যাক্সেস করার পদ্ধতিসমূহ:

1. পজিটিভ ইনডেক্সিং: বাম থেকে 0, 1, 2 … — fruits[1]
2. নেগেটিভ ইনডেক্সিং: ডান থেকে −1, −2 … — fruits[-1]
3. স্লাইসিং: একটি অংশ — fruits[1:4]
4. লুপের মাধ্যমে: for f in fruits:

fruits = ["আম", "কলা", "লিচু", "জাম", "কাঁঠাল"]
print(fruits[1])      # পজিটিভ ইনডেক্স → কলা
print(fruits[-1])     # নেগেটিভ ইনডেক্স → কাঁঠাল
print(fruits[1:4])    # স্লাইসিং
for f in fruits[:2]:  # লুপ দিয়ে
    print(f)

নমুনা আউটপুট:

কলা
কাঁঠাল
['কলা', 'লিচু', 'জাম']
আম
কলা

কী-ওয়ার্ড: ইনডেক্স দিয়ে মান পরিবর্তন, স্লাইস দিয়ে একাধিক পরিবর্তন, Mutable

লিস্টের উপাদান আপডেটিং: লিস্ট পরিবর্তনযোগ্য (Mutable), তাই তৈরির পর এর কোনো উপাদানের মান ইনডেক্স বা স্লাইস ব্যবহার করে পরিবর্তন করাকে লিস্ট আপডেটিং বলে।

সিনট্যাক্স: list[index] = new_value বা list[start:end] = [new values]

marks = [70, 80, 90]
marks[1] = 85            # একটি উপাদান পরিবর্তন
marks[0:2] = [75, 88]    # স্লাইস দিয়ে একাধিক পরিবর্তন
print(marks)

নমুনা আউটপুট:

[75, 88, 90]

কী-ওয়ার্ড: লিস্ট পরিবর্তনযোগ্য [ ], টাপল অপরিবর্তনযোগ্য ( ), গতি, মেথড

টাপল ও লিস্টের পার্থক্য:

বিষয়	লিস্ট (List)	টাপল (Tuple)
সংজ্ঞা	পরিবর্তনযোগ্য (Mutable) ক্রমানুসারী উপাদানের সংগ্রহ	অপরিবর্তনযোগ্য (Immutable) ক্রমানুসারী উপাদানের সংগ্রহ
বন্ধনী	তৃতীয় বন্ধনী [ ]	প্রথম বন্ধনী ( )
পরিবর্তন	উপাদান যোগ, পরিবর্তন ও মুছে ফেলা যায়	তৈরির পর পরিবর্তন করা যায় না
মেথড	অনেক মেথড (append, insert, remove, sort…)	মাত্র দুটি মেথড (count, index)
গতি ও মেমরি	তুলনামূলক ধীর, মেমরি বেশি লাগে	দ্রুত, মেমরি কম লাগে
ডিকশনারির কী	কী হিসেবে ব্যবহার করা যায় না	কী হিসেবে ব্যবহার করা যায়

কী-ওয়ার্ড: count(): কতবার আছে; index(): প্রথম অবস্থান

টাপলে মাত্র দুটি বিল্ট-ইন মেথড আছে:

1. count(value): টাপলে একটি মান কতবার আছে তা গণনা করে।
2. index(value): টাপলে একটি মান প্রথম কোন অবস্থানে (ইনডেক্সে) আছে তা দেয়; না থাকলে ValueError হয়।

t = (2, 5, 2, 8, 2)
print(t.count(2))    # 2 কতবার আছে → 3
print(t.index(8))    # 8-এর অবস্থান → 3

নমুনা আউটপুট:

3
3

কী-ওয়ার্ড: len(), max(), min(), sum(), sorted(), tuple(), any(), all()

টাপলে ব্যবহৃত বিল্ট-ইন ফাংশনসমূহ:

ফাংশন	কাজ
len()	উপাদানের সংখ্যা
max()	সর্বোচ্চ মান
min()	সর্বনিম্ন মান
sum()	সংখ্যাগুলোর যোগফল
sorted()	সাজানো নতুন লিস্ট
tuple()	লিস্ট বা অন্য সিকোয়েন্সকে টাপলে রূপান্তর
any()	অন্তত একটি উপাদান True হলে True
all()	সব উপাদান True হলে True

t = (15, 8, 23, 4)
print(len(t), max(t), min(t), sum(t))
print(sorted(t))
print(tuple([1, 2, 3]))
print(any((0, 0, 1)), all((1, 2, 0)))

নমুনা আউটপুট:

4 23 4 50
[4, 8, 15, 23]
(1, 2, 3)
True False

কী-ওয়ার্ড: তৈরি করে লিখতে হয় না, পরীক্ষিত ও নির্ভুল, দ্রুত, সময় সাশ্রয়

Library (বিল্ট-ইন) ফাংশন ব্যবহারের সুবিধা:

1. ফাংশন নিজে লিখতে হয় না, সরাসরি ব্যবহার করা যায়।
2. এগুলো আগে থেকে পরীক্ষিত, তাই নির্ভুল ও নির্ভরযোগ্য।
3. দক্ষভাবে তৈরি বলে দ্রুত চলে।
4. প্রোগ্রাম লেখার সময় ও শ্রম বাঁচে।
5. কোড ছোট ও পড়তে সহজ হয়।
6. জটিল কাজ (গাণিতিক, তারিখ-সময়, ফাইল) সহজে করা যায়।

কী-ওয়ার্ড: নিজেকে নিজে কল করে, বেস কেস, ফ্যাক্টরিয়াল

Recursive ফাংশন: যে ফাংশন নিজের দেহের ভেতর থেকে নিজেকেই কল করে, তাকে রিকার্সিভ ফাংশন বলে। এতে অবশ্যই একটি থামার শর্ত (Base case) থাকতে হয়, নইলে অসীমবার কল হয়ে RecursionError হয়।

def factorial(n):
    if n == 0 or n == 1:      # বেস কেস: এখানে থামবে
        return 1
    return n * factorial(n - 1)   # নিজেকে নিজে কল

print(factorial(5))   # 5 × 4 × 3 × 2 × 1

নমুনা আউটপুট:

120

factorial(5) = 5 × factorial(4) = 5 × 4 × factorial(3) … = 120

কী-ওয়ার্ড: পজিশনাল, কীওয়ার্ড, ডিফল্ট, ভেরিয়েবল-লেংথ (*args, **kwargs)

পাইথনে ফাংশনের আর্গুমেন্ট প্রধানত চার প্রকার:

ধরন	বৈশিষ্ট্য	উদাহরণ
পজিশনাল (Positional)	অবস্থান অনুযায়ী প্যারামিটারে মান বসে	info("রহিম", 18)
কীওয়ার্ড (Keyword)	প্যারামিটারের নাম উল্লেখ করে মান দেওয়া; ক্রম বদলানো যায়	info(age=20, name="সাদিয়া")
ডিফল্ট (Default)	মান না দিলে আগে নির্ধারিত মান নেয়	def info(name, age=18):
ভেরিয়েবল-লেংথ	যেকোনো সংখ্যক আর্গুমেন্ট: *args (টাপল), **kwargs (ডিকশনারি)	def f(*args, **kwargs):

def info(name, age=18, *subjects, **extra):
    print(name, age, subjects, extra)

info("রহিম")                                # পজিশনাল + ডিফল্ট
info(age=20, name="সাদিয়া")                 # কীওয়ার্ড আর্গুমেন্ট
info("করিম", 19, "ICT", "Math")             # ভেরিয়েবল-লেংথ (*args)
info("মিতু", 17, city="Dhaka")              # **kwargs

নমুনা আউটপুট:

রহিম 18 () {}
সাদিয়া 20 () {}
করিম 19 ('ICT', 'Math') {}
মিতু 17 () {'city': 'Dhaka'}

কী-ওয়ার্ড: লিস্ট বিল্ট-ইন ও মিশ্র ডাটা, অ্যারে একই ধরনের ডাটা, import array/NumPy, মেমরি, গাণিতিক অপারেশন

পাইথন লিস্ট ও অ্যারের পার্থক্য:

বিষয়	লিস্ট (List)	অ্যারে (Array)
ডাটার ধরন	ভিন্ন ভিন্ন ধরনের ডাটা রাখা যায়	শুধু একই ধরনের ডাটা রাখা যায়
ব্যবহার	পাইথনের বিল্ট-ইন, import লাগে না	array মডিউল বা NumPy ইমপোর্ট করতে হয়
ঘোষণা	a = [1, "দুই", 3.0]	array.array('i', [1, 2, 3])
মেমরি	বেশি মেমরি লাগে	কম মেমরি লাগে
গাণিতিক অপারেশন	সরাসরি সব উপাদানে গাণিতিক অপারেশন করা যায় না	NumPy অ্যারেতে সরাসরি করা যায় (যেমন arr * 2)
গতি	বড় সংখ্যাভিত্তিক হিসাবে ধীর	দ্রুত
নমনীয়তা	বেশি নমনীয়	কম নমনীয়
উপযোগিতা	সাধারণ ডাটা সংরক্ষণ	বড় সংখ্যাভিত্তিক ডাটা ও বৈজ্ঞানিক হিসাব

import array
arr = array.array('i', [10, 20, 30])   # শুধু int রাখা যাবে
arr.append(40)
print(arr)
lst = [10, "দশ", 10.5]                  # লিস্টে মিশ্র ডাটা চলে
print(lst)

নমুনা আউটপুট:

array('i', [10, 20, 30, 40])
[10, 'দশ', 10.5]

কী-ওয়ার্ড: Mutable বনাম Immutable, [ ] বনাম ( ), মেথড, গতি, মেমরি, ডিকশনারির কী, ব্যবহার

পাইথন লিস্ট ও টাপলের পার্থক্যসমূহ:

বিষয়	লিস্ট (List)	টাপল (Tuple)
সংজ্ঞা	পরিবর্তনযোগ্য (Mutable) ক্রমানুসারী উপাদানের সংগ্রহ	অপরিবর্তনযোগ্য (Immutable) ক্রমানুসারী উপাদানের সংগ্রহ
বন্ধনী	তৃতীয় বন্ধনী [ ]	প্রথম বন্ধনী ( )
পরিবর্তন	উপাদান যোগ, পরিবর্তন ও মুছে ফেলা যায়	তৈরির পর পরিবর্তন করা যায় না
মেথড	অনেক মেথড (append, insert, remove, sort…)	মাত্র দুটি মেথড (count, index)
গতি ও মেমরি	তুলনামূলক ধীর, মেমরি বেশি লাগে	দ্রুত, মেমরি কম লাগে
ডিকশনারির কী	কী হিসেবে ব্যবহার করা যায় না	কী হিসেবে ব্যবহার করা যায়
উপযোগিতা	যে ডাটা বারবার বদলাবে (যেমন নম্বরের তালিকা)	স্থির ডাটা (যেমন সপ্তাহের দিন, স্থানাঙ্ক)
উদাহরণ	marks = [80, 75, 90]	days = ("শনি", "রবি")

point = (10, 20)
days = ("শনি", "রবি", "সোম")
single = (5,)          # এক উপাদানের টাপলে কমা লাগে
print(days[1], len(days))
# days[0] = "শুক্র"   → TypeError: টাপল পরিবর্তন করা যায় না

নমুনা আউটপুট:

রবি 3

কী-ওয়ার্ড: অ্যাক্সেসিং, স্লাইসিং, আপডেটিং, append/insert/extend, remove/pop/del, +, *, in, sort

ভূমিকা: লিস্টের উপর বিভিন্ন অপারেশন করে ডাটা খোঁজা, যোগ, পরিবর্তন ও মুছে ফেলা যায়।

১. অ্যাক্সেসিং ও স্লাইসিং

fruits = ["আম", "কলা", "লিচু", "জাম", "কাঁঠাল"]
print(fruits[1])      # পজিটিভ ইনডেক্স → কলা
print(fruits[-1])     # নেগেটিভ ইনডেক্স → কাঁঠাল
print(fruits[1:4])    # স্লাইসিং
for f in fruits[:2]:  # লুপ দিয়ে
    print(f)

নমুনা আউটপুট:

কলা
কাঁঠাল
['কলা', 'লিচু', 'জাম']
আম
কলা

২. আপডেটিং

marks = [70, 80, 90]
marks[1] = 85            # একটি উপাদান পরিবর্তন
marks[0:2] = [75, 88]    # স্লাইস দিয়ে একাধিক পরিবর্তন
print(marks)

নমুনা আউটপুট:

[75, 88, 90]

৩. উপাদান যোগ (append, insert, extend)

nums = [10, 20, 30]
nums.append(40)       # শেষে যোগ
print(nums)
nums.insert(1, 15)    # ইনডেক্স 1-এ যোগ
print(nums)

নমুনা আউটপুট:

[10, 20, 30, 40]
[10, 15, 20, 30, 40]

৪. অন্যান্য অপারেশন: কনক্যাটেনেশন, রিপিটেশন, মেম্বারশিপ, মুছে ফেলা, সর্টিং

a = [3, 1, 2]
b = [5, 4]
print(a + b)          # কনক্যাটেনেশন
print(a * 2)          # রিপিটেশন
print(2 in a)         # মেম্বারশিপ
print(a[0:2])         # স্লাইসিং
a.append(9); a.insert(0, 7)     # যোগ করা
a.remove(1); a.pop()            # মুছে ফেলা
print(a)
a.sort()                        # সাজানো
print(a, len(a))

নমুনা আউটপুট:

[3, 1, 2, 5, 4]
[3, 1, 2, 3, 1, 2]
True
[3, 1]
[7, 3, 2]
[2, 3, 7] 3

অপারেশন	পদ্ধতি
মুছে ফেলা	remove(x) মান দিয়ে, pop(i) ইনডেক্স দিয়ে, del a[i], clear() সব
দৈর্ঘ্য	len(a)
উল্টানো	a.reverse() বা a[::-1]

কী-ওয়ার্ড: def, প্যারামিটার, ফাংশনের দেহ, return, ফাংশন কল, আর্গুমেন্ট, নিয়ন্ত্রণ স্থানান্তর

ফাংশন ডেফিনিশন (সংজ্ঞা): def কী-ওয়ার্ড, ফাংশনের নাম, বন্ধনীর ভেতরে প্যারামিটার এবং কোলন দিয়ে ফাংশন তৈরি করা হয়। এরপর ইনডেন্টেড দেহে কাজের স্টেটমেন্ট লেখা হয় এবং return দিয়ে ফলাফল ফেরত দেওয়া হয়।

def function_name(parameters):
    statement(s)
    return value

ফাংশন কলিং: ফাংশনের নাম ও বন্ধনীর ভেতরে আর্গুমেন্ট দিয়ে ফাংশন চালানো হয়। কল হলে নিয়ন্ত্রণ ফাংশনের দেহে যায়, কাজ শেষে ফেরত মান নিয়ে আগের স্থানে ফিরে আসে।

উদাহরণ:

def area_of_rectangle(length, width):
    """আয়তক্ষেত্রের ক্ষেত্রফল ফেরত দেয়"""
    area = length * width
    return area

# ফাংশন কল
result = area_of_rectangle(8, 5)
print("ক্ষেত্রফল =", result)
print(area_of_rectangle(3, 4))

নমুনা আউটপুট:

ক্ষেত্রফল = 40
12

ধাপসমূহ: ১) area_of_rectangle(8, 5) কল হলো → ২) length = 8, width = 5 বসল → ৩) area = 40 হিসাব হলো → ৪) return 40 কল করার স্থানে ফিরে result-এ জমা হলো → ৫) print করা হলো।

কী-ওয়ার্ড: ফাংশন: len, max, min, sum, sorted; মেথড: append, insert, extend, remove, pop, clear, index, count, sort, reverse, copy

লিস্ট ফাংশন: লিস্টকে আর্গুমেন্ট হিসেবে নেয়।

ফাংশন	কাজ
len(list)	উপাদানের সংখ্যা
max(list) / min(list)	সর্বোচ্চ / সর্বনিম্ন মান
sum(list)	যোগফল
sorted(list)	সাজানো নতুন লিস্ট
list(seq)	অন্য সিকোয়েন্সকে লিস্টে রূপান্তর

লিস্ট মেথড: লিস্টের নামের পরে ডট (.) দিয়ে ব্যবহৃত হয়।

মেথড	কাজ
append(x)	শেষে x যোগ
insert(i, x)	i ইনডেক্সে x যোগ
extend(seq)	অন্য সিকোয়েন্সের সব উপাদান যোগ
remove(x)	প্রথম x মুছে ফেলে
pop(i)	i ইনডেক্সের (না দিলে শেষের) উপাদান মুছে ফেরত দেয়
clear()	সব উপাদান মুছে ফেলে
index(x)	x-এর প্রথম অবস্থান
count(x)	x কতবার আছে
sort()	লিস্টটিকেই সাজায়
reverse()	ক্রম উল্টে দেয়
copy()	লিস্টের অনুলিপি তৈরি করে

nums = [40, 10, 30, 10]
print(len(nums), max(nums), min(nums), sum(nums))
print(sorted(nums))            # নতুন সাজানো লিস্ট
nums.append(50)
nums.insert(0, 5)
nums.extend([60, 70])
nums.remove(30)                # প্রথম 30 মুছবে
x = nums.pop()                 # শেষ উপাদান (70) বের করবে
print(nums, x)
print(nums.index(10), nums.count(10))
nums.sort(reverse=True)
print(nums)
nums.reverse()
print(nums)
copy_list = nums.copy()
nums.clear()
print(nums, copy_list)

নমুনা আউটপুট:

4 40 10 90
[10, 10, 30, 40]
[5, 40, 10, 10, 50, 60] 70
2 2
[60, 50, 40, 10, 10, 5]
[5, 10, 10, 40, 50, 60]
[] [5, 10, 10, 40, 50, 60]

কী-ওয়ার্ড: int লিস্ট (sum, max), str লিস্ট (sort, join), bool লিস্ট (any, all), মিশ্র লিস্ট, নেস্টেড লিস্ট

ভূমিকা: পাইথনের লিস্টে বিভিন্ন ধরনের ডাটা রাখা যায় এবং ডাটার ধরন অনুযায়ী ভিন্ন অপারেশন করা হয়:

লিস্টের ধরন	উপযোগী অপারেশন	উদাহরণ
সংখ্যার লিস্ট	sum(), max(), min(), গড়	sum([12, 7, 25]) → 44
স্ট্রিং লিস্ট	sort(), join(), upper()	", ".join(names)
বুলিয়ান লিস্ট	any(), all()	any([True, False]) → True
মিশ্র লিস্ট	type() দিয়ে ধরন যাচাই, ইনডেক্সিং	[1, "a", 2.5]
নেস্টেড লিস্ট	দুই স্তরের ইনডেক্স [i][j]	matrix[1][1] → 4

nums = [12, 7, 25]
print(sum(nums), max(nums))                 # সংখ্যার লিস্ট
names = ["করিম", "আলম", "বিনা"]
names.sort()
print(", ".join(names))                     # স্ট্রিং লিস্ট
flags = [True, False, True]
print(any(flags), all(flags))               # বুলিয়ান লিস্ট
mixed = [1, "a", 2.5]
print([type(x).__name__ for x in mixed])    # মিশ্র লিস্ট
matrix = [[1, 2], [3, 4]]
print(matrix[1][1], len(matrix))            # নেস্টেড লিস্ট

নমুনা আউটপুট:

44 25
আলম, করিম, বিনা
True False
['int', 'str', 'float']
4 2

লক্ষণীয়: মিশ্র লিস্টে (যেমন সংখ্যা ও স্ট্রিং একসাথে) sort() বা sum() ব্যবহার করলে TypeError হয়।

কী-ওয়ার্ড: ফাংশন সংজ্ঞা, বিল্ট-ইন, ইউজার ডিফাইন্ড, ল্যাম্বডা (নামহীন), রিকার্সিভ, উদাহরণ

ফাংশন: নির্দিষ্ট কাজ সম্পাদনের জন্য লেখা নামযুক্ত কোড ব্লককে ফাংশন বলে, যা নাম ধরে কল করলে চলে এবং প্রয়োজনে মান ফেরত দেয়।

ফাংশনের শ্রেণিবিভাগ:

১. বিল্ট-ইন (লাইব্রেরি) ফাংশন

পাইথনে আগে থেকে তৈরি; সরাসরি ব্যবহার করা যায়। যেমন print(), len(), max(), math.sqrt()।

import math
nums = [4, 9, 1]
print(len(nums))          # উপাদান সংখ্যা → 3
print(max(nums))          # সর্বোচ্চ → 9
print(sum(nums))          # যোগফল → 14
print(round(3.14159, 2))  # রাউন্ড → 3.14
print(math.sqrt(16))      # বর্গমূল → 4.0

নমুনা আউটপুট:

3
9
14
3.14
4.0

২. ইউজার ডিফাইন্ড ফাংশন

প্রোগ্রামার def দিয়ে নিজে তৈরি করেন।

def area_of_rectangle(length, width):
    """আয়তক্ষেত্রের ক্ষেত্রফল ফেরত দেয়"""
    area = length * width
    return area

# ফাংশন কল
result = area_of_rectangle(8, 5)
print("ক্ষেত্রফল =", result)
print(area_of_rectangle(3, 4))

নমুনা আউটপুট:

ক্ষেত্রফল = 40
12

৩. ল্যাম্বডা (নামহীন) ফাংশন

lambda কী-ওয়ার্ড দিয়ে এক লাইনে তৈরি ছোট ফাংশন।

square = lambda x: x * x      # নামহীন (lambda) ফাংশন
print(square(6))

নমুনা আউটপুট:

36

৪. রিকার্সিভ ফাংশন

যে ফাংশন নিজেকেই কল করে।

def factorial(n):
    if n == 0 or n == 1:      # বেস কেস: এখানে থামবে
        return 1
    return n * factorial(n - 1)   # নিজেকে নিজে কল

print(factorial(5))   # 5 × 4 × 3 × 2 × 1

নমুনা আউটপুট:

120

এছাড়া আর্গুমেন্ট ও রিটার্ন মানের ভিত্তিতে ফাংশন চার ধরনের হতে পারে: আর্গুমেন্ট ও রিটার্ন উভয়ই আছে, শুধু আর্গুমেন্ট আছে, শুধু রিটার্ন আছে, কোনোটিই নেই।

কী-ওয়ার্ড: datetime, date, timedelta, strftime, time.sleep, calendar.isleap, now(), today()

ভূমিকা: পাইথনে তারিখ ও সময় নিয়ে কাজের জন্য datetime, time ও calendar মডিউল ব্যবহৃত হয়।

ফাংশন/ক্লাস	কাজ
datetime.date(y, m, d)	নির্দিষ্ট তারিখ তৈরি
date.today()	আজকের তারিখ
datetime.now()	বর্তমান তারিখ ও সময়
strftime(format)	তারিখকে পছন্দমতো ফরম্যাটে লেখা (%d দিন, %m মাস, %Y বছর, %I ঘণ্টা, %M মিনিট, %p AM/PM)
timedelta(days=n)	তারিখের সাথে দিন যোগ-বিয়োগ
date2 − date1	দুই তারিখের ব্যবধান
time.sleep(n)	n সেকেন্ড বিরতি
calendar.isleap(y)	অধিবর্ষ কিনা যাচাই

উদাহরণ (নির্দিষ্ট তারিখ দিয়ে):

import datetime, calendar
d = datetime.date(2026, 3, 26)
print(d.year, d.month, d.day)
print(d.strftime("%d-%m-%Y"))
print(d + datetime.timedelta(days=10))        # ১০ দিন পর
gap = datetime.date(2026, 12, 16) - d
print(gap.days, "দিন বাকি")
t = datetime.datetime(2026, 3, 26, 9, 30)
print(t.strftime("%I:%M %p"))
print(calendar.isleap(2028))

নমুনা আউটপুট:

2026 3 26
26-03-2026
2026-04-05
265 দিন বাকি
09:30 AM
True

বর্তমান সময় দেখা: নিচের কোডের আউটপুট চালানোর সময়ের উপর নির্ভর করে।

import datetime, time
print(datetime.datetime.now())   # বর্তমান তারিখ ও সময়
print(datetime.date.today())     # আজকের তারিখ
time.sleep(1)                    # ১ সেকেন্ড অপেক্ষা