আউটপুট কী হবে? — Python কোড পড়ার অনুশীলন

(মাঝারি) একটি set-এ তিনটি string — CPython 3.14-এ একটি .py ফাইল হিসেবে চালালে কী ছাপা হবে?

print({"a", "b", "c"})

• {'a', 'b', 'c'}
• {'a', 'b', 'c'} — কারণ set নিজে থেকে সাজায়
• {'c', 'b', 'a'}
• তিনটি অক্ষরই থাকবে, কিন্তু ক্রম নিশ্চিত নয় — চালানো থেকে চালানোয় বদলাতে পারে

(সহজ) চার রকম ভাগ — কী ছাপা হবে?

print(7 / 2, 7 // 2, -7 // 2, -7 % 3)

• 3.5 3 -3 -1
• 3.5 3 -4 2
• 3 3 -4 2
• 3.5 3.5 -3.5 2

(মাঝারি) round() কোন দিকে গোল করে?

print(round(2.5), round(3.5), round(2.675, 2))

• 3 4 2.68
• 2 4 2.67
• 2 3 2.67
• 3 4 2.67

(সহজ) 0.1 + 0.2 কি 0.3?

print(0.1 + 0.2 == 0.3, 0.1 + 0.2)

• True 0.3
• False 0.3
• False 0.30000000000000004
• True 0.30000000000000004

(মাঝারি) f-string-এর format spec — ঠিক কী দেখা যাবে?

x = 3.14159
n = 42
print(f"{x:.2f}|{n:>5}|{n:05}|{'ab':*^6}|")

• 3.14|42 |00042|**ab**|
• 3.14| 42|00042|**ab**|
• 3.14159| 42|42000|ab****|
• 3.14| 42| 42|**ab**|

(মাঝারি) Chained comparison — কী ছাপা হবে?

print(5 > 3 > 1, 3 > 2 == True, 1 < 3 > 2)

• True True True
• True False True
• False False True
• SyntaxError

(মাঝারি) and/or কী ফেরত দেয়?

print(0 or "x", repr("" and 5), [] or [0], 3 and 4)

• True False True True
• x 5 [0] 3
• x '' [0] 4
• x False [0] True

(কঠিন) is বনাম == — একটি .py ফাইল হিসেবে CPython 3.14-এ কী ছাপা হবে?

a = 1000
b = 1000
x = int("1000")
y = int("1000")
print(a == x, a is b, x is y)

• True False False
• True True False
• True True True
• False True False

(সহজ) for-এর পরে else — কী ছাপা হবে?

for n in [3, 5, 8, 9]:
    if n % 2 == 0:
        print("even", n)
        break
else:
    print("none")

for n in [3, 5]:
    if n % 2 == 0:
        break
else:
    print("none")

• শুধু even 8
• even 8, তারপর none (দুই লাইনে)
• none, তারপর none
• even 8, none, none

(মাঝারি) Mutable default, এক print-এ তিন ডাক — কী ছাপা হবে?

def add(x, box=[]):
    box.append(x)
    return box

print(add(1), add(2), add(3, []))

• [1] [2] [3]
• [1] [1, 2] [3]
• [1, 2] [1, 2] [3]
• [1] [1, 2] [1, 2, 3]

(মাঝারি) Default মান কখন ঠিক হয়?

n = 10
def f(x=n):
    return x
n = 20
print(f())

• 10
• 20
• NameError
• None

(মাঝারি) Keyword-only parameter — কী ঘটবে?

def f(a, b=2, *, c=3):
    return a + b * c

print(f(1), f(1, c=10))
print(f(1, 2, 3))

• 7 21, তারপর 9
• 7 21, তারপর TypeError
• শুধু TypeError — কিছুই ছাপা হয় না
• 7 33, তারপর TypeError

(মাঝারি) Recursion-এ ডাকের আগে আর পরে print

def show(n):
    if n == 0:
        return
    print(n, end=" ")
    show(n - 1)
    print(n, end=" ")

show(3)

• 3 2 1
• 3 2 1 1 2 3
• 3 2 1 0 1 2 3
• 1 2 3 3 2 1

(কঠিন) Global ভ্যারিয়েবল ফাংশনের ভেতরে বাড়ানো

count = 0
def inc():
    count += 1
inc()
print(count)

• 1
• 0
• UnboundLocalError
• NameError

(কঠিন) match-এ একটি constant-এর নাম — কী ছাপা হবে?

RED = "red"
color = "blue"
match color:
    case RED:
        print("matched", RED)

• কিছুই ছাপা হয় না
• matched red
• matched blue
• SyntaxError

(সহজ) Alias আর slice-কপি

a = [1, 2, 3]
b = a
b.append(4)
c = a[:]
c.append(5)
print(a, len(c))

• [1, 2, 3] 4
• [1, 2, 3, 4] 5
• [1, 2, 3, 4, 5] 5
• [1, 2, 3] 5

(মাঝারি) * 3 দিয়ে বানানো grid

grid = [[0] * 3] * 3
grid[0][0] = 1
print(grid)

• [[1, 0, 0], [1, 0, 0], [1, 0, 0]]
• [[1, 0, 0], [0, 0, 0], [0, 0, 0]]
• [[1, 1, 1], [0, 0, 0], [0, 0, 0]]
• TypeError

(সহজ) sort() আর sorted()

nums = [3, 1, 2]
r = nums.sort()
print(r, nums, sorted("bca"))

• None [1, 2, 3] ['a', 'b', 'c']
• [1, 2, 3] [1, 2, 3] ['a', 'b', 'c']
• None [3, 1, 2] abc
• [1, 2, 3] [3, 1, 2] ['a', 'b', 'c']

(মাঝারি) একই key দুইবার

d = {"b": 1, "a": 2, "b": 3}
print(d, list(d))

• {'b': 3, 'a': 2} ['b', 'a']
• {'a': 2, 'b': 3} ['a', 'b']
• {'b': 1, 'a': 2, 'b': 3} ['b', 'a', 'b']
• SyntaxError

(মাঝারি) dict.get আর [] একই print-এ

d = {"x": 1}
print(d.get("y"), d.get("y", 0), d["y"])

• None 0, তারপর KeyError
• None 0 None
• KeyError: 'y' — কিছুই ছাপা হয় না
• None 0 KeyError

(কঠিন) set-এ 1, True আর 1.0

print({1, True, 1.0}, len({3, 1, 3, 2, 1}))

• {1, True, 1.0} 5
• {1} 3
• {1, 1.0} 3
• {True} 3

(কঠিন) tuple-এর ভেতরের list-এ +=

t = (1, [2])
try:
    t[1] += [3]
except TypeError:
    print("TypeError")
print(t)

• শুধু (1, [2, 3])
• TypeError, তারপর (1, [2, 3])
• TypeError, তারপর (1, [2])
• (1, [2], [3])

(মাঝারি) লুপ চলার সময় list থেকে মোছা

nums = [2, 2, 3]
for n in nums:
    if n == 2:
        nums.remove(n)
print(nums)

• [2, 3]
• [3]
• [2, 2, 3]
• RuntimeError

(মাঝারি) একই module তিনবার import — python main.py চালালে কী ছাপা হবে?

# helper.py
print("loading", __name__)
VALUE = 42

# main.py
import helper
import helper
from helper import VALUE
print(__name__, VALUE)

• loading helper, তারপর __main__ 42
• loading helper তিনবার, তারপর __main__ 42
• loading __main__, তারপর main 42
• loading helper দুইবার, তারপর __main__ 42

(সহজ) ওপরের helper.py ফাইলটি সরাসরি python helper.py দিয়ে চালালে কী ছাপা হবে?

# helper.py
print("loading", __name__)
VALUE = 42

• loading helper
• loading __main__
• loading main
• loading helper.py

(মাঝারি) try, except, else, finally আর return

def f(x):
    try:
        r = 10 // x
    except ZeroDivisionError:
        print("E", end=" ")
        return -1
    else:
        print("L", end=" ")
        return r
    finally:
        print("F", end=" ")

print(f(2))
print(f(0))

• L F 5, তারপর E F -1
• L 5 F, তারপর E -1 F
• L F 5, তারপর E L F -1
• L F 5, তারপর E -1

(কঠিন) try-তে return, finally-তেও return — CPython 3.14-এ কী ঘটবে?

def g():
    try:
        return "try"
    finally:
        return "finally"

print(g())

• try
• finally (সঙ্গে stderr-এ একটি SyntaxWarning)
• try, তারপর finally
• SyntaxError

(কঠিন) except-এর নামটি ব্লকের পরে

try:
    1 / 0
except ZeroDivisionError as e:
    pass
print(e)

• division by zero
• None
• ZeroDivisionError('division by zero')
• NameError

(মাঝারি) ফাইলের মোড "w" আর "a"

from pathlib import Path
p = Path("note.txt")
p.write_text("one\n")
with open(p, "w") as f:
    f.write("two\n")
with open(p, "a") as f:
    f.write("three\n")
print(p.read_text().splitlines())

• ['one', 'two', 'three']
• ['three']
• ['two', 'three']
• ['two\n', 'three\n']

(সহজ) Class attribute বনাম instance attribute

class Dog:
    sound = "woof"

a, b = Dog(), Dog()
a.sound = "bark"
Dog.sound = "grr"
print(a.sound, b.sound)

• bark grr
• bark woof
• grr grr
• bark bark

(মাঝারি) Class-এ রাখা list

class Team:
    members = []
    def add(self, m):
        self.members.append(m)

x, y = Team(), Team()
x.add("Sakib")
y.add("Tamim")
print(x.members)

• ['Sakib', 'Tamim']
• ['Sakib']
• []
• AttributeError

(কঠিন) Diamond inheritance আর super()

class A:
    def hi(self): print("A", end=" ")
class B(A):
    def hi(self): print("B", end=" "); super().hi()
class C(A):
    def hi(self): print("C", end=" "); super().hi()
class D(B, C):
    def hi(self): print("D", end=" "); super().hi()

D().hi()

• D B C A
• D B A C A
• D B A
• D C B A

(কঠিন) __eq__ আছে, __hash__ নেই — CPython 3.14-এ কী ঘটবে?

class P:
    def __init__(self, x): self.x = x
    def __eq__(self, o): return self.x == o.x

print(P(1) == P(1))
print({P(1)})

• True, তারপর {<__main__.P object at …>}
• True, তারপর TypeError
• False, তারপর TypeError
• শুধু TypeError

(মাঝারি) __str__ আর __repr__ — কোনটি কখন?

class Taka:
    def __init__(self, v): self.v = v
    def __str__(self): return f"৳{self.v}"
    def __repr__(self): return f"Taka({self.v})"

t = Taka(50)
print(t, [t], f"{t!r}")

• ৳50 [Taka(50)] Taka(50)
• ৳50 [৳50] Taka(50)
• Taka(50) [Taka(50)] Taka(50)
• ৳50 [৳50] ৳50

(মাঝারি) Setter ছাড়া property

class Temp:
    def __init__(self): self._c = 0
    @property
    def f(self): return self._c * 9 / 5 + 32

t = Temp()
t._c = 100
print(t.f)
t.f = 50

• 212.0, তারপর AttributeError
• শুধু 212.0 — শেষ লাইন নিঃশব্দে f বদলায়
• 212, তারপর AttributeError
• শুধু AttributeError

(সহজ) dataclass-এর repr আর ==

from dataclasses import dataclass

@dataclass
class Point:
    x: int
    y: int = 0

p, q = Point(1), Point(1, 0)
print(p, p == q, p is q)

• Point(x=1, y=0) True False
• <__main__.Point object at …> False False
• Point(x=1, y=0) True True
• Point(1, 0) True False

(মাঝারি) একই generator দুবার ব্যবহার

g = (n * n for n in range(4))
print(sum(g), sum(g), list(g))

• 14 0 []
• 14 14 [0, 1, 4, 9]
• 14 0 [0, 1, 4, 9]
• 14, তারপর StopIteration

(মাঝারি) দুটি decorator — কোনটি বাইরে?

def bold(f): return lambda: "<b>" + f() + "</b>"
def ital(f): return lambda: "<i>" + f() + "</i>"

@bold
@ital
def hi(): return "hi"

print(hi())

• <i><b>hi</b></i>
• <b>hi</b>
• <b><i>hi</i></b>
• <b>hi</b><i>hi</i>

(মাঝারি) এক with-এ দুটি context manager

class CM:
    def __init__(self, n): self.n = n
    def __enter__(self):
        print("enter", self.n)
        return self
    def __exit__(self, *exc):
        print("exit", self.n)
        return False

with CM(1), CM(2):
    print("body")

• enter 1 → enter 2 → body → exit 2 → exit 1
• enter 1 → enter 2 → body → exit 1 → exit 2
• enter 1 → exit 1 → enter 2 → body → exit 2
• enter 2 → enter 1 → body → exit 1 → exit 2

(কঠিন) __exit__ True ফেরত দিলে

class Quiet:
    def __enter__(self): return self
    def __exit__(self, et, ev, tb):
        print("exit:", et.__name__)
        return True

with Quiet():
    1 / 0
    print("after")
print("next")

• exit: ZeroDivisionError, after, next
• exit: ZeroDivisionError, তারপর next
• exit: ZeroDivisionError, তারপর traceback
• শুধু next

(মাঝারি) লুপে বানানো lambda

fs = [lambda: i for i in range(3)]
print([f() for f in fs])

• [2, 2, 2]
• [0, 1, 2]
• [3, 3, 3]
• NameError

(মাঝারি) না সাজিয়ে groupby

from itertools import groupby
print([(k, len(list(g))) for k, g in groupby("aabba")])

• [('a', 2), ('b', 2), ('a', 1)]
• [('a', 3), ('b', 2)]
• [('a', 2), ('b', 2)]
• TypeError

(সহজ) Type hint কি চলার সময় যাচাই হয়?

def double(x: int) -> int:
    return x * 2

print(double("ha"), double([0]))

• haha [0, 0]
• TypeError
• None None
• mypy-র error বার্তা ছাপা হয়

(কঠিন) asyncio.gather — কোন ক্রমে?

import asyncio

async def job(name, delay):
    await asyncio.sleep(delay)
    print("done", name)
    return name

async def main():
    r = await asyncio.gather(job("A", 0.2), job("B", 0.1))
    print(r)

asyncio.run(main())

• done B → done A → ['A', 'B']
• done A → done B → ['A', 'B']
• done B → done A → ['B', 'A']
• done B → done A → None

(মাঝারি) Thread আর join() — কোন আউটপুট নিশ্চিত?

import threading

results = []
def work(n):
    results.append(n * n)

ts = [threading.Thread(target=work, args=(i,)) for i in range(4)]
for t in ts: t.start()
for t in ts: t.join()
print(sorted(results), len(results))

• [0, 1, 4, 9] 4
• ক্রম অনিশ্চিত, তাই আউটপুট বলা যায় না
• [] 0
• কখনো কখনো তিনটি মান — race condition

(সহজ) খালি list-এ any, all আর sum

print(any([]), all([]), sum([], 10))

• False True 10
• False False 0
• True True 10
• None None 10

(মাঝারি) dict-এর ওপর max

d = {"x": 9, "y": 2}
print(max(d), max(d, key=d.get), sorted(d, key=d.get))

• y x ['y', 'x']
• x x ['y', 'x']
• 9 9 [2, 9]
• y y ['x', 'y']

(মাঝারি) \d কি বাংলা অঙ্ক চেনে?

import re
t = "মূল্য ১২০ টাকা, 30 tk"
print(re.findall(r"\d+", t), re.findall(r"\d+", t, re.ASCII))

• ['১২০', '30'] ['30']
• ['30'] ['30']
• ['১', '২', '০', '30'] ['30']
• ['30'] []

(মাঝারি) বাংলা string-এর দৈর্ঘ্য

s = "বাংলা"
print(len(s), len("ক্ষ"), s[0])

• 5 3 ব
• 3 1 ব
• 5 1 বা
• 15 9 ব

(কঠিন) বাংলা অঙ্কের string থেকে int

print(int("১২৩") + 1, "১২৩".isdigit())

• 124 True
• ValueError
• ১২৩1 True
• TypeError