module, package আর import — বড় প্রোগ্রামকে ফাইলে ভাগ করা

১ · একটি ফাইল যখন আর কুলায় না — প্রতিটি .py ফাইলই একটি module

পর্ব ২১-এর মাঝপথের প্রজেক্টে আপনি একটি ফলাফলের টুল বানিয়েছেন: নম্বর যোগ করা, GPA হিসাব, মেধাতালিকা ছাপা, কমান্ড পড়া — সব একটি ফাইলে। দেড়শো লাইন পর্যন্ত এক ফাইল চলে যায়। কিন্তু কল্পনা করুন, টুলটি এবার পুরো স্কুল ব্যবহার করবে: ফলাফল ফাইলে সেভ হবে, শিক্ষকদের জন্য আলাদা রিপোর্ট লাগবে, পরে হয়তো একটি ওয়েবসাইটও। দুই হাজার লাইনের একটি ফাইলে একটি ফাংশন খুঁজে পাওয়াই তখন কাজ হয়ে দাঁড়ায়, আর দুজন একসাথে একই ফাইলে কাজ করলে একে অপরের পরিবর্তন মুছে ফেলার ভয় থাকে।

Python-এ এই “সেকশন”-এর নাম module. সংজ্ঞাটি অবাক করার মতো সরল: যেকোনো .py ফাইলই একটি module, আর ফাইলের নাম (.py বাদ দিয়ে) হলো module-এর নাম। grading.py নামে একটি ফাইল বানালেন, ব্যস — grading নামের module তৈরি। বিশেষ কোনো ঘোষণা, কোনো কিওয়ার্ড লাগে না।

পর্ব ২০-এ দেখেছিলেন, প্রতিটি নাম কোনো একটি namespace-এ — নামের খাতায় — লেখা থাকে, আর “global” মানে আসলে “এই module-এর global”. এবার সেই কথাটি পূর্ণ হলো: প্রতিটি module-এর নিজের একটি global namespace আছে. grading.py-তে total আর report.py-তে total দুটি আলাদা নাম, আলাদা খাতায়। বাইরে থেকে ব্যবহার করতে হলে বলতে হয় grading.total — ঠিক “সুইংয়ের রহিম”-এর মতো। এই কারণে দুটি ফাইলে একই নাম থাকলেও সংঘর্ষ হয় না।

আর এক ফাইল যখন অন্য ফাইলের নাম ব্যবহার করতে চায়, তখন লেখে import. পর্ব ২১-এর টুলকে দায়িত্ব অনুযায়ী ভাগ করলে এমন দেখাতে পারে:

result_tool/
├── grading.py     # grade_point(), gpa() — শুধু হিসাব, কোনো print নেই
├── storage.py     # load(), save() — ফাইলে রাখা আর পড়া (পর্ব ২৫–২৬)
└── cli.py         # কমান্ড পড়া, ঠিক ফাংশন ডাকা, ফল ছাপা

# cli.py — শুধু ব্যবহারকারীর সাথে কথা বলে
import storage
from grading import gpa

def main():
    students = storage.load("marks.json")
    for name, marks in students.items():
        print(f"{name}: GPA {gpa(marks):.2f}")

if __name__ == "__main__":
    main()

এখনই সব লাইন বোঝার দরকার নেই — if __name__ লাইনটির গল্প অংশ ৪-এ। শুধু ভাগটা দেখুন। grading.py জানে না নম্বর কোথা থেকে আসে; সে শুধু হিসাব করে। storage.py জানে না GPA কী; সে শুধু ফাইল পড়ে-লেখে। cli.py কিছু হিসাব করে না; সে শুধু দুজনকে জোড়া লাগায়। পর্ব ২১-এ এই নীতির নাম শিখেছিলেন — separation of concerns. Module হলো সেই নীতিকে ফাইলের স্তরে নিয়ে যাওয়া।

আপনি এতদিন না জেনেই module ব্যবহার করেছেন। import math, import random — এগুলো Python-এর সাথে আসা standard library-র module, যাদের বেশিরভাগ আসলে কারও লেখা সাধারণ .py ফাইল, আপনার কম্পিউটারে Python-এর ফোল্ডারে রাখা। আর কয়েকটি module একটি ফোল্ডারে গুছিয়ে রাখলে তাকে বলে package — অংশ ৬-এ।

২ · import-এর চারটি রূপ — আর কোনটি এড়াবেন

একই module চারভাবে import করা যায়। পার্থক্য একটাই: আপনার ফাইলের namespace-এ কোন নাম বসে.

প্রথম রূপে আপনার namespace-এ একটিই নতুন নাম আসে — math, যা পুরো module object-এর গায়ে লাগানো লেবেল। পর্ব ০৫ থেকে জানেন, Python-এ সবকিছু object; module-ও তাই, আর math.sqrt মানে “math object-এর sqrt নামের attribute”. প্রতিটি ব্যবহারে উৎস লেখা থাকে, তাই যে কেউ পড়ে বোঝে sqrt এসেছে math থেকে।

দ্বিতীয় রূপ as শুধু লেবেলের নাম বদলায়; module একটাই। Data science-এ import numpy as np, import pandas as pd এত প্রচলিত যে এগুলো প্রায় নিয়ম হয়ে গেছে (পর্ব ৪৬)। তবে নিজে থেকে অদ্ভুত ডাকনাম (import grading as g) বানাবেন না — পাঠকের জন্য একটি নতুন ধাঁধা তৈরি হয়।

তৃতীয় রূপ from math import sqrt module-টিকে আপনার namespace-এ আনে না, আনে শুধু sqrt নামটি — যা সেই একই ফাংশন object-এর দিকে নির্দেশ করে। একসাথে কয়েকটিও আনা যায়: from math import sqrt, pi, floor. কয়েকটি নাম বারবার ব্যবহার করলে এটি সুবিধাজনক। as এখানেও চলে: from datetime import datetime as dt.

from x import * — কেন এড়াবেন

চতুর্থ রূপকে বলে wildcard import (star import). এটি module-এর সব “public” নাম — underscore দিয়ে শুরু হয় না এমন সব নাম, অথবা module যদি __all__ তালিকা দেয় তবে শুধু সেগুলো — একবারে আপনার namespace-এ ঢেলে দেয়। দেখতে সুবিধাজনক, কিন্তু তিনটি গুরুতর সমস্যা:

• উৎস হারিয়ে যায়: ফাইলের মাঝখানে floor(x) দেখে বোঝার উপায় নেই এটি কোথা থেকে এল — আপনার নিজের, নাকি কোনো import-এর? তিনটি star import থাকলে খুঁজতে হয় তিনটি module-এ।
• নিঃশব্দে ঢেকে ফেলা: পর্ব ২০-এর shadowing এখানে লুকিয়ে ঘটে। from os import * লিখলে os module-এর open নামের ফাংশন built-in open-কে ঢেকে দেয় — আর তার আচরণ একেবারে আলাদা। দুটি module-এ একই নাম থাকলে পরেরটি আগেরটিকে মুছে দেয়, কোনো সতর্কতা ছাড়া।
• টুল অন্ধ হয়ে যায়: Editor-এর auto-complete, linter আর পাঠক — কেউই নিশ্চিত জানে না কোন নাম আছে। PEP 8 এই কারণেই স্পষ্ট বলে, wildcard import এড়ানো উচিত।

একটি ছোট শৈলীর কথা। PEP 8 অনুযায়ী সব import ফাইলের একেবারে শুরুতে (module docstring-এর পরে) থাকে, তিনটি দলে, মাঝে একটি ফাঁকা লাইন: প্রথমে standard library (import sys), তারপর বাইরে থেকে install করা library (import requests), শেষে নিজের project-এর module (import grading). তাহলে ফাইল খুলেই বোঝা যায় এটি কার ওপর নির্ভর করে। ruff-এর মতো টুল (পর্ব ৪৪) এই সাজানো নিজেই করে দেয়।

৩ · import আসলে কী করে — খোঁজা, একবার চালানো, cache, নাম বাঁধা

অনেকে ভাবেন import বুঝি C-র #include-এর মতো — অন্য ফাইলের লেখা এখানে কপি করে বসানো। তা নয়। import একটি সাধারণ statement, যা চালানোর মুহূর্তে চারটি কাজ করে:

1. Cache দেখা: Python একটি dict রাখে — sys.modules — যার চাবি module-এর নাম, মান module object. আগে দেখে, এই নামে module কি আগেই লোড হয়েছে? হলে সোজা ধাপ ৪-এ।
2. খোঁজা: না থাকলে খোঁজে — কিছু module interpreter-এর ভেতরেই তৈরি (যেমন sys), বাকিদের জন্য sys.path তালিকার ফোল্ডারগুলোতে একে একে grading.py বা grading/ ফোল্ডার খোঁজে (অংশ ৫)। কোথাও না পেলে ModuleNotFoundError.
3. তৈরি, cache-এ রাখা আর চালানো: পেলে একটি খালি module object তৈরি করে, সঙ্গে সঙ্গে sys.modules-এ রাখে, তারপর ফাইলের কোড উপর থেকে নিচে একবার চালায়। এই চালানোর সময় যত def, যত assignment — সব module-এর namespace ভরে তোলে। (পর্ব ০৫-এর bytecode পরের বারের জন্য __pycache__ ফোল্ডারে .pyc হিসেবে জমা থাকে, যাতে পরেরবার compile করতে না হয়।)
4. নাম বাঁধা: শেষে আপনার ফাইলের namespace-এ একটি নাম সেই module object-এর গায়ে লাগায় — import grading হলে grading, from grading import gpa হলে শুধু gpa.

এখান থেকে দুটি গুরুত্বপূর্ণ ফল আসে। এক: module-এর বাইরের স্তরের কোড (যেকোনো ফাংশনের বাইরে লেখা কোড) চলে মাত্র একবার, প্রথম import-এর সময়। দুই: একই module যতবার, যত ফাইল থেকেই import করুন, সবাই একই object পায় — তাই এক জায়গায় module-এর কোনো মান বদলালে সবাই সেই বদল দেখে। ধাপে ধাপে দেখুন:

1# config.py2print("config লোড হচ্ছে")3VAT = 0.154# report.py5import config6# main.py7import config8import report9import config10print(config.VAT, report.config is config)

এবার প্রথম runnable প্রোগ্রাম। এখানে শুধু standard library ব্যবহার করে import-এর রূপগুলো, sys.modules-এর cache আর dir() দেখা হচ্ছে। চালানোর আগে প্রথম লাইনের আউটপুট অনুমান করুন:

import sys
import math
import math as m
from math import sqrt

print(__name__)                         # এই ফাইলের নিজের নাম
print(m is math, sqrt is math.sqrt)     # একই object, ভিন্ন লেবেল
print(sqrt(2025), type(math).__name__)
print(sys.modules["math"] is math)      # cache-এ রাখা সেই module
print([n for n in dir(math) if n.startswith("is")])

import random
random.seed(22)                         # নির্দিষ্ট seed → প্রতিবার একই ফল
print([random.randint(1, 6) for _ in range(3)])
print(random.__name__, "random" in sys.modules)

৪ · if __name__ == "__main__": — একই ফাইল, script আর library দুই রূপে

অংশ ৩ থেকে একটি সমস্যা সরাসরি বেরিয়ে আসে। ধরুন আপনি bangla_utils.py নামে একটি সহায়ক ফাইল লিখলেন — টাকার অঙ্ক বাংলা অঙ্কে সুন্দর করে লেখার ফাংশন। ফাংশনটি ঠিক কাজ করছে কি না দেখতে ফাইলের শেষে কয়েকটি print দিলেন। এবার cli.py থেকে import bangla_utils করলেই সেই পরীক্ষার print-গুলোও চলে যাবে — কারণ import মানে পুরো ফাইল একবার চালানো। আপনার রিপোর্টের মাঝখানে হঠাৎ পরীক্ষার আউটপুট!

সমাধান হলো একটি বিশেষ নাম: __name__. প্রতিটি module-এর namespace-এ Python নিজে এই ভ্যারিয়েবলটি বসিয়ে দেয়। এর মান নির্ভর করে ফাইলটি কীভাবে চালানো হলো তার ওপর:

তাই ফাইলের শেষে এই শর্ত — যাকে বলে main guard — লিখলে তার ভেতরের কোড শুধু সরাসরি চালানোর সময় চলে, import-এর সময় নয়:

প্রচলিত ধরন হলো সব “চালানোর” কাজ একটি main() ফাংশনে রাখা, আর guard-এর ভেতরে শুধু সেটিকে ডাকা — অংশ ১-এর cli.py-তে ঠিক এটাই দেখেছেন। এতে দুটি সুবিধা: main()-এর ভেতরের ভ্যারিয়েবল local থাকে (module-এর global namespace নোংরা হয় না, পর্ব ২০), আর পরীক্ষার কোড চাইলে main() নিজেও ডাকতে পারে।

এবার দ্বিতীয় runnable প্রোগ্রাম, যেটি একটু অন্যরকম: অনলাইনে এখানে একটিমাত্র ফাইল চালানো যায়, তাই প্রোগ্রামটি নিজেই কাজের ফোল্ডারে (working directory) bangla_utils.py নামে একটি ছোট module লিখে ফেলে, তারপর সেটি import করে। দুবার import হচ্ছে — খেয়াল করুন “লোড হচ্ছে” কতবার ছাপা হয়, আর guard-এর ভেতরের লাইনটি ছাপা হয় কি না:

import importlib, sys
from pathlib import Path

Path("bangla_utils.py").write_text('''\
print("bangla_utils লোড হচ্ছে...")
_DIGITS = str.maketrans("0123456789", "০১২৩৪৫৬৭৮৯")

def taka(amount):
    return "৳" + f"{amount:,}".translate(_DIGITS)

if __name__ == "__main__":
    print("সরাসরি চালানো হলো")
''', encoding="utf-8")
importlib.invalidate_caches()

import bangla_utils              # প্রথমবার: ফাইলটি চলে
import bangla_utils              # দ্বিতীয়বার: cache থেকে
print(bangla_utils.taka(1250000))
print(bangla_utils.__name__, "bangla_utils" in sys.modules)
print([n for n in dir(bangla_utils) if not n.startswith("__")])

৫ · Python module কোথায় খোঁজে — sys.path আর random.py-র ফাঁদ

অংশ ৩-এর ধাপ ২-এ বলেছিলাম, Python sys.path-এর ফোল্ডারগুলোতে খোঁজে। sys.path একটি সাধারণ list, যাতে ফোল্ডারের ঠিকানা থাকে, আর খোঁজা চলে উপর থেকে নিচে; প্রথম মিলেই থামে — ঠিক পর্ব ২০-এর LEGB-র মতো। সাধারণত এর ক্রম:

1. যে script চালাচ্ছেন, তার নিজের ফোল্ডার (REPL বা python -c-তে বর্তমান ফোল্ডার)। এই কারণেই একই ফোল্ডারের grading.py কোনো সেটআপ ছাড়াই import হয়।
2. PYTHONPATH নামের environment variable-এ লেখা ফোল্ডারগুলো, যদি থাকে।
3. Python-এর নিজের standard library-র ফোল্ডার।
4. site-packages — pip install দিয়ে বসানো বাইরের library যেখানে থাকে (পর্ব ২৩)।

নিজের কম্পিউটারে দেখতে চাইলে REPL-এ লিখুন import sys; print(sys.path). কোনো module ঠিক কোন ফাইল থেকে এল জানতে print(random.__file__) — এটি ডিবাগিংয়ের একটি খুব কাজের কৌশল।

প্রথম ধাপটিই নতুনদের সবচেয়ে পরিচিত একটি বাগের জন্ম দেয়। একজন শিক্ষার্থী random নিয়ে অনুশীলন করতে নিজের ফাইলের নাম দিলেন random.py. পরে একই ফোল্ডারে একটি লুডু খেলা লিখলেন, যেটি import random করে। কী হয়, ধাপে ধাপে দেখুন:

practice/
├── random.py     # শিক্ষার্থীর অনুশীলন: print("আমার random অনুশীলন")
└── ludo.py       # import random; print(random.randint(1, 6))

[0] .../practice            ← random.py এখানেই পাওয়া গেল!
[1] .../Python314/Lib       ← আসল random.py এখানে, কিন্তু এ পর্যন্ত আসেই না
[2] .../site-packages

$ python ludo.py
আমার random অনুশীলন

AttributeError: module 'random' has no attribute 'randint'
(consider renaming '.../practice/random.py' since it has the same
name as the standard library module named 'random' and prevents
importing that standard library module)

practice/
├── dice_practice.py
└── ludo.py

$ python ludo.py
4

একই ফাঁদ পাতে json.py, csv.py, email.py, test.py, string.py, turtle.py — এমনকি numpy.py বা pandas.py (তখন install করা library ঢাকা পড়ে)। নিয়ম: নিজের ফাইলের নাম কোনো পরিচিত module-এর নামে রাখবেন না. নাম রাখার আগে REPL-এ import নাম লিখে দেখুন — চললে বুঝবেন নামটি আগে থেকেই কারও। (sys-এর মতো কিছু module interpreter-এর ভেতরেই তৈরি, তাদের sys.path-এর আগেই খুঁজে পাওয়া যায়, তাই তাদের ঢাকা যায় না — কিন্তু কোনটি এমন, তা মনে রাখার চেয়ে নাম আলাদা রাখাই সহজ।)

৬ · Package — module-এর ফোল্ডার আর __init__.py

Module যখন অনেক হয়ে যায়, তখন সম্পর্কিতগুলোকে একটি ফোল্ডারে রাখা স্বাভাবিক। একটি অনলাইন দোকানের কোড ভাবুন — দাম, স্টক আর কমান্ড-লাইন, তিনটি আলাদা দায়িত্ব:

shop_project/
├── main.py
└── shop/                 ← package
    ├── __init__.py       ← “এই ফোল্ডারটি একটি package”
    ├── pricing.py        ← shop.pricing
    ├── inventory.py      ← shop.inventory
    └── cli.py            ← shop.cli

shop ফোল্ডারটি একটি package, আর এর ভেতরের প্রতিটি ফাইল একটি module, যার পুরো নাম ডট দিয়ে লেখা: shop.pricing, shop.inventory. ডট-ওয়ালা নাম ফোল্ডারের পথেরই প্রতিফলন — shop/pricing.py মানে shop.pricing. Package-এর ভেতরে আরেকটি package (sub-package)-ও রাখা যায়, যেমন shop/payments/bkash.py হলে shop.payments.bkash.

__init__.py ফাইলটি থাকলে ফোল্ডারটি হয় একটি regular package. ফাইলটি খালিও হতে পারে — অধিকাংশ সময় খালিই থাকে। কিন্তু খালি না হলে, এর কোড চলে package প্রথমবার import হওয়ার সময়, আর এখানে সংজ্ঞায়িত নামগুলোই হয় package object-এর নাম। import shop.pricing লিখলে আসলে কী কী ঘটে, ধাপে ধাপে দেখুন:

1# shop/__init__.py2print("shop package লোড হলো")3# shop/pricing.py4VAT = 0.155def with_vat(p): return round(p * (1 + VAT))6# main.py7import shop.pricing8print(shop.pricing.with_vat(200))

__init__.py-তে কী রাখবেন — হালকা রাখুন

যেহেতু package-এর যেকোনো module import করলেই আগে __init__.py চলে, এখানে ভারী কিছু রাখলে সবাই সেই খরচ দেয়। ভালো অভ্যাস:

• খালি রাখা — ছোট project-এ এটাই যথেষ্ট।
• প্রয়োজনীয় কয়েকটি নাম সামনে আনা: from .pricing import with_vat লিখলে ব্যবহারকারী from shop import with_vat লিখতে পারেন, ভেতরের ফাইলের কাঠামো না জেনেই। বড় library (যেমন requests) এভাবেই একটি পরিষ্কার “সামনের দরজা” দেয়।
• একটি version নম্বর বা package-এর docstring.
• যা রাখবেন না: ফাইল পড়া, নেটওয়ার্ক, ডেটাবেস সংযোগ, বা package-এর সব module একসাথে import করা।

Namespace package — __init__.py ছাড়া ফোল্ডার

Python 3.3 থেকে __init__.py ছাড়া ফোল্ডারও import করা যায়। একে বলে namespace package (PEP 420). এর আসল উদ্দেশ্য বড় প্রতিষ্ঠানের জন্য: একই package নামের অংশ আলাদা আলাদা ফোল্ডারে, এমনকি আলাদাভাবে install করা ভিন্ন ভিন্ন distribution-এ থাকতে পারে, আর Python সবগুলোকে মিলিয়ে একটি package বানায়। নতুনদের জন্য নিয়ম সহজ: নিজের package-এ সবসময় __init__.py রাখুন. ভুলে গেলে কোড প্রায়ই চলবে, কিন্তু কিছু টুল (যেমন কিছু test runner বা package বানানোর টুল) ফোল্ডারটিকে package হিসেবে চিনতে ভুল করতে পারে, আর ভুল জায়গার একই নামের ফোল্ডার নিঃশব্দে package হয়ে যেতে পারে।

৭ · Absolute বনাম relative import — আর python -m

shop/cli.py থেকে pricing ব্যবহার করতে চাইলে দুইভাবে লেখা যায়:

# absolute import — package-এর শুরু থেকে পুরো পথ
from shop.pricing import with_vat
import shop.inventory

# relative import — "আমার নিজের package থেকে"
from .pricing import with_vat       # একই package-এর pricing
from . import inventory             # একই package-এর inventory
from ..utils import taka            # এক ধাপ উপরের package-এর utils

Absolute import সবসময় top-level package-এর নাম থেকে শুরু করে — যেকোনো ফাইল থেকে একই রকম দেখায়, তাই পড়তে সবচেয়ে পরিষ্কার। PEP 8-ও সাধারণত absolute import পছন্দ করে। Relative import-এ সামনের ডটগুলো ফোল্ডারের মতো কাজ করে: একটি ডট মানে “এই ফাইলের নিজের package”, দুটি ডট মানে “এক ধাপ উপরের package”. সুবিধা: package-এর নাম বদলালে ভেতরের import বদলাতে হয় না। বড় package-এর ভেতরে এটি বেশ প্রচলিত। দুটি নিয়ম মনে রাখুন: relative import শুধু from ... import ... রূপে চলে (import .pricing লেখা যায় না), আর শুধু package-এর ভেতরের ফাইলে।

যখন relative import ভাঙে

এবার সবচেয়ে বেশি প্রশ্ন আসা error-টি। shop/cli.py-তে from .pricing import with_vat লেখা, আর আপনি সেটি সরাসরি চালালেন:

python shop/cli.py

ImportError: attempted relative import with no known parent package

কারণ অংশ ৪-এ লুকিয়ে আছে। সরাসরি চালানো ফাইলের নাম হয়ে যায় "__main__" — "shop.cli" নয়। Python-এর চোখে এটি এখন কোনো package-এর অংশ নয়, একটি একা ফাইল। “আমার package” বলতে কোনটি, সে জানে না — তাই .-র কোনো অর্থ নেই। (সাথে আরেকটি সমস্যা: sys.path[0] হয়ে যায় shop/ ফোল্ডার নিজে, তার উপরের ফোল্ডার নয়, তাই absolute import shop-ও খুঁজে পাওয়া যায় না।)

সমাধান হলো ফাইলের পথ না দিয়ে module-এর নাম দিয়ে চালানো, project-এর মূল ফোল্ডার থেকে:

cd shop_project
python -m shop.cli

-m (run as module) মানে “এই নামের module খুঁজে script হিসেবে চালাও”. এখন Python জানে ফাইলটি shop package-এর অংশ, তাই relative import কাজ করে; আর sys.path[0] হয় বর্তমান ফোল্ডার (shop_project/), তাই absolute import-ও কাজ করে। ফাইলের __name__ তবু "__main__" থাকে, তাই main guard-ও ঠিকঠাক চলে। আপনি আগেই এর ব্যবহার দেখেছেন: python -m pip, python -m venv (পর্ব ২৩), python -m http.server — সবই standard library বা install করা module-কে নাম ধরে চালানো।

৮ · Circular import — দুটি module যখন একে অপরকে চায়

দোকানের কোড বড় হচ্ছে। pricing.py-তে ছাড়ের হিসাবের জন্য জানা দরকার কোন পণ্য স্টকে বেশি আছে, তাই সে inventory থেকে stock আনে। আবার inventory.py-তে স্টকের মোট মূল্য বের করতে দাম লাগে, তাই সে pricing থেকে price আনে। দুটি ফাইল একে অপরকে import করছে — একে বলে circular import. চালালে:

ImportError: cannot import name 'price' from partially initialized module 'shop.pricing'
(most likely due to a circular import) (.../shop/pricing.py)

“partially initialized module” — অর্ধেক তৈরি হওয়া module. কথাটির মানে বুঝতে অংশ ৩-এর একটি খুঁটিনাটি মনে করুন: module object চালানোর আগেই sys.modules-এ বসে। টাইমলাইনটি দেখুন:

1# shop/pricing.py2from shop.inventory import stock3def price(item): ...4# shop/inventory.py5from shop.pricing import price6def stock(item): ...7# main.py8import shop.pricing

Circular import সারানোর উপায়গুলো, পছন্দের ক্রমে:

1. কাঠামো বদলান: circular import প্রায় সবসময় একটি নকশার সংকেত — দুটি module-এর দায়িত্ব পরিষ্কারভাবে ভাগ হয়নি। ভাগ করা অংশ তৃতীয় module-এ নিন, অথবা দুটিকে একটিতে মিলিয়ে দিন। লক্ষ্য: নির্ভরতা একদিকে বয়ে যাক — cli → pricing → catalog, কখনো উল্টো দিকে নয়।
2. ফাংশনের ভেতরে import: def stock_value(): from shop.pricing import price; ... — import চলে ফাংশন ডাকার সময়, যখন দুটি module-ই পুরো তৈরি। দ্রুত সমাধান, কিন্তু নির্ভরতা লুকিয়ে রাখে; comment দিয়ে কারণ লিখে রাখুন।
3. module import, নাম নয়: from shop.pricing import price-এর বদলে import shop.pricing, আর ব্যবহারের সময় shop.pricing.price(...). তখন import-এর মুহূর্তে price নামটি লাগে না, লাগে ডাকার মুহূর্তে। অনেক ক্ষেত্রে এতেই চলে, তবে নির্ভর করে কোন কোড কখন চলে তার ওপর।

৯ · module-এর সামনের দরজা — __all__, underscore, dir()/help() আর গোছানো project

Underscore — “এটি ভেতরের জিনিস”

Python-এ private কিওয়ার্ড নেই। বদলে আছে একটি সর্বজনস্বীকৃত রীতি: নাম যদি underscore দিয়ে শুরু হয় (_DIGITS, _parse_row), তবে সেটি module-এর ভেতরের ব্যবহারের জন্য — বাইরের কেউ এর ওপর নির্ভর করবেন না, পরের version-এ এটি বদলে বা মুছে যেতে পারে। একে বলে private name রীতি। অংশ ৪-এর প্রোগ্রামে দেখেছেন, এমন নামও বাইরে থেকে দেখা যায় — Python আটকায় না। শুধু দুটি জায়গায় এর প্রভাব: from x import * underscore-ওয়ালা নাম আনে না, আর অনেক editor auto-complete-এ এগুলো লুকিয়ে রাখে। Python-এর দর্শন এখানে: “আমরা সবাই প্রাপ্তবয়স্ক” — সংকেত দেওয়া হলো, মানা আপনার দায়িত্ব।

__all__ — public নামের তালিকা

module-এর একেবারে উপরে __all__ = ["taka", "to_bangla_digits"] লিখলে আপনি স্পষ্ট ঘোষণা করেন, এই module-এর public API কোনগুলো। __all__-এর প্রযুক্তিগত প্রভাব একটাই — from bangla_utils import * লিখলে শুধু এই নামগুলো আসবে। কিন্তু এর আসল মূল্য দলিল হিসেবে: পাঠক আর টুল এক নজরে বোঝেন কোনটি ব্যবহারের জন্য। Package-এর __init__.py-তে from .pricing import * লেখার সাথে pricing-এ __all__ থাকলে, এটিই সেই নিয়ন্ত্রিত বিশেষ ব্যবহার, যার কথা অংশ ২-এ বলেছিলাম।

dir() আর help() — অচেনা module ঘুরে দেখা

নতুন module হাতে পেলে প্রথমে REPL খুলুন। dir(math) সব নামের সাজানো তালিকা দেয়; help(math.isqrt) ফাংশনের docstring দেখায় — কী নেয়, কী দেয়; help(math) পুরো module-এর বিবরণ। কোনো কিছু ইনস্টল ছাড়াই, ইন্টারনেট ছাড়াই, এটি আপনার হাতের কাছের ডকুমেন্টেশন। চলমান প্রোগ্রাম থেকে নিজের সম্পর্কে এভাবে তথ্য বের করাকে বলে introspection. আর আপনি নিজে module লিখলে ফাইলের প্রথম লাইনে একটি docstring দিন — help(bangla_utils) তখন সেটিই দেখাবে।

importlib.reload — শুধু REPL-এ

REPL-এ একটি module import করে পরীক্ষা করছেন, এর মধ্যে ফাইলে কিছু বদলালেন। আবার import bangla_utils লিখলে কিছুই হবে না — cache! তখন import importlib; importlib.reload(bangla_utils) ফাইলটি আবার চালায়। তবে importlib-এর এই ফাংশনের সীমা আছে: পুরোনো object-গুলো (যেমন আগে from bangla_utils import taka দিয়ে আনা taka) পুরোনোই থেকে যায়। তাই এটি শুধু REPL বা Jupyter-এ দ্রুত পরীক্ষার জন্য; আসল প্রোগ্রামে reload ব্যবহার করবেন না — প্রোগ্রাম নতুন করে চালান।

একটি গোছানো ছোট project

সব মিলিয়ে, একটি ছোট দোকানের project এমন দেখাতে পারে:

shop_project/
├── README.md
├── shop/
│   ├── __init__.py      # খালি, বা কয়েকটি নাম সামনে আনা
│   ├── catalog.py       # পণ্যের তালিকা — কারও ওপর নির্ভর করে না
│   ├── pricing.py       # দাম, VAT, ছাড় — catalog ব্যবহার করে
│   ├── inventory.py     # স্টক — catalog ব্যবহার করে
│   └── cli.py           # main() + main guard — সবাইকে জোড়ে
└── tests/
    └── test_pricing.py  # পর্ব ৩৯

চালানো:  cd shop_project  →  python -m shop.cli

লক্ষ করুন নির্ভরতার দিক: cli সবাইকে ব্যবহার করে, pricing আর inventory শুধু catalog-কে, আর catalog কাউকেই না। কোনো চক্র নেই, তাই circular import-এর সুযোগ নেই। input() আর print() শুধু cli.py-তে, তাই বাকি সব module টেস্ট করা সহজ, আর পরে ওয়েব ইন্টারফেস (পর্ব ৪৮) বানালে cli.py-র জায়গায় আরেকটি ফাইল বসালেই চলবে। পেশাদার project-এ প্রায়ই package-টিকে একটি src/ ফোল্ডারের ভেতরে রাখা হয় (src layout) আর একটি pyproject.toml ফাইল যোগ করা হয় — সেগুলোর কারণ ও নিয়ম পর্ব ২৩-এ।

১০ · AI-এর যুগে — AI-এর লেখা import আর project কাঠামো যাচাই

AI একটি ফাইলের ছোট প্রোগ্রাম চমৎকার লেখে। কিন্তু “একটি project বানিয়ে দাও” বললেই দুর্বলতা দেখা দেয়: AI এক এক বার্তায় এক একটি ফাইল লেখে, পুরো কাঠামো একসাথে মাথায় রাখে না, আর প্রশিক্ষণের কোডে থাকা পুরোনো অভ্যাস নকল করে। ফলে এমন কোড আসে যা AI-এর উদাহরণে চলে, কিন্তু আপনার ফোল্ডারে চালালে ভাঙে।

AI-এর দেওয়া project পেলে — যাচাইয়ের চেকলিস্ট

• সব ফাইলে import * খুঁজেছি (Ctrl+F) — একটিও নেই
• sys.path শব্দটি খুঁজেছি; থাকলে কাঠামো ঠিক করে সেটি মুছতে বলেছি
• কাগজে প্রতিটি ফাইল থেকে তীর এঁকে দেখেছি কে কাকে import করে — কোনো চক্র নেই
• যে ফাইল সরাসরি চালানোর, তার শেষে main guard আছে; অন্য ফাইল import করলে কিছু ছাপা হয় না
• কোনো ফাইলের নাম random, json, csv, test, string-এর মতো নয়
• project-এর মূল ফোল্ডার থেকে python -m ... দিয়ে নিজে চালিয়ে দেখেছি — AI-এর কথায় ভরসা না করে