if/else ও loop

Indentation-as-syntax — Python-এর সবচেয়ে polarizing design choice। Guido van Rossum ১৯৯১-এ এই সিদ্ধান্ত নেন — programming history-তে যা বিরল।

Guido-র যুক্তি:

• "Code is read 10× more than written" — পঠনযোগ্যতা প্রথম priority।
• C/Java-এ — programmer এমনিতেও indent করে। তাহলে compiler কেন কেয়ার করে না?
• Indent ও {} mismatch — confusing bug source।
• "There should be one obvious way to do it" — Zen of Python।

সুবিধা:

• Visual ও syntactic structure সবসময় match।
• কোড dense নয় — air ও spacing।
• Diff ছোট — bracket লাইন থাকে না।
• Beginner-friendly — কম symbol।

ঝুঁকি ও সমস্যা:

• Tab/space mixing: Python ৩-এ illegal, কিন্তু legacy code-এ চলে।
• Copy-paste subtle bug: editor-এ indent বদলে গেলে behavior বদলায়।
• Email/chat-এ code paste: indentation চলে যায়।
• Multi-line lambda অসম্ভব — single line-এ আটকে।
• Auto-formatting tool কঠিন: "correct" indent কী — context-নির্ভর।

Tooling-এর সমাধান:

• Black: opinionated formatter — সবার কোড একই দেখায়।
• ruff: ১০০× দ্রুত linter+formatter (Rust-এ লেখা)।
• EditorConfig: team-wide editor settings।
• pre-commit hooks: push-এর আগে auto-format।

AI কোডে এর তাৎপর্য:

• Notebook cell-এ paste করে "running" — indent ভুল কামড় দেয়।
• Deep nested model code — visual structure কোড পড়া সহজ করে।
• Stack Overflow থেকে copy — সবসময় re-indent।
• Jupyter-এ shift+tab indent helpful।

অন্য language-এ এই philosophy:

• Haskell, F# — optional indent-based syntax।
• YAML — pure indent-based (controversial)।
• Go — tab-only enforced।
• Rust — formatter rustfmt enforced।

মূল উপলব্ধি: Indent = visual contract। ভাল IDE + Black = সমস্যা শেষ। Beginners-এর জন্য awkward, পেশাদারদের জন্য liberation। Python = "executable pseudocode"-এর spirit এই indent-এ।

Vectorization — AI performance-এর সবচেয়ে গুরুত্বপূর্ণ একক ধারণা। এটা না বুঝলে — production AI কোড impossible।

Python for loop কেন ধীর?

• প্রতি iteration-এ Python interpreter overhead — bytecode dispatch, type checking।
• প্রতি element-এ object allocation/dereference।
• GIL (Global Interpreter Lock) — multi-thread parallelism নেই।
• CPython implementation — JIT নেই (PyPy-তে আছে)।

Vectorization কী?

• Operation একটি element-এ নয়, পুরো array-এ একসাথে।
• NumPy a + b — Python loop নয়, C-তে SIMD instruction।
• GPU-তে — হাজার core parallel।

Concrete benchmark:

# ১ লক্ষ float-এর square
# Python loop:
result = []
for x in data:
    result.append(x * x)
# 50 ms

# NumPy vectorized:
result = data ** 2
# 0.5 ms — ১০০× দ্রুত

# GPU (PyTorch):
result = data.cuda() ** 2
# 0.05 ms — ১০০০× দ্রুত

SIMD-এর জাদু:

• "Single Instruction, Multiple Data" — একটি CPU instruction ৪/৮/১৬টি float একসাথে।
• AVX-512 — ১৬ float একসাথে (Intel Skylake+)।
• GPU SIMT — হাজার thread।

কখন loop ঠিক আছে?

• Loop-এর body-তে I/O (file, network) — bottleneck Python নয়।
• Sequential dependency — RNN unrolling।
• Small data — overhead worth it নয়।
• Outer training loop — epoch ৫০, vectorize-এর কিছু নেই।

Vectorization-এর প্যাটার্ন:

• Replace explicit loop: [x*2 for x in lst] → arr * 2।
• Broadcasting: shape mismatch auto-resolve।
• Boolean masking: arr[arr > 0] — filter without loop।
• Reduction: arr.sum(), arr.mean()।

"Numpy thinking" — paradigm shift:

• প্রশ্ন: "প্রতিটি element-এর জন্য কী করব?" — wrong।
• প্রশ্ন: "পুরো array-কে কোন function-এ পাঠাব?" — right।
• Brain-এর reflex বদল — সময় লাগে।

মূল উপলব্ধি: Loop = কম্পিউটারের natural language। Vectorize = mathematician-এর natural language। AI = math-heavy → vectorize default। L09–L12-এ NumPy-তে এই thinking তৈরি হবে।

Python-এর for-else — সবচেয়ে confusing feature, কিন্তু চমৎকার pattern।

Behavior: for/while loop normally complete (break ছাড়া) হলে else block চলে।

for x in data:
    if x == target:
        print("পাওয়া গেছে")
        break
else:
    print("নেই")    # break না হলে এই block

Why "else"? — name বিভ্রান্তিকর:

• Knuth-এর মতে এটি "nobreak" বলা উচিত ছিল।
• "else" অর্থ — "if you didn't break"।
• Guido নিজে এটি পছন্দ নাম স্বীকার করেছেন।

সাধারণ pattern — search:

# খারাপ — flag variable
found = False
for x in data:
    if x == target:
        found = True
        break
if not found:
    handle_missing()

# ভাল — for/else
for x in data:
    if x == target:
        process(x)
        break
else:
    handle_missing()

AI কোডে কাজের examples:

• Convergence check:

  for epoch in range(max_epochs):
      train_one_epoch()
      if loss < threshold:
          print(f"Converged at epoch {epoch}")
          break
  else:
      print("Did not converge")    # max_epochs শেষ

• Hyperparameter search:

  for lr in lr_grid:
      if try_train(lr) > 0.95:
          best_lr = lr
          break
  else:
      raise ValueError("কোনো learning rate কাজ করেনি")

• Validation:

  for sample in batch:
      if not validate(sample):
          raise ValueError(f"Invalid: {sample}")
          break
  else:
      proceed_to_train()

সমালোচনা:

• অপরিচিতদের জন্য বিভ্রান্তিকর।
• Code review-এ comment ছাড়া পড়া কঠিন।
• অনেক senior dev এড়িয়ে চলেন।

Alternatives:

• Function + early return:

  def find(target, data):
      for x in data:
          if x == target:
              return x
      return None

• সাধারণত — function-এ wrap করা cleaner।

মূল উপলব্ধি: for-else exotic কিন্তু powerful। জানা থাকলে — "did the loop finish without break?" pattern এক structure-এ। আজকের preference — function-এ encapsulate, কিন্তু legacy কোড পড়তে এই knowledge দরকার।

Branching logic বাড়লে — কোড maintainability ভেঙে পড়ে। Modern Python-এ এর কয়েকটি সুন্দর pattern আছে।

সমস্যার রূপ:

# ১০টি case — কুৎসিত
def get_optimizer(name):
    if name == "sgd":
        return SGD(...)
    elif name == "adam":
        return Adam(...)
    elif name == "rmsprop":
        return RMSprop(...)
    # ... আরও

সমাধান ১: Dict dispatch (Pythonic):

OPTIMIZERS = {
    "sgd": SGD,
    "adam": Adam,
    "rmsprop": RMSprop,
}

def get_optimizer(name, **kwargs):
    cls = OPTIMIZERS.get(name)
    if cls is None:
        raise ValueError(f"Unknown: {name}")
    return cls(**kwargs)

• O(1) lookup। Extensible — নতুন entry শুধু dict-এ।
• Test data-driven।
• Plugin architecture-এর ভিত্তি।

সমাধান ২: match/case (Python 3.10+, ২০২১):

def parse_command(cmd):
    match cmd:
        case ["train", model, *args]:
            train(model, args)
        case ["predict", model, input]:
            predict(model, input)
        case ["save", path]:
            save(path)
        case _:
            raise ValueError("Unknown command")

• Structural pattern matching — Rust/Haskell-এর মতো।
• Destructuring + condition একসাথে।
• Complex data structure-এর জন্য আদর্শ।

সমাধান ৩: Strategy pattern (OO):

class Strategy:
    def execute(self, x): ...

class FastStrategy(Strategy):
    def execute(self, x): return x * 2

class SafeStrategy(Strategy):
    def execute(self, x): return x

• Strategy ভিন্ন ভিন্ন behavior একই interface-এ।
• Heavy কাজ, configurable।

সমাধান ৪: Polymorphism (duck typing):

• Python "if isinstance(x, ...)" এড়াও।
• Object-এর method call — type ignore।

AI-তে concrete:

• Model registry: Hugging Face Transformers — model name string → class।
• Loss function: "mse"/"crossentropy"/"focal" → callable।
• Activation: "relu"/"gelu"/"silu" → torch function।
• Data augmentation: recipe → list of operations।

কখন কোনটা — guideline:

• ২-৩টি case → simple if/elif।
• ৪-১০টি case → dict dispatch।
• Pattern matching, destructuring → match/case।
• Complex behavior → Strategy class।
• Deep type hierarchy → polymorphism।

"Replace conditional with polymorphism" — Martin Fowler:

• Refactoring book-এর famous pattern।
• OOP দিয়ে if/else explosion দূর।

মূল উপলব্ধি: If/elif chain — code smell। ১০-এর বেশি — refactor। AI ML codebase-এ — registry pattern + dict dispatch + match/case = clean architecture। L05-এ function ও lambda — এই idiom-এর বিল্ডিং ব্লক।