regular expression — লেখার আকৃতি দিয়ে খোঁজা

১ · regular expression কী — লেখার “আকৃতি” বর্ণনার ছোট একটি ভাষা

পর্ব ০৯-এ আপনি string method দিয়ে লেখা নিয়ে কাজ করেছেন: "OTP" in sms, text.replace("মো.", "মোহাম্মদ"), phone.startswith("017"). এগুলো সবই একটি নির্দিষ্ট লেখা খোঁজে। কিন্তু বাস্তবের অনেক প্রশ্ন নির্দিষ্ট লেখা নিয়ে নয়, লেখার আকৃতি নিয়ে। “এই ফর্মে যা লেখা হয়েছে, সেটা কি একটি বৈধ মোবাইল নম্বরের মতো দেখতে?” “এই SMS-এ টাকার অঙ্কটা কোথায়?” “এই লগ ফাইলে যত তারিখ আছে, সব বের করো।” আপনি আগে থেকে জানেন না নম্বরটা কী হবে — জানেন শুধু তার চেহারা: 01 দিয়ে শুরু, তারপর 3 থেকে 9-এর একটি অঙ্ক, তারপর আরও ৮টি অঙ্ক।

এই চেহারা বর্ণনা করার জন্য একটি ছোট, ঘন ভাষা আছে, যার নাম regular expression — ছোট করে regex. উপরের মোবাইল নম্বরের বর্ণনাটি regex-এ লেখা যায় এভাবে: 01[3-9]\d{8}. পড়ুন বাম থেকে: 0, তারপর 1, তারপর [3-9] মানে “3 থেকে 9-এর যেকোনো একটি”, তারপর \d{8} মানে “ঠিক ৮টি অঙ্ক”। পুরো একটি বাক্যের কাজ মাত্র বারোটি চিহ্নে।

একটি regex দিয়ে মূলত চার ধরনের কাজ হয়:

২ · re module — raw string আর search, match, fullmatch

Python-এ regex-এর কাজ করে standard library-র re module (পর্ব ২২-এ import শিখেছেন, পর্ব ২৭-এ library-র আরও কয়েকটি module দেখেছেন)। প্রথম নিয়মটি পর্ব ০৯ থেকেই চেনা: প্যাটার্ন সবসময় raw string-এ লিখুন — r"\d+", শুধু "\d+" নয়।

কেন? regex-এ backslash (\) অনেক: \d, \w, \s, \b. আর সাধারণ Python string-ও backslash-কে নিজের মতো ব্যাখ্যা করে। সবচেয়ে বিপজ্জনক উদাহরণ \b: regex-এ এর মানে “শব্দের সীমানা”, কিন্তু সাধারণ string-এ "\b" হলো backspace নামের একটি অদৃশ্য অক্ষর। তাই re.search("\bcat\b", "a cat here") ফল দেয় None — কোনো error ছাড়াই চুপচাপ ভুল! আর re.search(r"\bcat\b", "a cat here") ঠিকঠাক cat খুঁজে পায়। r লিখলে Python backslash ছোঁয় না, পুরোটা যায় re-এর কাছে। ("\d"-এর মতো অচেনা escape-এ Python এখন SyntaxWarning দেয়, কিন্তু "\b" চেনা escape বলে কোনো সতর্কবার্তাও আসে না।)

তিন ভাই — search, match আর fullmatch

তিনটি ফাংশনই প্রশ্ন করে “প্যাটার্নটা মেলে কি?”, কিন্তু কোথায় মিলতে হবে তা আলাদা। মিললে তিনটিই একটি match object ফেরত দেয়, না মিললে None.

নামটি বিভ্রান্তিকর: re.match “পুরোটা মেলে কি না” দেখে না, শুধু শুরুটা দেখে। re.match(r"\d+", "123abc") সফল — শুরুর 123 মিলেছে, পরের abc নিয়ে তার মাথাব্যথা নেই। তাই ফর্মে কেউ 017123456789 (১২ অঙ্ক) লিখলে match আর search দুটোই “ঠিক আছে” বলবে, কারণ প্রথম ১১টি অঙ্ক তো প্যাটার্নের সাথে মেলে! re.fullmatch (Python 3.4 থেকে আছে) ঠিক এই সমস্যার সমাধান: পুরো লেখা মিলতে হবে, একটি অক্ষরও বাড়তি থাকা চলবে না।

এবার দেখুন regex ইঞ্জিন ভেতরে কীভাবে মেলায় — প্যাটার্নের প্রতিটি অংশ এক এক করে লেখার অক্ষরের সাথে তুলনা:

প্যাটার্ন: 0  1  [3-9]  \d{8}
লেখা    : 0 1 7 1 2 3 4 5 6 7 8
           ↑ '0' == '0' ✔

প্যাটার্ন: 0  1  [3-9]  \d{8}
লেখা    : 0 1 7 1 2 3 4 5 6 7 8
             ↑ '1' == '1' ✔

প্যাটার্ন: 0  1  [3-9]  \d{8}
লেখা    : 0 1 7 1 2 3 4 5 6 7 8
               ↑ '7' কি 3–9-এর মধ্যে? ✔

প্যাটার্ন: 0  1  [3-9]  \d{8}
লেখা    : 0 1 7 1 2 3 4 5 6 7 8
                 ↑ ৮টি অঙ্ক গোনা হলো ✔ — প্যাটার্ন শেষ

প্যাটার্ন: 0  1  [3-9]  \d{8}
লেখা    : 0 1 2 1 2 3 4 5 6 7 8
               ↑ '2' 3–9-এর মধ্যে নেই ✘

ঘর 1 থেকে: '1' ≠ '0' ✘
ঘর 2 থেকে: '2' ≠ '0' ✘
…  কোথাও আর '0' নেই
ফল: None — কোথাও মিল নেই

বাকি ফাংশনগুলো — এক টেবিলে

re.compile কেন? regex লেখা থেকে ইঞ্জিন প্রথমে একটি ভেতরের কাঠামো বানায় — একে বলে compile করা। re module সাম্প্রতিক ব্যবহৃত প্যাটার্নগুলো নিজেই cache করে রাখে, তাই গতির পার্থক্য সাধারণত সামান্য। compile-এর আসল লাভ পরিষ্কার কোড: প্যাটার্নটি একবার একটি অর্থপূর্ণ নাম দিয়ে (BD_MOBILE) module-এর ওপরে রাখা যায়, পুরো প্রোগ্রাম সেটাই ব্যবহার করে, আর বদলাতে হলে এক জায়গায় বদলালেই হয়।

৩ · প্যাটার্নের ইট — character class, quantifier আর anchor

regex-এ বেশিরভাগ অক্ষর নিজেকেই মেলায়: Tk মেলায় ঠিক “Tk”. কিন্তু কিছু অক্ষরের বিশেষ মানে আছে — এদের বলে metacharacter: . ^ $ * + ? { } [ ] \ | ( ). এদের আসল অক্ষর হিসেবে খুঁজতে আগে backslash দিন: \. মানে আসল ডট, \+ মানে আসল যোগচিহ্ন। +880 খুঁজতে তাই লিখতে হয় \+880.

একটি ঘরে কোন অক্ষর বসতে পারে — character class

তৃতীয় বন্ধনী [...] দিয়ে লেখা হয় character class: ভেতরের যেকোনো একটি অক্ষর মেলে। [aeiou] একটি স্বরবর্ণ, [0-9] একটি অঙ্ক, [A-Za-z] একটি ইংরেজি অক্ষর। শুরুতে ^ দিলে উল্টো মানে: [^0-9] মানে “অঙ্ক ছাড়া যেকোনো একটি অক্ষর”। বহুল ব্যবহৃত class-গুলোর ছোট নামও আছে:

কতবার — quantifier

একটি অংশ কতবার পরপর আসবে, তা বলে quantifier. এটি সবসময় ঠিক আগের অংশের ওপর কাজ করে — একটি অক্ষর, একটি class, বা বন্ধনীতে ঘেরা একটি group.

একটি সূক্ষ্মতা: re.findall(r"\d{2,3}", "1 12 123 1234") দেয় ['12', '123', '123'] — শেষেরটি 1234-এর প্রথম তিন অঙ্ক, কারণ প্যাটার্নে বলা নেই সংখ্যাটা কোথায় শেষ হতে হবে। পুরো সংখ্যা চাইলে সীমানা বসান: \b\d{2,3}\b. এটাই anchor আর boundary-র কাজ — তারা কোনো অক্ষর খায় না, শুধু বলে “এখানে একটি সীমা থাকতে হবে”।

Anchor: ^, $ আর \b

^\d+$ মানে “শুরু থেকে শেষ পর্যন্ত শুধু অঙ্ক”। re.search-এর সাথে ^...$ দিলে প্রায় fullmatch-এর মতো কাজ হয় — তবে পুরোপুরি নয়: $ লেখার একেবারে শেষে থাকা একটি newline-এর ঠিক আগেও মেলে, তাই re.search(r"^\d+$", "123\n") সফল হয়। যাচাইয়ের জন্য তাই fullmatch বেশি নিরাপদ ও পরিষ্কার। আর \b বসে একটি “শব্দের অক্ষর” আর “শব্দের অক্ষর নয়” এমন কিছুর মাঝখানে: re.findall(r"\bcat\b", "cat catalog bobcat cat.") দেয় শুধু দুটি 'cat' — catalog আর bobcat-এর ভেতরেরগুলো বাদ।

৪ · greedy বনাম lazy — .* কতটুকু খাবে

quantifier ডিফল্টে greedy — লোভী: যতটা সম্ভব বেশি অক্ষর খায়, তারপর দরকার হলে একটু একটু করে ফেরত দেয়। সাধারণত এটাই চাই, কিন্তু একটি ক্লাসিক ক্ষেত্রে এটি চমকে দেয়। ধরুন "<b>bold</b>" থেকে ট্যাগগুলো তুলতে চান, আর লিখলেন <.*> — “<, তারপর যেকোনো কিছু, তারপর >”. আশা করছেন দুটি ট্যাগ, পাবেন পুরো লেখা একটিমাত্র মিল হিসেবে! quantifier-এর পরে ? দিলে সেটা হয় lazy — যত কম পারা যায়। ধাপে ধাপে দেখুন:

ঘর  : 0 1 2 3 4 5 6 7 8 9 10
লেখা: < b > b o l d < / b >
      ↑ '<' মিলল

ঘর  : 0 1 2 3 4 5 6 7 8 9 10
লেখা: < b > b o l d < / b >
                            ↑ শেষ — এবার '>' চাই, কিন্তু কিছু বাকি নেই

ঘর  : 0 1 2 3 4 5 6 7 8 9 10
লেখা: < b > b o l d < / b >
      .* ফেরত দিল ঘর 10-এর '>' → '>' মিলল ✔
মিল: '<b>bold</b>' — পুরোটা!

ঘর  : 0 1 2 3 4 5 6 7 8 9 10
লেখা: < b > b o l d < / b >
      .*? = '' ; এখন '>' চাই, ঘর 1-এ 'b' ✘

ঘর  : 0 1 2 3 4 5 6 7 8 9 10
লেখা: < b > b o l d < / b >
      .*? = 'b' ; ঘর 2-এ '>' ✔
প্রথম মিল: '<b>'

ঘর  : 0 1 2 3 4 5 6 7 8 9 10
লেখা: < b > b o l d < / b >
      ঘর 3–6 এ '<' নেই; ঘর 7 থেকে '</b>' ✔
ফল: ['<b>', '</b>']

বিকল্প | আর বন্ধনী

Alternation | মানে “এটা অথবা ওটা”: bKash|Nagad|Rocket. এর অগ্রাধিকার সবচেয়ে কম, তাই ^Tk|BDT$ মানে “শুরুতে Tk” অথবা “শেষে BDT” — সম্ভবত যা চেয়েছিলেন তা নয়। দলবদ্ধ করতে বন্ধনী দিন: ^(?:Tk|BDT)\s?\d+. আরও একটি চমক: Python-এর ইঞ্জিন বিকল্পগুলো বাম থেকে ক্রমানুসারে চেষ্টা করে, আর প্রথম যেটা মেলে সেটাই নেয় — সবচেয়ে লম্বাটা নয়। re.findall(r"a|ab", "ab") দেয় ['a']. তাই লম্বা বিকল্প আগে লিখুন: ab|a.

৫ · group, named group আর match object — মিলের ভেতর থেকে টুকরো তোলা

সাধারণ বন্ধনী ( ) দুটি কাজ করে: কয়েকটি অংশকে একসাথে বাঁধে (যাতে quantifier পুরোটার ওপর বসে, যেমন (ab)+), আর মেলা অংশটুকু আলাদা করে মনে রাখে। দ্বিতীয় কাজের জন্য একে বলে capturing group. শুধু বাঁধতে চাইলে, মনে রাখার দরকার না থাকলে, লিখুন (?:...) — non-capturing group.

মিল পাওয়া গেলে match object থেকে সব তথ্য তোলা যায়। m = re.search(r"(\d+)-(\d+)", "x 12-34 y") হলে:

• m.group() বা m.group(0) — পুরো মিল: '12-34'
• m.group(1), m.group(2) — প্রথম ও দ্বিতীয় বন্ধনীর মিল: '12', '34'
• m.groups() — সব group একটি tuple-এ: ('12', '34')
• m.span() — মিলটি লেখার কোন ঘর থেকে কোন ঘর: (2, 7); m.start(), m.end() আলাদা করেও পাওয়া যায়

group নম্বর দিয়ে ডাকা ভঙ্গুর — প্যাটার্নের শুরুতে একটি নতুন বন্ধনী যোগ করলেই সব নম্বর এক ঘর সরে যায়। এর সমাধান named group: (?P<amount>...). এখন m["amount"] বা m.group("amount") দিয়ে নাম ধরে ডাকা যায়, আর m.groupdict() সব নামসহ একটি dict দেয়। একটি bKash/Nagad-ধাঁচের SMS (কাল্পনিক) থেকে টাকার অঙ্ক আর transaction ID তোলা দেখুন:

1sms = "Received Tk 1,250.50 ... TrxID BK7Q2M9XA1"2m = TXN.search(sms)3trx = m["trx"]4amount = float(m["amount"].replace(",", ""))5print(m.groupdict(), amount)

re.sub — group দিয়ে আর ফাংশন দিয়ে বদলানো

re.sub-এর বদলি লেখার ভেতরে \1, \2 বা \g<name> লিখে মেলা group ফিরিয়ে আনা যায়। তারিখের ক্রম উল্টাতে: re.sub(r"(\d{2})/(\d{2})/(\d{4})", r"\3-\2-\1", "17/10/2026") দেয় '2026-10-17'. (মনে রাখুন, বদলি লেখাটিও raw string — না হলে "\1" হয়ে যায় একটি অদৃশ্য অক্ষর।)

বদলির নিয়ম আরও জটিল হলে লেখার জায়গায় একটি ফাংশন দিন। re প্রতিটি মিলের match object দিয়ে ফাংশনটি ডাকবে, আর ফাংশন যা ফেরত দেবে সেটাই বসবে: re.sub(r"\d+", lambda m: str(int(m.group()) * 2), "3 আম 10 কলা") দেয় '6 আম 20 কলা'. ফাংশন এখানে একটি সাধারণ মান হিসেবে পাঠানো হয়েছে — Python-এ ফাংশনও object (পর্ব ১৩), আর lambda-র বিস্তারিত পর্ব ৩৮-এ। ফোন নম্বর ঢাকার উদাহরণ পরের অংশের কোডে।

Flag — প্যাটার্নের আচরণ বদলানো

পুরো প্যাটার্নের আচরণ বদলানোর সুইচগুলোকে বলে flag. এগুলো দেওয়া হয় flags= argument-এ, বা re.compile-এর দ্বিতীয় argument হিসেবে:

কয়েকটি flag একসাথে দিতে | দিয়ে জুড়ুন: re.I | re.M. আর একটি নতুন নিয়ম: Python 3.13 থেকে re.sub, re.subn আর re.split-এ count, maxsplit বা flags অবস্থান ধরে (positional) দেওয়া deprecated — re.sub(p, r, s, 1) লিখলে DeprecationWarning আসে। নাম দিয়ে লিখুন: count=1, flags=re.I. পুরোনো টিউটোরিয়াল আর AI-এর কোডে এই পুরোনো রূপ প্রায়ই দেখবেন।

৬ · বাস্তব যাচাই — মোবাইল নম্বর, ইমেইল, তারিখ আর SMS

বাংলাদেশি মোবাইল নম্বর

একটি সাইন-আপ ফর্মে মোবাইল নম্বর নিচ্ছেন। মানুষ লিখবে 01712345678, কেউ +8801712345678, কেউ 8801712345678. লেখার সময় বাংলাদেশে মোবাইল অপারেটরের কোড 013 থেকে 019 (013 ও 017 গ্রামীণফোন, 014 ও 019 বাংলালিংক, 015 টেলিটক, 016 এয়ারটেল, 018 রবি) — এগুলো সময়ের সাথে বদলাতে পারে, তাই প্যাটার্নটি এক জায়গায় নাম দিয়ে রাখা জরুরি। এটি input validation-এর একটি ক্লাসিক উদাহরণ। নিয়মটি বাংলায়: “ঐচ্ছিকভাবে +88 বা 88, তারপর 01, তারপর 3–9-এর একটি অঙ্ক, তারপর ঠিক ৮টি ইংরেজি অঙ্ক — আর কিছু না”। regex-এ: (?:\+?88)?01[3-9][0-9]{8}, আর ব্যবহার fullmatch দিয়ে।

import re

BD_MOBILE = re.compile(r"(?:\+?88)?01[3-9][0-9]{8}")

tests = ["01712345678", "+8801812345678", "8801912345678",
         "01212345678", "0171234567", "017123456789", "০১৭১২৩৪৫৬৭৮"]
for t in tests:
    ok = BD_MOBILE.fullmatch(t) is not None
    print(f"{t:<15} {'ঠিক' if ok else 'ভুল'}")

text = "কল করুন 017123456789 নম্বরে"
print(re.search(r"01[3-9]\d{8}", text))
print(re.fullmatch(r"01[3-9]\d{8}", "017123456789"))
print(re.fullmatch(r"\d{11}", "০১৭১২৩৪৫৬৭৮") is not None)
print(re.fullmatch(r"\d{11}", "০১৭১২৩৪৫৬৭৮", flags=re.ASCII))

def mask(m):
    return "*" * len(m.group(1)) + m.group(2)

print(re.sub(r"^(\d+)(\d{3})$", mask, "01712345678"))

ইমেইল — নিখুঁত regex একটি ফাঁদ

ইন্টারনেটে “perfect email regex” খুঁজলে কয়েকশো অক্ষরের দানব পাবেন — Perl-এর একটি পুরোনো module-এ ইমেইলের মান (RFC 822) মেনে লেখা regex কয়েক হাজার অক্ষর লম্বা! কারণ ইমেইলের অফিসিয়াল নিয়ম অবিশ্বাস্য রকম উদার: কোটের ভেতরে space, মন্তব্য, অদ্ভুত চিহ্ন, এমনকি এখন বাংলা অক্ষরের ডোমেইনও বৈধ। বাস্তব পরামর্শ: শুধু একটি সহজ আকৃতি-যাচাই করুন — “@-এর আগে কিছু, পরে কিছু, তারপর একটি ডট আর ডোমেইন” — যেমন [^@\s]+@[^@\s]+\.[A-Za-z]{2,}, fullmatch দিয়ে। ঠিকানাটা আসল কি না, তা জানার একমাত্র নির্ভরযোগ্য উপায় সেখানে একটি যাচাই-লিংক পাঠানো।

তারিখ — regex আকৃতি দেখে, datetime অর্থ দেখে

\d{2}/\d{2}/\d{4} বলে লেখাটা dd/mm/yyyy-এর মতো দেখতে। কিন্তু 31/02/2026-ও এই আকৃতি পাস করে, অথচ ফেব্রুয়ারিতে ৩১ তারিখ নেই। regex দিয়ে মাসভেদে দিনের সংখ্যা আর লিপ ইয়ার যাচাই করা সম্ভব, কিন্তু সেই প্যাটার্ন কেউ পড়তে পারবে না। সঠিক ভাগাভাগি: regex দিয়ে আকৃতি, তারপর পর্ব ২৭-এর datetime.strptime(s, "%d/%m/%Y") দিয়ে অর্থ — অবৈধ তারিখে এটি ValueError দেয় (Python 3.14-এ বার্তাটি এমন: day 31 must be in range 1..28 for month 2 in year 2026).

SMS থেকে টাকা — finditer আর VERBOSE

অংশ ৫-এর stepper-এ একটি SMS থেকে টাকার অঙ্ক তোলা দেখেছেন। বাস্তবে একটি ফাইলে শত শত SMS থাকে, আর প্রতিটির জন্য একটি করে মিল চাই — এখানে finditer সেরা, কারণ প্রতিটি মিলের পুরো match object দেয়, named group-সহ। পুরো উদাহরণটি অংশ ৭-এর শেষের কোডে, বাংলা লেখার কয়েকটি পরীক্ষার সাথে।

৭ · বাংলা লেখায় regex — \w আর \b-এর ফাঁদ

পর্ব ০৯-এ দেখেছেন, বাংলা লেখায় চোখের একটি অক্ষর কয়েকটি code point হতে পারে: “কি” = ক + ি, “ক্ষ” = ক + হসন্ত + ষ. regex ইঞ্জিনও code point ধরে চলে — আর এখানেই বাংলার জন্য বড় ফাঁদ।

Python-এর ডকুমেন্টেশন অনুযায়ী \w মেলায় এমন অক্ষর, যার জন্য str.isalnum() সত্য, আর _. বাংলা ব্যঞ্জন আর স্বরবর্ণ (ক, আ) এর মধ্যে পড়ে। কিন্তু কার-চিহ্ন (া ি ী ু…), হসন্ত, অনুস্বার, চন্দ্রবিন্দু — Unicode-এর হিসাবে এরা অক্ষর নয়, combining mark. ফলে:

>>> re.findall(r"\w+", "আমি কাল ঢাকা যাব")
['আম', 'ক', 'ল', 'ঢ', 'ক', 'য', 'ব']

প্রতিটি কার-চিহ্নে শব্দ ভেঙে গেছে! ইংরেজিতে যে প্যাটার্ন নিখুঁত শব্দ গোনে, বাংলায় সেটা আবর্জনা দেয়। একই কারণে \b-ও বাংলায় ভুল জায়গায় বসে। \b হলো \w আর অ-\w-এর মাঝের সীমানা; “কি”-এর ক আর ি-এর মাঝেই একটি সীমানা তৈরি হয়ে যায়। পরীক্ষা করে দেখা গেছে: re.findall(r"\bকি\b", "কি খবর, কিন্তু") একটি 'কি' দেয় — কিন্তু সেটা “কিন্তু”-র ভেতরের, ঘর 8 থেকে! আলাদা শব্দ “কি”-টি বাদ পড়ে, কারণ ি আর পরের space দুটোই অ-\w, তাদের মাঝে কোনো সীমানা নেই। আর “কিন্তু”-তে ি-এর পর ন আসে, যা \w — সেখানে সীমানা আছে। ঠিক উল্টো ফল।

আরেকটি বিষয় পর্ব ০৯ থেকে মনে রাখুন: একই দেখতে লেখা ভিন্ন code point-এ থাকতে পারে (যেমন “ড়” একক U+09DC, অথবা ড + নুক্তা)। আপনার প্যাটার্নে এক রূপ, ইনপুটে আরেক রূপ থাকলে মিলবে না। তাই বাইরে থেকে আসা বাংলা লেখায় regex চালানোর আগে normalization (unicodedata.normalize("NFC", s)) করে নিন। আর grapheme cluster ধরে কাজ করতে (চোখের অক্ষর ধরে গোনা বা কাটা) standard library-র re যথেষ্ট নয়; তৃতীয় পক্ষের regex package-এর \X প্যাটার্ন এই কাজ করে।

এবার সব একসাথে — VERBOSE প্যাটার্নে দুটি কাল্পনিক SMS থেকে TrxID ও টাকা, তারপর বাংলা লেখায় \w বনাম Unicode খণ্ড, একাধিক চিহ্নে ভাঙা, বাড়তি ফাঁকা পরিষ্কার আর তারিখের ক্রম বদল:

import re

sms = """You have received Tk 1,250.50 from 01712345678. TrxID BK7Q2M9XA1 at 17/10/2026 10:15
Cash Out Tk 500.00 successful. Fee Tk 9.25. TrxID NG4H8T2ZP0 at 17/10/2026 18:40"""

TXN = re.compile(r"""
    Tk\s(?P<amount>[0-9,]+\.[0-9]{2})   # টাকার অঙ্ক, কমাসহ
    .*?                                 # মাঝের লেখা — যত কম পারা যায়
    TrxID\s(?P<trx>[A-Z0-9]{10})        # ১০ ঘরের transaction ID
""", re.VERBOSE)

for m in TXN.finditer(sms):
    amount = float(m["amount"].replace(",", ""))
    print(m["trx"], amount)

print(re.findall(r"\w+", "আমি কাল ঢাকা যাব"))
print(re.findall(r"[\u0980-\u09FF]+", "আমি কাল ঢাকা যাব"))
print(re.split(r"\s*[,;|]\s*", "আম, কলা;লিচু | জাম"))
print(re.sub(r"\s+", " ", "  অনেক   ফাঁকা \t জায়গা  ").strip())
print(re.sub(r"(\d{2})/(\d{2})/(\d{4})", r"\3-\2-\1", "তারিখ 17/10/2026"))

৮ · নিরাপত্তা আর কখন regex নয় — catastrophic backtracking

অংশ ৪-এ দেখেছেন, Python-এর ইঞ্জিন মেলাতে না পারলে পেছনে ফিরে অন্য উপায়ে চেষ্টা করে (backtracking). বেশিরভাগ প্যাটার্নে এই ফিরে যাওয়া সামান্য। কিন্তু কিছু প্যাটার্নে একই লেখা মেলানোর অসংখ্য উপায় থাকে, আর মিল শেষ পর্যন্ত ব্যর্থ হলে ইঞ্জিন প্রতিটি উপায় চেষ্টা করে দেখে। একে বলে catastrophic backtracking. সবচেয়ে ছোট উদাহরণ: (a+)+$ — “এক বা একাধিক a-এর দল, এমন এক বা একাধিক দল, তারপর শেষ”। লেখা aaaa…a! হলে (শেষে একটি !, তাই মিল অসম্ভব) কী ঘটে, দেখুন — শুধু হিসাব, চালানো নয়:

৪টি a-কে দলে ভাগ করার উপায়:
(aaaa)  (aaa)(a)  (a)(aaa)  (aa)(aa)
(aa)(a)(a)  (a)(aa)(a)  (a)(a)(aa)  (a)(a)(a)(a)
প্রতিটির শেষে '!' — $ মেলে না ✘

প্রতি নতুন a: আগের দলে জুড়বে, নাকি নতুন দল?
→ প্রতিবার ২টি পথ, উপায় দ্বিগুণ
n = 10 → 2^9 = 512 উপায়

n = 20 → 2^19 = 524,288 উপায়
প্রায় সোয়া পাঁচ লাখ চেষ্টা — একটিমাত্র ছোট লেখায়

n = 30 → 2^29 = 536,870,912 উপায়
প্রায় ৫৪ কোটি — একটি ৩১ অক্ষরের ইনপুটে!

a+$ : a-গুলো ভাগ করার একটিমাত্র উপায়
n = 30 → মোটামুটি n-এর অনুপাতে ধাপ
নিয়ম: quantifier-এর ভেতরে quantifier নয়

প্রতিরক্ষার নিয়ম

• সরল প্যাটার্ন: nested quantifier নয়; .*-এর বদলে যতটা সম্ভব নির্দিষ্ট class ([^,]*, [0-9]{8}).
• Anchor দিন: fullmatch বা ^...$ ইঞ্জিনকে অসংখ্য শুরুর ঘর থেকে চেষ্টা করা থেকে বাঁচায়।
• ইনপুটের দৈর্ঘ্য সীমিত করুন: regex চালানোর আগে if len(s) > 100: reject. একটি মোবাইল নম্বর ২০ অক্ষরের বেশি হওয়ার কোনো কারণ নেই।
• ব্যবহারকারীর লেখা দিয়ে প্যাটার্ন বানাবেন না: কারও সার্চ-বক্সের লেখা সরাসরি প্যাটার্নে বসালে সে নিজেই বিপজ্জনক প্যাটার্ন পাঠাতে পারে। আক্ষরিক খোঁজার জন্য re.escape(text), বা আরও সহজে text in s.
• বিশ্বাস নেই এমন ইনপুটে বড় সিস্টেম: সেখানে RE2-র মতো linear-time ইঞ্জিন (ভাবনার প্রশ্ন ০৫) বিবেচনা করুন।

কখন regex নয়

HTML কেন regex দিয়ে নয়? কারণ HTML-এর ট্যাগ একটির ভেতরে আরেকটি যত গভীরে খুশি থাকতে পারে, attribute-এর ক্রম বদলাতে পারে, কোট এক বা জোড়া হতে পারে, মন্তব্যের ভেতরে নকল ট্যাগ থাকতে পারে। গণিতের দিক থেকেও, আসল “regular” expression ইচ্ছামতো গভীর বাসা-বাঁধা কাঠামো (যেমন মেলানো বন্ধনী) চিনতে পারে না — এটা theory of computation-এর একটি প্রমাণিত সীমা। parser এই কাজের জন্যই তৈরি।

regex লেখা আর পরীক্ষার অভ্যাস

regex101.com-এর মতো অনলাইন টেস্টারে প্যাটার্ন বসিয়ে কয়েকটি উদাহরণ লেখা দিলে সেটি প্রতিটি অংশের ব্যাখ্যা দেখায়, কোন group কী ধরল তা রঙ দিয়ে দেখায়। সেখানে “Python” flavor বেছে নিতে ভুলবেন না — বিভিন্ন ভাষার regex-এ ছোটখাটো পার্থক্য আছে। তবে টেস্টারে পাস করাই শেষ কথা নয়: আসল যাচাই হলো আপনার কোডে একগুচ্ছ “ঠিক” আর “ভুল” উদাহরণের টেস্ট, যা প্রতিবার প্যাটার্ন বদলালে চলবে (pytest শিখবেন পর্ব ৩৯-এ)। আর প্রতিটি অ-সরল প্যাটার্ন re.VERBOSE-এ মন্তব্যসহ লিখুন।

৯ · AI-এর যুগে — AI-এর লেখা regex যাচাই

regex এমন একটি জায়গা, যেখানে AI সবচেয়ে আত্মবিশ্বাসী আর সবচেয়ে বিপজ্জনক দুটোই। কয়েক সেকেন্ডে সে একটি লম্বা প্যাটার্ন দেয়, যা দেখতে পেশাদার — কিন্তু কেউ পড়ে যাচাই করতে পারে না, তাই ভুলগুলো চুপচাপ প্রোডাকশনে চলে যায়। নিচের ভুলগুলো বাস্তবে বারবার দেখা যায়:

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

• প্যাটার্নটির প্রতিটি অংশ নিজে পড়ে বাংলায় বলতে পারি এটা কী মেলায় — না পারলে VERBOSE-এ ভেঙে লিখতে বলেছি
• প্যাটার্ন raw string-এ, আর যাচাইয়ের কাজে fullmatch
• \d, \w, \b থাকলে ভেবেছি — Unicode আচরণ (বাংলা অঙ্ক, কার-চিহ্ন) এখানে চাই কি না
• “ঠিক” উদাহরণের পাশাপাশি “ভুল” আর কিনারার (edge case) উদাহরণ দিয়ে চালিয়ে দেখেছি — খালি লেখা, বাড়তি অক্ষর, বাংলা লেখা
• nested quantifier নেই, আর regex চালানোর আগে ইনপুটের দৈর্ঘ্য সীমিত
• HTML, JSON, CSV বা তারিখের অর্থের কাজে regex নয়, ঠিক যন্ত্র (parser, module, datetime) ব্যবহার হয়েছে