অধ্যায় ৪.২: পাইথন কন্ট্রোল স্ট্রাকচার

কী-ওয়ার্ড: ক্রমানুসারে একবার, উপর থেকে নিচে, কোনো শর্ত বা পুনরাবৃত্তি নেই

সিকুয়েন্সিয়াল স্ট্রাকচার: যে কন্ট্রোল স্ট্রাকচারে প্রোগ্রামের স্টেটমেন্টগুলো কোনো শর্ত বা পুনরাবৃত্তি ছাড়াই উপর থেকে নিচে ক্রমানুসারে একবার করে সম্পাদিত হয়, তাকে সিকুয়েন্সিয়াল স্ট্রাকচার বলে। এটি সবচেয়ে সরল কন্ট্রোল স্ট্রাকচার।

উদাহরণ — আয়তক্ষেত্রের ক্ষেত্রফল:

# সিকুয়েন্সিয়াল স্ট্রাকচার: প্রতিটি লাইন ক্রমানুসারে একবার চলে
length = 10
width = 5
area = length * width
print("ক্ষেত্রফল =", area)

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

ক্ষেত্রফল = 50

সিকুয়েন্সিয়াল স্ট্রাকচার

কী-ওয়ার্ড: একাধিক শর্ত পরপর যাচাই, প্রথম সত্য শর্তের ব্লক, শেষে else

elif স্টেটমেন্টে একাধিক শর্ত পরপর যাচাই করা হয়; প্রথম যে শর্তটি সত্য হয় শুধু তার ব্লক চলে, কোনোটি সত্য না হলে else ব্লক চলে। নম্বর অনুযায়ী গ্রেড নির্ণয়ের ফ্লোচার্ট:

কী-ওয়ার্ড: একটি if-এর ভেতরে আরেকটি if, বাইরের শর্ত সত্য হলে ভেতরের শর্ত যাচাই

একটি if স্টেটমেন্টের ভেতরে আরেকটি if থাকলে তাকে nested if বলে। বাইরের শর্ত সত্য হলেই কেবল ভেতরের শর্ত যাচাই হয়। পাস ও A+ নির্ণয়ের ফ্লোচার্ট:

কী-ওয়ার্ড: আরম্ভিক মান, শর্ত যাচাই, লুপের দেহ, মান বৃদ্ধি, আবার শর্তে ফেরা

for লুপ নির্দিষ্ট সংখ্যকবার কাজ পুনরাবৃত্তি করে। for i in range(1, 6): print(i) লুপের ফ্লোচার্ট:

for i in range(1, 6):
    print(i, end=" ")

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

1 2 3 4 5

কী-ওয়ার্ড: শর্ত যাচাই, সত্য হলে দেহ চলে, মান পরিবর্তন, মিথ্যা হলে লুপ শেষ

while লুপ শর্ত সত্য থাকা পর্যন্ত বারবার চলে। ১ থেকে ৫ পর্যন্ত প্রিন্ট করার while লুপের ফ্লোচার্ট:

i = 1
while i <= 5:
    print(i, end=" ")
    i += 1

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

1 2 3 4 5

কী-ওয়ার্ড: শর্তভিত্তিক সিদ্ধান্ত, শর্ত সত্য হলে নির্দিষ্ট কোড চালানো

প্রোগ্রামে কোনো শর্ত সত্য হলে তবেই নির্দিষ্ট কাজ করার জন্য if স্টেটমেন্ট ব্যবহার করা হয়। এর মাধ্যমে প্রোগ্রাম পরিস্থিতি অনুযায়ী সিদ্ধান্ত নিতে পারে, যেমন নম্বর ৩৩ বা বেশি হলে "পাস" দেখানো।

marks = 75
if marks >= 33:
    print("অভিনন্দন! তুমি পাস করেছ")
print("ফলাফল প্রকাশিত")

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

অভিনন্দন! তুমি পাস করেছ
ফলাফল প্রকাশিত

কী-ওয়ার্ড: দুইয়ের বেশি সম্ভাবনা, একাধিক শর্ত, else if-এর সংক্ষিপ্ত রূপ, nested if এড়ানো

যখন দুইয়ের বেশি সম্ভাব্য পরিস্থিতি থাকে এবং একাধিক শর্ত পরপর যাচাই করতে হয়, তখন elif (else if-এর সংক্ষিপ্ত রূপ) ব্যবহার করা হয়। এতে অনেকগুলো nested if-else না লিখে পরিচ্ছন্নভাবে কোড লেখা যায়। যেমন নম্বর অনুযায়ী বিভিন্ন গ্রেড নির্ণয়।

marks = int(input("নম্বর: "))
if marks >= 80:
    grade = "A+"
elif marks >= 70:
    grade = "A"
elif marks >= 60:
    grade = "A-"
elif marks >= 33:
    grade = "পাস"
else:
    grade = "F"
print("গ্রেড:", grade)

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

নম্বর: 72
গ্রেড: A

কী-ওয়ার্ড: ব্রাঞ্চিং: শর্তভেদে ভিন্ন পথ (if); লুপিং: বারবার পুনরাবৃত্তি (for, while)

Branching (শাখা): শর্তের সত্য-মিথ্যার উপর ভিত্তি করে প্রোগ্রামের প্রবাহ ভিন্ন ভিন্ন পথে যাওয়াকে ব্রাঞ্চিং বলে। পাইথনে if, if-else, elif ব্রাঞ্চিং স্টেটমেন্ট।

Looping (পুনরাবৃত্তি): কোনো শর্ত সত্য থাকা পর্যন্ত বা নির্দিষ্ট সংখ্যকবার একই কোড ব্লক বারবার চালানোকে লুপিং বলে। পাইথনে for ও while লুপিং স্টেটমেন্ট।

কী-ওয়ার্ড: পরিস্থিতি অনুযায়ী ভিন্ন কাজ, ব্যবহারকারীর ইনপুট যাচাই, বাস্তব সমস্যা সমাধান

প্রোগ্রামে Decision making-এর প্রয়োজনীয়তা:

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

balance = 5000
amount = 7000
if amount <= balance:
    balance -= amount
    print("টাকা উত্তোলন সফল")
else:
    print("পর্যাপ্ত ব্যালান্স নেই")

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

পর্যাপ্ত ব্যালান্স নেই

কী-ওয়ার্ড: কোড ছোট, পুনরাবৃত্তিমূলক কাজ স্বয়ংক্রিয়, সময় সাশ্রয়, ভুল কম

লুপিং ব্যবহারের সুবিধা:

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

কী-ওয়ার্ড: for লুপ, while লুপ, nested লুপ, এন্ট্রি-কন্ট্রোলড

পাইথনে লুপিং প্রধানত দুই প্রকার:

1. for লুপ: নির্দিষ্ট সংখ্যকবার বা কোনো সিকোয়েন্সের (লিস্ট, স্ট্রিং, range) প্রতিটি উপাদানের জন্য চলে।
2. while লুপ: শর্ত সত্য থাকা পর্যন্ত চলে; কতবার চলবে আগে জানা না থাকলে ব্যবহৃত হয়।

এছাড়া একটি লুপের ভেতরে আরেকটি লুপ থাকলে তাকে nested লুপ বলে। পাইথনের দুটি লুপই এন্ট্রি-কন্ট্রোলড (আগে শর্ত যাচাই হয়); C ভাষার মতো do-while লুপ পাইথনে নেই।

কী-ওয়ার্ড: for লুপ, while লুপ

পাইথনের দুটি লুপিং স্টেটমেন্ট:

1. for লুপ — যেমন for i in range(5):
2. while লুপ — যেমন while i <= 5:

কী-ওয়ার্ড: for ভেরিয়েবল in সিকোয়েন্স:, কোলন, ইনডেন্টেশন, range()

for লুপের সিনট্যাক্স:

for variable in sequence:
    statement(s)      # লুপের দেহ (ইনডেন্টেড)

এখানে sequence হতে পারে range(), লিস্ট, টাপল বা স্ট্রিং। প্রতিবার sequence-এর পরের উপাদানটি variable-এ বসে এবং লুপের দেহ চলে।

fruits = ["আম", "কলা", "লিচু"]
for f in fruits:
    print(f)

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

আম
কলা
লিচু

কী-ওয়ার্ড: তিন ধরন: range(stop), range(start, stop), range(start, stop, step)

range() ফাংশনে সর্বোচ্চ তিনটি প্যারামিটার থাকে: start (শুরুর মান, ডিফল্ট 0), stop (শেষ সীমা, এটি অন্তর্ভুক্ত নয়) ও step (প্রতি ধাপে বৃদ্ধি, ডিফল্ট 1)। এটি তিনভাবে লেখা যায়:

ধরন	উদাহরণ	উৎপন্ন সংখ্যা
range(stop)	range(5)	0, 1, 2, 3, 4
range(start, stop)	range(2, 7)	2, 3, 4, 5, 6
range(start, stop, step)	range(1, 10, 2)	1, 3, 5, 7, 9

print(list(range(5)))          # stop
print(list(range(2, 7)))       # start, stop
print(list(range(1, 10, 2)))   # start, stop, step
print(list(range(10, 0, -3)))  # উল্টো দিকে

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

[0, 1, 2, 3, 4]
[2, 3, 4, 5, 6]
[1, 3, 5, 7, 9]
[10, 7, 4, 1]

কী-ওয়ার্ড: শুধু পূর্ণসংখ্যা, stop অন্তর্ভুক্ত নয়, ডিফল্ট start 0 ও step 1, step শূন্য নয়, ঋণাত্মক step

range() ফাংশন ব্যবহারে বিবেচ্য বিষয়সমূহ:

1. প্যারামিটারগুলো অবশ্যই পূর্ণসংখ্যা (int) হবে; দশমিক দিলে TypeError হয়।
2. stop-এর মান ফলাফলে অন্তর্ভুক্ত হয় না; range(1, 5) মানে 1 থেকে 4।
3. start না দিলে 0 এবং step না দিলে 1 ধরা হয়।
4. step শূন্য হতে পারে না; দিলে ValueError হয়।
5. step ঋণাত্মক হলে সংখ্যা উল্টো দিকে কমে, যেমন range(10, 0, -3) → 10, 7, 4, 1।
6. range() সরাসরি তালিকা দেয় না, একটি range অবজেক্ট দেয়; দেখতে list(range(5)) লিখতে হয়।

কী-ওয়ার্ড: পুনরাবৃত্তির সংখ্যা অজানা, শর্তভিত্তিক, ইনপুট যাচাই, মেনু-চালিত প্রোগ্রাম

কোনো কাজ কতবার পুনরাবৃত্তি হবে তা আগে থেকে জানা না থাকলে এবং একটি শর্ত সত্য থাকা পর্যন্ত কাজ চালিয়ে যেতে হলে while লুপ ব্যবহার করা হয়। যেমন সঠিক পাসওয়ার্ড না দেওয়া পর্যন্ত বারবার চাওয়া।

password = ""
tries = 0
while password != "1234":
    password = input("পাসওয়ার্ড দাও: ")
    tries += 1
print(tries, "বার চেষ্টায় সঠিক হয়েছে")

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

পাসওয়ার্ড দাও: 1111
পাসওয়ার্ড দাও: 1234
2 বার চেষ্টায় সঠিক হয়েছে

কী-ওয়ার্ড: while শর্ত:, কোলন, ইনডেন্টেড দেহ, মান পরিবর্তন

while লুপের সিনট্যাক্স:

initialization            # শুরুর মান
while condition:
    statement(s)
    update               # মান পরিবর্তন, নইলে অসীম লুপ

i = 1
while i <= 5:
    print(i, end=" ")
    i += 1

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

1 2 3 4 5

কী-ওয়ার্ড: লুপের ভেতরে লুপ, বাইরের লুপের প্রতি ধাপে ভেতরের লুপ সম্পূর্ণ চলে

Nested লুপিং: একটি লুপের ভেতরে আরেকটি লুপ থাকলে তাকে nested লুপিং বলে। বাইরের লুপের প্রতিটি ধাপে ভেতরের লুপ সম্পূর্ণভাবে চলে। বাইরের লুপ m বার এবং ভেতরের লুপ n বার চললে ভেতরের দেহ মোট m × n বার চলে। প্যাটার্ন, নামতা ও টেবিল তৈরিতে এটি ব্যবহৃত হয়।

for i in range(1, 3):
    for j in range(1, 4):
        print(i, "x", j, "=", i * j)

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

1 x 1 = 1
1 x 2 = 2
1 x 3 = 3
2 x 1 = 2
2 x 2 = 4
2 x 3 = 6

কী-ওয়ার্ড: for লুপের ভেতরে for লুপ, সারি-কলাম, প্যাটার্ন

Nested for লুপ: একটি for লুপের ভেতরে আরেকটি for লুপ থাকলে তাকে nested for লুপ বলে। সাধারণত বাইরের লুপ সারি (Row) এবং ভেতরের লুপ কলাম নিয়ন্ত্রণ করে।

for i in range(1, 4):          # বাইরের লুপ: সারি
    for j in range(1, i + 1):  # ভেতরের লুপ: কলাম
        print("*", end=" ")
    print()

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

* 
* * 
* * *

কী-ওয়ার্ড: বাইরের for, ভেতরের for, দুই স্তরের ইনডেন্টেশন

nested for লুপের সিনট্যাক্স:

for outer_var in sequence1:
    for inner_var in sequence2:
        statement(s)      # ভেতরের লুপের দেহ
    statement(s)          # বাইরের লুপের দেহ

for i in range(1, 4):          # বাইরের লুপ: সারি
    for j in range(1, i + 1):  # ভেতরের লুপ: কলাম
        print("*", end=" ")
    print()

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

* 
* * 
* * *

কী-ওয়ার্ড: while লুপের ভেতরে while লুপ, প্রতিটির নিজস্ব শর্ত ও মান পরিবর্তন

Nested while লুপ: একটি while লুপের ভেতরে আরেকটি while লুপ থাকলে তাকে nested while লুপ বলে। প্রতিটি লুপের নিজস্ব শর্ত থাকে; বাইরের লুপের প্রতিটি ধাপে ভেতরের লুপ তার শর্ত মিথ্যা না হওয়া পর্যন্ত চলে।

i = 1
while i <= 3:
    j = 1
    while j <= i:
        print(j, end=" ")
        j += 1
    print()
    i += 1

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

1 
1 2 
1 2 3

কী-ওয়ার্ড: বাইরের while শর্ত, ভেতরের while শর্ত, ভেতরের ভেরিয়েবল রিসেট, দুটি আপডেট

nested while লুপের সিনট্যাক্স:

while outer_condition:
    inner_init
    while inner_condition:
        statement(s)
        inner_update
    outer_update

i = 1
while i <= 3:
    j = 1
    while j <= i:
        print(j, end=" ")
        j += 1
    print()
    i += 1

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

1 
1 2 
1 2 3

কী-ওয়ার্ড: লুপ তাৎক্ষণিক বন্ধ, লুপের পরের লাইনে যায়, শর্তের সাথে ব্যবহার

break স্টেটমেন্ট: লুপ চলাকালীন কোনো নির্দিষ্ট শর্ত পূরণ হলে লুপকে তাৎক্ষণিকভাবে বন্ধ করে লুপের পরের স্টেটমেন্টে নিয়ে যায়। সাধারণত if-এর সাথে ব্যবহৃত হয়।

for i in range(1, 11):
    if i == 5:
        break          # i = 5 হলে লুপ থেমে যাবে
    print(i, end=" ")

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

1 2 3 4

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

continue স্টেটমেন্ট: লুপের বর্তমান ধাপের বাকি স্টেটমেন্টগুলো বাদ দিয়ে সরাসরি পরের ধাপে (Iteration) চলে যায়; লুপ বন্ধ হয় না।

for i in range(1, 8):
    if i % 2 == 0:
        continue       # জোড় সংখ্যা বাদ দিয়ে পরের ধাপে
    print(i, end=" ")

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

1 3 5 7

কী-ওয়ার্ড: for i in range(), নির্দিষ্ট সংখ্যকবার, যোগফল নির্ণয়

for লুপের সাথে range() ব্যবহার করে নির্দিষ্ট সংখ্যকবার কাজ পুনরাবৃত্তি করা যায়। উদাহরণ — ১ থেকে ১০ পর্যন্ত সংখ্যার যোগফল:

total = 0
for i in range(1, 11):
    total += i
print("১ থেকে ১০ এর যোগফল =", total)

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

১ থেকে ১০ এর যোগফল = 55

এখানে range(1, 11) দিয়ে 1 থেকে 10 পর্যন্ত সংখ্যা পাওয়া যায় (11 অন্তর্ভুক্ত নয়)।

কী-ওয়ার্ড: বাইরের লুপ সারি, ভেতরের লুপ কলাম, print(), ফ্লোচার্ট, তারকা প্যাটার্ন

গঠন: একটি for লুপের ভেতরে আরেকটি for লুপ থাকে। বাইরের লুপের প্রতি ধাপে ভেতরের লুপ শুরু থেকে শেষ পর্যন্ত চলে।

for i in range(1, 4):
    for j in range(1, i + 1):
        print("*", end=" ")
    print()

উদাহরণের আউটপুট:

* 
* * 
* * *

ব্যাখ্যা: i = 1 হলে ভেতরের লুপ ১ বার, i = 2 হলে ২ বার, i = 3 হলে ৩ বার "*" প্রিন্ট করে। প্রতিটি সারি শেষে print() নতুন লাইন দেয়।

ফ্লোচার্ট:

কী-ওয়ার্ড: break লুপ বন্ধ করে, continue পরের ধাপে যায়, উদাহরণ

break: শর্ত পূরণ হলে লুপ পুরোপুরি থামিয়ে দেয়।

for i in range(1, 11):
    if i == 5:
        break          # i = 5 হলে লুপ থেমে যাবে
    print(i, end=" ")

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

1 2 3 4

continue: শর্ত পূরণ হলে বর্তমান ধাপ বাদ দিয়ে পরের ধাপে যায়।

for i in range(1, 8):
    if i % 2 == 0:
        continue       # জোড় সংখ্যা বাদ দিয়ে পরের ধাপে
    print(i, end=" ")

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

1 3 5 7

	break	continue
লুপের অবস্থা	সম্পূর্ণ বন্ধ	চলতে থাকে
নিয়ন্ত্রণ যায়	লুপের পরের স্টেটমেন্টে	লুপের পরের ধাপে

কী-ওয়ার্ড: পুনরাবৃত্তির সংখ্যা জানা বনাম অজানা, সিকোয়েন্সভিত্তিক বনাম শর্তভিত্তিক, আপডেট

for ও while লুপের মূল পার্থক্য:

বিষয়	for লুপ	while লুপ
ব্যবহার	কতবার চলবে আগে থেকে জানা থাকলে	কতবার চলবে আগে জানা না থাকলে, শর্তভিত্তিক
ভিত্তি	সিকোয়েন্স বা range-এর প্রতিটি উপাদান	শর্ত সত্য থাকা পর্যন্ত
মান পরিবর্তন	স্বয়ংক্রিয়ভাবে পরের উপাদান নেয়	লুপের ভেতরে নিজে আপডেট লিখতে হয়
অসীম লুপের ঝুঁকি	সাধারণত নেই	আপডেট ভুলে গেলে অসীম লুপ হয়
উদাহরণ	for i in range(1, 6):	while i <= 5:

কী-ওয়ার্ড: কন্ডিশনাল: if/elif/else; আনকন্ডিশনাল: break, continue, return, ফাংশন কল

কন্ডিশনাল ব্রাঞ্চিং: শর্তের উপর নির্ভর করে প্রোগ্রামের প্রবাহ ভিন্ন পথে যায়। উদাহরণ: if, if-else, elif।

age = int(input("বয়স: "))
if age >= 18:
    print("ভোট দিতে পারবে")
else:
    print("ভোট দিতে পারবে না")

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

বয়স: 16
ভোট দিতে পারবে না

আনকন্ডিশনাল ব্রাঞ্চিং: কোনো শর্ত ছাড়াই নিয়ন্ত্রণ সরাসরি অন্য স্থানে চলে যায়। পাইথনে break, continue, return স্টেটমেন্ট ও ফাংশন কল আনকন্ডিশনাল জাম্প ঘটায় (পাইথনে goto নেই)। নিচের উদাহরণে break স্টেটমেন্টটি চলামাত্র নিয়ন্ত্রণ শর্তহীনভাবে লুপের বাইরে চলে যায়:

for i in range(1, 10):
    if i == 4:
        break        # শর্ত পূরণ হলে লুপ থেকে বের হওয়া
    print(i, end=" ")

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

1 2 3

কী-ওয়ার্ড: লাইনের শুরুতে ফাঁকা স্থান, কোড ব্লক, ৪টি স্পেস, IndentationError

ইনডেন্টেশন: প্রোগ্রামে কোড ব্লক বোঝাতে লাইনের শুরুতে নির্দিষ্ট পরিমাণ ফাঁকা স্থান (সাধারণত ৪টি স্পেস) রাখাকে ইনডেন্টেশন বলে। পাইথনে if, for, while, def ইত্যাদির অধীনের লাইনগুলো ইনডেন্টেশন দিয়েই চিহ্নিত হয়; {} ব্যবহার করা হয় না।

for i in range(3):
    print(i)        # লুপের ভেতরে (ইনডেন্টেড)
print("শেষ")       # লুপের বাইরে

একই ব্লকের সব লাইনে সমান ইনডেন্টেশন রাখতে হয়; না রাখলে IndentationError হয়।

কী-ওয়ার্ড: if শর্ত১:, elif শর্ত২:, else:, কোলন ও ইনডেন্টেশন

elif স্টেটমেন্টের সিনট্যাক্স:

if condition1:
    statement(s)
elif condition2:
    statement(s)
elif condition3:
    statement(s)
else:
    statement(s)

marks = int(input("নম্বর: "))
if marks >= 80:
    grade = "A+"
elif marks >= 70:
    grade = "A"
elif marks >= 60:
    grade = "A-"
elif marks >= 33:
    grade = "পাস"
else:
    grade = "F"
print("গ্রেড:", grade)

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

নম্বর: 72
গ্রেড: A

কী-ওয়ার্ড: if-এর ভেতরে if, বাইরের শর্ত সত্য হলে ভেতরের শর্ত যাচাই

Nested if statement: একটি if বা else ব্লকের ভেতরে আরেকটি if স্টেটমেন্ট থাকলে তাকে nested if বলে। বাইরের শর্ত সত্য হলেই ভেতরের শর্ত যাচাই করা হয়।

marks = 85
if marks >= 33:
    print("পাস")
    if marks >= 80:
        print("গ্রেড: A+")
    else:
        print("গ্রেড: A+ এর নিচে")
else:
    print("ফেল")

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

পাস
গ্রেড: A+

nested if-এর ফ্লোচার্ট

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

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

ধরন	স্টেটমেন্ট
কন্ডিশনাল (সিদ্ধান্ত গ্রহণ)	if, if-else, elif, match-case
লুপিং (পুনরাবৃত্তি)	for, while
জাম্প (নিয়ন্ত্রণ স্থানান্তর)	break, continue, pass, return

কী-ওয়ার্ড: শর্তের সত্য-মিথ্যা অনুযায়ী প্রবাহ, if, elif, else

কন্ডিশনাল প্রোগ্রাম ফ্লো: প্রোগ্রামের প্রবাহ যখন কোনো শর্তের সত্য বা মিথ্যা হওয়ার উপর নির্ভর করে ভিন্ন ভিন্ন পথে যায়, তখন তাকে কন্ডিশনাল প্রোগ্রাম ফ্লো বলে। পাইথনে if, if-else ও elif স্টেটমেন্টের মাধ্যমে এটি বাস্তবায়ন করা হয়।

age = int(input("বয়স: "))
if age >= 18:
    print("ভোট দিতে পারবে")
else:
    print("ভোট দিতে পারবে না")

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

বয়স: 16
ভোট দিতে পারবে না

কন্ডিশনাল প্রবাহ (if-else)

কী-ওয়ার্ড: if শর্ত:, কোলন, ইনডেন্টেড স্টেটমেন্ট

if স্টেটমেন্টের সিনট্যাক্স:

if condition:
    statement(s)     # শর্ত সত্য হলে চলবে

marks = 75
if marks >= 33:
    print("অভিনন্দন! তুমি পাস করেছ")
print("ফলাফল প্রকাশিত")

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

অভিনন্দন! তুমি পাস করেছ
ফলাফল প্রকাশিত

কী-ওয়ার্ড: শুরু, ইনপুট, শর্ত যাচাই, হ্যাঁ হলে কাজ, না হলে সরাসরি শেষ

if স্টেটমেন্টে শর্ত সত্য হলে নির্দিষ্ট কাজ হয়; মিথ্যা হলে কাজটি বাদ দিয়ে প্রোগ্রাম সামনে এগোয়।

কী-ওয়ার্ড: শর্ত সত্য হলে if ব্লক, মিথ্যা হলে else ব্লক, দুই পথ মিলিত

if-else স্টেটমেন্টে শর্ত সত্য হলে if ব্লক এবং মিথ্যা হলে else ব্লক চলে; এরপর দুই পথ মিলিত হয়।

age = int(input("বয়স: "))
if age >= 18:
    print("ভোট দিতে পারবে")
else:
    print("ভোট দিতে পারবে না")

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

বয়স: 16
ভোট দিতে পারবে না

কী-ওয়ার্ড: তিনটি input(), if-elif-else, and অপারেটর, সবচেয়ে বড় সংখ্যা প্রিন্ট

পাইথন প্রোগ্রাম:

a = int(input("প্রথম সংখ্যা: "))
b = int(input("দ্বিতীয় সংখ্যা: "))
c = int(input("তৃতীয় সংখ্যা: "))
if a >= b and a >= c:
    largest = a
elif b >= a and b >= c:
    largest = b
else:
    largest = c
print("সবচেয়ে বড় সংখ্যা =", largest)

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

প্রথম সংখ্যা: 25
দ্বিতীয় সংখ্যা: 48
তৃতীয় সংখ্যা: 17
সবচেয়ে বড় সংখ্যা = 48

ব্যাখ্যা: প্রথমে তিনটি সংখ্যা ইনপুট নেওয়া হয়। a যদি b ও c উভয়ের সমান বা বড় হয় তবে a বড়; না হলে b যদি a ও c-এর সমান বা বড় হয় তবে b বড়; অন্যথায় c বড়।

সংক্ষিপ্ত বিকল্প: বিল্ট-ইন ফাংশন দিয়ে: print(max(a, b, c))

ফ্লোচার্ট:

কী-ওয়ার্ড: সিকুয়েন্সিয়াল, সিলেকশন/ব্রাঞ্চিং (if, elif, nested if, match), লুপ (for, while), জাম্প (break, continue, pass)

ভূমিকা: প্রোগ্রামের স্টেটমেন্টগুলো কোন ক্রমে চলবে তা নিয়ন্ত্রণের কাঠামোকে কন্ট্রোল স্ট্রাকচার বলে। পাইথনে কন্ট্রোল স্ট্রাকচার প্রধানত তিন প্রকার:

১. সিকুয়েন্সিয়াল স্ট্রাকচার

স্টেটমেন্টগুলো উপর থেকে নিচে ক্রমানুসারে একবার করে চলে।

# সিকুয়েন্সিয়াল স্ট্রাকচার: প্রতিটি লাইন ক্রমানুসারে একবার চলে
length = 10
width = 5
area = length * width
print("ক্ষেত্রফল =", area)

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

ক্ষেত্রফল = 50

২. সিলেকশন বা ব্রাঞ্চিং স্ট্রাকচার

শর্ত অনুযায়ী ভিন্ন ভিন্ন পথে প্রোগ্রাম চলে। এর প্রকারভেদ: if, if-else, if-elif-else, nested if এবং পাইথন ৩.১০ থেকে match-case।

marks = int(input("নম্বর: "))
if marks >= 80:
    grade = "A+"
elif marks >= 70:
    grade = "A"
elif marks >= 60:
    grade = "A-"
elif marks >= 33:
    grade = "পাস"
else:
    grade = "F"
print("গ্রেড:", grade)

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

নম্বর: 72
গ্রেড: A

৩. লুপ বা ইটারেশন স্ট্রাকচার

শর্ত সত্য থাকা পর্যন্ত বা নির্দিষ্ট সংখ্যকবার একই কাজ পুনরাবৃত্তি হয়: for লুপ ও while লুপ।

total = 0
for i in range(1, 11):
    total += i
print("১ থেকে ১০ এর যোগফল =", total)

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

১ থেকে ১০ এর যোগফল = 55

লুপ নিয়ন্ত্রণ (জাম্প) স্টেটমেন্ট

break (লুপ বন্ধ), continue (পরের ধাপে যাওয়া) ও pass (কিছু না করা)।

উপসংহার: এই তিন কাঠামোর সমন্বয়েই যেকোনো জটিল প্রোগ্রাম তৈরি করা যায়।

কী-ওয়ার্ড: সিকুয়েন্সিয়াল: সরল প্রবাহ; ব্রাঞ্চ: রম্বস দিয়ে শাখা; লুপ: পেছনে ফেরা তীর

১. সিকুয়েন্সিয়াল স্ট্রাকচার

প্রতিটি ধাপ পরপর একবার করে চলে; কোনো শাখা বা পুনরাবৃত্তি নেই।

২. ব্রাঞ্চ (সিলেকশন) স্ট্রাকচার

ডিসিশন প্রতীকে শর্ত যাচাই করে হ্যাঁ/না অনুযায়ী ভিন্ন পথে যায়।

৩. লুপ (ইটারেশন) স্ট্রাকচার

শর্ত সত্য থাকা পর্যন্ত লুপের দেহ চলে এবং তীরচিহ্ন আবার শর্তে ফিরে যায়।

কী-ওয়ার্ড: break: লুপ বন্ধ; continue: পরের ধাপে; pass: কিছু করে না (স্থান সংরক্ষক)

ভূমিকা: লুপের স্বাভাবিক প্রবাহ নিয়ন্ত্রণের জন্য পাইথনে তিনটি বিশেষ স্টেটমেন্ট আছে:

১. break স্টেটমেন্ট

শর্ত পূরণ হলে লুপকে তাৎক্ষণিকভাবে সম্পূর্ণ বন্ধ করে দেয় এবং নিয়ন্ত্রণ লুপের পরের স্টেটমেন্টে চলে যায়।

for i in range(1, 11):
    if i == 5:
        break          # i = 5 হলে লুপ থেমে যাবে
    print(i, end=" ")

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

1 2 3 4

২. continue স্টেটমেন্ট

বর্তমান ধাপের বাকি অংশ বাদ দিয়ে লুপের পরের ধাপে চলে যায়; লুপ বন্ধ হয় না।

for i in range(1, 8):
    if i % 2 == 0:
        continue       # জোড় সংখ্যা বাদ দিয়ে পরের ধাপে
    print(i, end=" ")

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

1 3 5 7

৩. pass স্টেটমেন্ট

কোনো কাজ করে না; শুধু স্থান সংরক্ষক (Placeholder) হিসেবে ব্যবহৃত হয়। পাইথনে ফাঁকা ব্লক রাখা যায় না, তাই পরে কোড লিখব এমন জায়গায় pass বসানো হয়।

for i in range(3):
    pass           # এখনও কিছু লেখা হয়নি, কিন্তু ত্রুটি হবে না

def future_function():
    pass

print("pass কোনো কাজ করে না")

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

pass কোনো কাজ করে না

স্টেটমেন্ট	লুপের উপর প্রভাব	সাধারণ ব্যবহার
break	লুপ সম্পূর্ণ বন্ধ	কাঙ্ক্ষিত মান পেলে খোঁজা বন্ধ
continue	বর্তমান ধাপ বাদ, লুপ চলে	নির্দিষ্ট মান বাদ দেওয়া
pass	কোনো প্রভাব নেই	ফাঁকা ব্লকের স্থান সংরক্ষণ

কী-ওয়ার্ড: if, if-else, if-elif-else, nested if, match-case, সিনট্যাক্স ও উদাহরণ

ভূমিকা: শর্তের সত্য-মিথ্যার উপর ভিত্তি করে ভিন্ন কোড চালানোর স্টেটমেন্টকে কন্ডিশনাল স্টেটমেন্ট বলে। পাইথনের কন্ডিশনাল স্টেটমেন্টগুলো:

১. if স্টেটমেন্ট

শর্ত সত্য হলে একটি ব্লক চলে।

marks = 75
if marks >= 33:
    print("অভিনন্দন! তুমি পাস করেছ")
print("ফলাফল প্রকাশিত")

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

অভিনন্দন! তুমি পাস করেছ
ফলাফল প্রকাশিত

২. if-else স্টেটমেন্ট

শর্ত সত্য হলে if ব্লক, মিথ্যা হলে else ব্লক চলে।

age = int(input("বয়স: "))
if age >= 18:
    print("ভোট দিতে পারবে")
else:
    print("ভোট দিতে পারবে না")

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

বয়স: 16
ভোট দিতে পারবে না

৩. if-elif-else স্টেটমেন্ট

একাধিক শর্ত পরপর যাচাই করে প্রথম সত্য শর্তের ব্লক চালায়।

marks = int(input("নম্বর: "))
if marks >= 80:
    grade = "A+"
elif marks >= 70:
    grade = "A"
elif marks >= 60:
    grade = "A-"
elif marks >= 33:
    grade = "পাস"
else:
    grade = "F"
print("গ্রেড:", grade)

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

নম্বর: 72
গ্রেড: A

৪. nested if স্টেটমেন্ট

একটি if-এর ভেতরে আরেকটি if।

marks = 85
if marks >= 33:
    print("পাস")
    if marks >= 80:
        print("গ্রেড: A+")
    else:
        print("গ্রেড: A+ এর নিচে")
else:
    print("ফেল")

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

পাস
গ্রেড: A+

৫. match-case (পাইথন ৩.১০+)

একটি মানকে বিভিন্ন সম্ভাব্য মানের সাথে মিলিয়ে সংশ্লিষ্ট ব্লক চালায়।

day = 5
match day:
    case 5:
        print("শুক্রবার — ছুটি")
    case 6:
        print("শনিবার")
    case _:
        print("কর্মদিবস")

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

শুক্রবার — ছুটি

কী-ওয়ার্ড: input(), if n > 0 Positive, elif n < 0 Negative, else শূন্য

পাইথন প্রোগ্রাম:

n = float(input("একটি সংখ্যা দাও: "))
if n > 0:
    print("সংখ্যাটি Positive")
elif n < 0:
    print("সংখ্যাটি Negative")
else:
    print("সংখ্যাটি শূন্য")

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

একটি সংখ্যা দাও: -7
সংখ্যাটি Negative

ব্যাখ্যা: সংখ্যাটি 0-এর বড় হলে Positive, 0-এর ছোট হলে Negative, আর কোনোটিই না হলে সংখ্যাটি শূন্য।

Positive/Negative নির্ণয়ের ফ্লোচার্ট

কী-ওয়ার্ড: for i in range(1, n+1), i % 2 == 0, even_sum ও odd_sum আলাদা যোগ

পাইথন প্রোগ্রাম:

n = int(input("n এর মান দাও: "))
even_sum = 0
odd_sum = 0
for i in range(1, n + 1):
    if i % 2 == 0:
        even_sum += i
    else:
        odd_sum += i
print("জোড় সংখ্যার যোগফল =", even_sum)
print("বিজোড় সংখ্যার যোগফল =", odd_sum)

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

n এর মান দাও: 10
জোড় সংখ্যার যোগফল = 30
বিজোড় সংখ্যার যোগফল = 25

ব্যাখ্যা: range(1, n + 1) দিয়ে 1 থেকে n পর্যন্ত প্রতিটি সংখ্যা নেওয়া হয়। সংখ্যাটি 2 দিয়ে নিঃশেষে বিভাজ্য হলে জোড় যোগফলে, না হলে বিজোড় যোগফলে যোগ হয়। n = 10 হলে জোড়: 2+4+6+8+10 = 30, বিজোড়: 1+3+5+7+9 = 25।

কী-ওয়ার্ড: n < 2 প্রাইম নয়, 2 থেকে √n পর্যন্ত ভাগ, ভাগ গেলে break, ফ্ল্যাগ ভেরিয়েবল

যে সংখ্যা 1-এর চেয়ে বড় এবং 1 ও সংখ্যাটি নিজে ছাড়া অন্য কোনো সংখ্যা দিয়ে নিঃশেষে বিভাজ্য নয়, তাকে প্রাইম (মৌলিক) নাম্বার বলে।

পাইথন প্রোগ্রাম:

n = int(input("একটি পূর্ণসংখ্যা দাও: "))
if n < 2:
    print(n, "প্রাইম নাম্বার নয়")
else:
    is_prime = True
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            is_prime = False
            break
    if is_prime:
        print(n, "একটি প্রাইম নাম্বার")
    else:
        print(n, "প্রাইম নাম্বার নয়")

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

একটি পূর্ণসংখ্যা দাও: 29
29 একটি প্রাইম নাম্বার

ব্যাখ্যা: 2-এর ছোট সংখ্যা প্রাইম নয়। এরপর 2 থেকে √n পর্যন্ত প্রতিটি সংখ্যা দিয়ে ভাগ করা হয়; কোনোটি দিয়ে নিঃশেষে ভাগ গেলে সংখ্যাটি প্রাইম নয় এবং break দিয়ে লুপ থামানো হয়। √n পর্যন্ত যাচাই করাই যথেষ্ট, কারণ n-এর কোনো উৎপাদক √n-এর বড় হলে তার জোড়া উৎপাদকটি √n-এর ছোট হবে।