কিভাবে পাইথন রেগুলার এক্সপ্রেশন মডিউল পুনরায় ব্যবহার করবেন (ম্যাচ, সার্চ, সাব, ইত্যাদি)

পাইথনে রেগুলার এক্সপ্রেশন প্রসেসিং করতে, আমরা স্ট্যান্ডার্ড লাইব্রেরি থেকে re মডিউল ব্যবহার করি। এটি আপনাকে রেগুলার এক্সপ্রেশন প্যাটার্ন ব্যবহার করে স্ট্রিং বের করতে, প্রতিস্থাপন করতে এবং বিভক্ত করতে দেয়।

• re — Regular expression operations — Python 3.10.0 Documentation
• Regular Expression HOWTO — Python 3.10.0 Documentation

এই বিভাগে, আমরা প্রথমে re মডিউলের কাজ এবং পদ্ধতি ব্যাখ্যা করব।

• নিয়মিত অভিব্যক্তি নিদর্শন সংকলন:compile()
• মিল বস্তু
• স্ট্রিং এর শুরু মেলে কিনা পরীক্ষা করুন, এক্সট্রাক্ট করুন:match()
• শুরুতে সীমাবদ্ধ নয় এমন ম্যাচের জন্য পরীক্ষা করুন:search()
• পুরো স্ট্রিং মেলে কিনা তা পরীক্ষা করুন:fullmatch()
• সমস্ত মিলে যাওয়া অংশগুলির একটি তালিকা পান:findall()
• একটি পুনরাবৃত্তিকারী হিসাবে সমস্ত মিলে যাওয়া অংশগুলি পান:finditer()
• মিলিত অংশ প্রতিস্থাপন করুন:sub(),subn()
• রেগুলার এক্সপ্রেশন প্যাটার্ন সহ স্ট্রিং বিভক্ত করা:split()

এর পরে, আমি মেটা অক্ষর (বিশেষ অক্ষর) এবং রেগুলার এক্সপ্রেশনের বিশেষ ক্রম ব্যাখ্যা করব যা পুনরায় মডিউলে ব্যবহার করা যেতে পারে। মূলত, এটি স্ট্যান্ডার্ড রেগুলার এক্সপ্রেশন সিনট্যাক্স, তবে পতাকা সেট করার বিষয়ে সতর্ক থাকুন (বিশেষ করে re.ASCII)।

• পাইথনে রেগুলার এক্সপ্রেশন মেটাক্যারেক্টার, বিশেষ সিকোয়েন্স এবং সতর্কতা
• পতাকা স্থাপন
  • ASCII অক্ষরের মধ্যে সীমাবদ্ধ:re.ASCII
  • কেস-সংবেদনশীল নয়:re.IGNORECASE
  • প্রতিটি লাইনের শুরু এবং শেষ মিল করুন:re.MULTILINE
  • একাধিক পতাকা নির্দিষ্ট করুন
• লোভী এবং অ-লোভী মেলে

রেগুলার এক্সপ্রেশন প্যাটার্ন কম্পাইল করুন: compile()

রি মডিউলে নিয়মিত এক্সপ্রেশন প্রসেসিং করার দুটি উপায় রয়েছে।

ফাংশন দিয়ে চালান

প্রথমটি একটি ফাংশন।re.match(),re.sub()রেগুলার এক্সপ্রেশন প্যাটার্ন ব্যবহার করে নিষ্কাশন, প্রতিস্থাপন এবং অন্যান্য প্রক্রিয়া সঞ্চালনের জন্য এই ধরনের ফাংশন উপলব্ধ।

ফাংশনগুলির বিশদ বিবরণ পরে বর্ণনা করা হবে, তবে তাদের সকলের মধ্যে, প্রথম আর্গুমেন্ট হল রেগুলার এক্সপ্রেশন প্যাটার্নের স্ট্রিং, তারপরে প্রসেস করা স্ট্রিং ইত্যাদি। উদাহরণস্বরূপ, re.sub(), যা প্রতিস্থাপন করে, দ্বিতীয় আর্গুমেন্ট হল প্রতিস্থাপন স্ট্রিং, এবং তৃতীয় আর্গুমেন্ট হল প্রক্রিয়া করা স্ট্রিং।

import re

s = 'aaa@xxx.com, bbb@yyy.com, ccc@zzz.net'

m = re.match(r'([a-z]+)@([a-z]+)\.com', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>

result = re.sub(r'([a-z]+)@([a-z]+)\.com', 'new-address', s)
print(result)
# new-address, new-address, ccc@zzz.net

উল্লেখ্য যে এই উদাহরণে রেগুলার এক্সপ্রেশন প্যাটার্নে [a-z] মানে a থেকে z (অর্থাৎ ছোট হাতের বর্ণমালা), এবং + মানে আগের প্যাটার্নটি (এই ক্ষেত্রে [a-z]) এক বা একাধিকবার পুনরাবৃত্তি করুন। [a-z]+ যে কোনো স্ট্রিংয়ের সাথে মেলে যা এক বা একাধিক ছোট হাতের বর্ণমালার অক্ষর পুনরাবৃত্তি করে।

. এটি একটি মেটা অক্ষর (বিশেষ অর্থ সহ একটি অক্ষর) এবং একটি ব্যাকস্ল্যাশ দিয়ে এস্কেপ করা আবশ্যক৷

যেহেতু রেগুলার এক্সপ্রেশন প্যাটার্ন স্ট্রিংগুলি প্রায়শই প্রচুর ব্যাকস্ল্যাশ ব্যবহার করে, তাই উদাহরণের মতো কাঁচা স্ট্রিং ব্যবহার করা সুবিধাজনক।

একটি রেগুলার এক্সপ্রেশন প্যাটার্ন অবজেক্টের পদ্ধতিতে চলে

re মডিউলে রেগুলার এক্সপ্রেশন প্রক্রিয়া করার দ্বিতীয় উপায় হল রেগুলার এক্সপ্রেশন প্যাটার্ন অবজেক্ট পদ্ধতি।

re.compile(), ব্যবহার করে আপনি একটি রেগুলার এক্সপ্রেশন প্যাটার্ন অবজেক্ট তৈরি করতে একটি রেগুলার এক্সপ্রেশন প্যাটার্ন স্ট্রিং কম্পাইল করতে পারেন।

p = re.compile(r'([a-z]+)@([a-z]+)\.com')

print(p)
# re.compile('([a-z]+)@([a-z]+)\\.com')

print(type(p))
# <class 're.Pattern'>

re.match(),re.sub()উদাহরণস্বরূপ, রেগুলার এক্সপ্রেশন অবজেক্টের মেথড ম্যাচ(),সাব() হিসাবে এই ফাংশনগুলির মতো একই প্রক্রিয়া চালানো যেতে পারে।

m = p.match(s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>

result = p.sub('new-address', s)
print(result)
# new-address, new-address, ccc@zzz.net

নীচে বর্ণিত সমস্ত re.xxx() ফাংশনও রেগুলার এক্সপ্রেশন অবজেক্টের পদ্ধতি হিসাবে প্রদান করা হয়েছে।

আপনি যদি একই প্যাটার্ন ব্যবহার করে এমন একটি প্রক্রিয়া পুনরাবৃত্তি করেন, তাহলে re.compile() দিয়ে একটি রেগুলার এক্সপ্রেশন অবজেক্ট তৈরি করা এবং এটি ব্যবহার করা আরও কার্যকর।

নিম্নলিখিত নমুনা কোডে, সুবিধার জন্য কম্পাইল না করেই ফাংশনটি ব্যবহার করা হয়, কিন্তু আপনি যদি একই প্যাটার্ন বারবার ব্যবহার করতে চান, তাহলে এটিকে আগে থেকে কম্পাইল করার এবং একটি রেগুলার এক্সপ্রেশন অবজেক্টের পদ্ধতি হিসাবে এটি চালানোর পরামর্শ দেওয়া হয়।

মিল বস্তু

match(), search(), ইত্যাদি একটি ম্যাচ অবজেক্ট রিটার্ন করে।

s = 'aaa@xxx.com'

m = re.match(r'[a-z]+@[a-z]+\.[a-z]+', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>

print(type(m))
# <class 're.Match'>

মিলিত স্ট্রিং এবং অবস্থান মিল বস্তুর নিম্নলিখিত পদ্ধতি ব্যবহার করে প্রাপ্ত করা হয়.

• ম্যাচের অবস্থান পান:start(),end(),span()
• মিলে যাওয়া স্ট্রিং পান:group()
• প্রতিটি গ্রুপের জন্য স্ট্রিং পান:groups()

print(m.start())
# 0

print(m.end())
# 11

print(m.span())
# (0, 11)

print(m.group())
# aaa@xxx.com

যদি আপনি একটি রেগুলার এক্সপ্রেশন প্যাটার্নের একটি অংশ বন্ধনী() সহ একটি স্ট্রিং এ আবদ্ধ করেন, তবে অংশটি একটি গ্রুপ হিসাবে প্রক্রিয়া করা হবে। এই ক্ষেত্রে, যে অংশের স্ট্রিংটি প্রতিটি গ্রুপের সাথে group() এর সাথে মেলে তা একটি টিপল হিসাবে পাওয়া যেতে পারে।

m = re.match(r'([a-z]+)@([a-z]+)\.([a-z]+)', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>

print(m.groups())
# ('aaa', 'xxx', 'com')

একটি স্ট্রিং এর শুরু মেলে কিনা পরীক্ষা করুন, extract: match()

ম্যাচ() একটি ম্যাচ অবজেক্ট প্রদান করে যদি স্ট্রিংয়ের শুরু প্যাটার্নের সাথে মেলে।

উপরে উল্লিখিত হিসাবে, ম্যাচ অবজেক্টটি মিলিত সাবস্ট্রিং বের করতে বা একটি ম্যাচ তৈরি হয়েছে কিনা তা পরীক্ষা করতে ব্যবহার করা যেতে পারে।

match() শুধুমাত্র শুরু পরীক্ষা করবে। শুরুতে কোন মিল স্ট্রিং না থাকলে, এটি কোনটিই ফেরত দেয় না।

s = 'aaa@xxx.com, bbb@yyy.com, ccc@zzz.net'

m = re.match(r'[a-z]+@[a-z]+\.com', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>

m = re.match(r'[a-z]+@[a-z]+\.net', s)
print(m)
# None

শুরুতে সীমাবদ্ধ নয় এমন মিলের জন্য পরীক্ষা করুন, বের করুন: অনুসন্ধান()

ম্যাচ() এর মতো, এটি মেলে যদি এটি একটি ম্যাচ অবজেক্ট ফেরত দেয়।

একাধিক ম্যাচিং অংশ থাকলে, শুধুমাত্র প্রথম ম্যাচিং অংশ ফেরত দেওয়া হবে।

s = 'aaa@xxx.com, bbb@yyy.com, ccc@zzz.net'

m = re.search(r'[a-z]+@[a-z]+\.net', s)
print(m)
# <re.Match object; span=(26, 37), match='ccc@zzz.net'>

m = re.search(r'[a-z]+@[a-z]+\.com', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>

আপনি যদি সমস্ত মিলে যাওয়া অংশগুলি পেতে চান তবে নীচে বর্ণিত হিসাবে Findall() বা Finditer() ব্যবহার করুন।

পুরো স্ট্রিং মেলে কিনা তা পরীক্ষা করুন: fullmatch()

পুরো স্ট্রিং নিয়মিত এক্সপ্রেশন প্যাটার্নের সাথে মেলে কিনা তা পরীক্ষা করতে, fullmatch() ব্যবহার করুন। এটি দরকারী, উদাহরণস্বরূপ, একটি স্ট্রিং একটি ইমেল ঠিকানা হিসাবে বৈধ কিনা তা পরীক্ষা করতে।

যদি সম্পূর্ণ স্ট্রিং মিলে যায়, একটি মিল বস্তু ফেরত দেওয়া হয়।

s = 'aaa@xxx.com'

m = re.fullmatch(r'[a-z]+@[a-z]+\.com', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>

যদি অতুলনীয় অংশ থাকে (শুধুমাত্র আংশিক মিল বা কোনো মিল নেই), কোনোটি ফেরত দেওয়া হয় না।

s = '!!!aaa@xxx.com!!!'

m = re.fullmatch(r'[a-z]+@[a-z]+\.com', s)
print(m)
# None

Python 3.4 এ fullmatch() যোগ করা হয়েছে। আপনি যদি পূর্ববর্তী সংস্করণগুলিতে একই কাজ করতে চান তবে শেষে ম্যাচ() এবং একটি মিল মেটা অক্ষর $ ব্যবহার করুন। যদি শুরু থেকে শেষ পর্যন্ত সম্পূর্ণ স্ট্রিং মেলে না, তবে এটি কোনটিই ফেরত দেয় না।

s = '!!!aaa@xxx.com!!!'

m = re.match(r'[a-z]+@[a-z]+\.com$', s)
print(m)
# None

সমস্ত মিলে যাওয়া অংশগুলির একটি তালিকা পান: findall()

findall() সমস্ত মিলে যাওয়া সাবস্ট্রিংগুলির একটি তালিকা প্রদান করে। নোট করুন যে তালিকার উপাদানগুলি মিলিত বস্তু নয় কিন্তু স্ট্রিং।

s = 'aaa@xxx.com, bbb@yyy.com, ccc@zzz.net'

result = re.findall(r'[a-z]+@[a-z]+\.[a-z]+', s)
print(result)
# ['aaa@xxx.com', 'bbb@yyy.com', 'ccc@zzz.net']

মিলিত অংশের সংখ্যা বিল্ট-ইন ফাংশন len() ব্যবহার করে পরীক্ষা করা যেতে পারে, যা তালিকায় উপাদানের সংখ্যা প্রদান করে।

print(len(result))
# 3

রেগুলার এক্সপ্রেশন প্যাটার্নে বন্ধনী() দিয়ে গ্রুপ করা টিপলের একটি তালিকা প্রদান করে যার উপাদানগুলি প্রতিটি গ্রুপের স্ট্রিং। এটি ম্যাচ অবজেক্টে গ্রুপ() এর সমতুল্য।

result = re.findall(r'([a-z]+)@([a-z]+)\.([a-z]+)', s)
print(result)
# [('aaa', 'xxx', 'com'), ('bbb', 'yyy', 'com'), ('ccc', 'zzz', 'net')]

গ্রুপ বন্ধনী () নেস্ট করা যেতে পারে, তাই আপনি যদি পুরো ম্যাচটিও পেতে চান তবে পুরো ম্যাচটি বন্ধনী () এ আবদ্ধ করুন।

result = re.findall(r'(([a-z]+)@([a-z]+)\.([a-z]+))', s)
print(result)
# [('aaa@xxx.com', 'aaa', 'xxx', 'com'), ('bbb@yyy.com', 'bbb', 'yyy', 'com'), ('ccc@zzz.net', 'ccc', 'zzz', 'net')]

কোনো মিল পাওয়া না গেলে, একটি খালি টিপল ফেরত দেওয়া হয়।

result = re.findall('[0-9]+', s)
print(result)
# []

একটি পুনরাবৃত্তিকারী হিসাবে সমস্ত মিলে যাওয়া অংশগুলি পান: সন্ধানকারী()

finditer() একটি পুনরাবৃত্তিকারী হিসাবে সমস্ত মিলে যাওয়া অংশ ফেরত দেয়। উপাদানগুলি findall() এর মতো স্ট্রিং নয়, কিন্তু বস্তুর সাথে মেলে, তাই আপনি মিলে যাওয়া অংশগুলির অবস্থান (সূচী) পেতে পারেন।

ইটারেটর নিজেই প্রিন্ট() দিয়ে প্রিন্ট করা যাবে না এর বিষয়বস্তু পেতে। আপনি বিল্ট-ইন ফাংশন নেক্সট() বা ফর স্টেটমেন্ট ব্যবহার করলে, আপনি একের পর এক বিষয়বস্তু পেতে পারেন।

s = 'aaa@xxx.com, bbb@yyy.com, ccc@zzz.net'

result = re.finditer(r'[a-z]+@[a-z]+\.[a-z]+', s)
print(result)
# <callable_iterator object at 0x10b0efa90>

print(type(result))
# <class 'callable_iterator'>

for m in result:
    print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>
# <re.Match object; span=(13, 24), match='bbb@yyy.com'>
# <re.Match object; span=(26, 37), match='ccc@zzz.net'>

এটি তালিকা() সহ একটি তালিকায় রূপান্তরিত করা যেতে পারে।

l = list(re.finditer(r'[a-z]+@[a-z]+\.[a-z]+', s))
print(l)
# [<re.Match object; span=(0, 11), match='aaa@xxx.com'>, <re.Match object; span=(13, 24), match='bbb@yyy.com'>, <re.Match object; span=(26, 37), match='ccc@zzz.net'>]

print(l[0])
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>

print(type(l[0]))
# <class 're.Match'>

print(l[0].span())
# (0, 11)

আপনি যদি সমস্ত মিলে যাওয়া অংশগুলির অবস্থান পেতে চান তবে তালিকা বোঝার স্বরলিপি list() এর চেয়ে বেশি সুবিধাজনক।

print([m.span() for m in re.finditer(r'[a-z]+@[a-z]+\.[a-z]+', s)])
# [(0, 11), (13, 24), (26, 37)]

পুনরাবৃত্তিকারী ক্রমানুসারে উপাদান বের করে। মনে রাখবেন যে আপনি যদি শেষ পর্যন্ত পৌঁছানোর পরে আরও উপাদান বের করার চেষ্টা করেন তবে আপনার কিছুই অবশিষ্ট থাকবে না।

result = re.finditer(r'[a-z]+@[a-z]+\.[a-z]+', s)

for m in result:
    print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>
# <re.Match object; span=(13, 24), match='bbb@yyy.com'>
# <re.Match object; span=(26, 37), match='ccc@zzz.net'>

print(list(result))
# []

মিলিত অংশগুলি প্রতিস্থাপন করুন: sub(), subn()

sub() ব্যবহার করে, আপনি মিলিত অংশটিকে অন্য স্ট্রিং দিয়ে প্রতিস্থাপন করতে পারেন। প্রতিস্থাপিত স্ট্রিং ফিরিয়ে দেওয়া হবে।

s = 'aaa@xxx.com, bbb@yyy.com, ccc@zzz.net'

result = re.sub(r'[a-z]+@[a-z]+\.com', 'new-address', s)
print(result)
# new-address, new-address, ccc@zzz.net

print(type(result))
# <class 'str'>

বন্ধনী () দিয়ে গোষ্ঠীবদ্ধ করার সময়, মিলে যাওয়া স্ট্রিংটি প্রতিস্থাপিত স্ট্রিং-এ ব্যবহার করা যেতে পারে।

ডিফল্টরূপে, নিম্নলিখিতগুলি সমর্থিত: মনে রাখবেন যে সাধারণ স্ট্রিংগুলির জন্য যেগুলি কাঁচা স্ট্রিং নয়, ব্যাকস্ল্যাশ থেকে বাঁচতে ব্যাকস্ল্যাশের আগে একটি ব্যাকস্ল্যাশ তালিকাভুক্ত করা আবশ্যক৷

result = re.sub(r'([a-z]+)@([a-z]+)\.com', r'\1@\2.net', s)
print(result)
# aaa@xxx.net, bbb@yyy.net, ccc@zzz.net

?P<xxx>
আপনি যদি রেগুলার এক্সপ্রেশন প্যাটার্নের বন্ধনীর শুরুতে এটি লিখে গ্রুপের নাম দেন, তাহলে নিচে দেখানো হিসাবে আপনি সংখ্যার পরিবর্তে নাম ব্যবহার করে এটি নির্দিষ্ট করতে পারেন।
\g<xxx>

result = re.sub(r'(?P<local>[a-z]+)@(?P<SLD>[a-z]+)\.com', r'\g<local>@\g<SLD>.net', s)
print(result)
# aaa@xxx.net, bbb@yyy.net, ccc@zzz.net

যুক্তি সংখ্যা প্রতিস্থাপনের সর্বোচ্চ সংখ্যা নির্দিষ্ট করে। শুধুমাত্র বাম দিক থেকে গণনা প্রতিস্থাপিত হবে.

result = re.sub(r'[a-z]+@[a-z]+\.com', 'new-address', s, count=1)
print(result)
# new-address, bbb@yyy.com, ccc@zzz.net

subn() প্রতিস্থাপিত স্ট্রিং (sub() এর রিটার্ন মানের সমান) এবং প্রতিস্থাপিত অংশের সংখ্যা (প্যাটার্নের সাথে মিলে যাওয়া সংখ্যা) এর একটি টিপল প্রদান করে।

result = re.subn(r'[a-z]+@[a-z]+\.com', 'new-address', s)
print(result)
# ('new-address, new-address, ccc@zzz.net', 2)

আর্গুমেন্ট নির্দিষ্ট করার পদ্ধতি সাব() এর মতই। আপনি বন্ধনী দ্বারা গোষ্ঠীবদ্ধ অংশটি ব্যবহার করতে পারেন, বা আর্গুমেন্ট গণনা নির্দিষ্ট করতে পারেন।

result = re.subn(r'(?P<local>[a-z]+)@(?P<SLD>[a-z]+)\.com', r'\g<local>@\g<SLD>.net', s)
print(result)
# ('aaa@xxx.net, bbb@yyy.net, ccc@zzz.net', 2)

result = re.subn(r'[a-z]+@[a-z]+\.com', 'new-address', s, count=1)
print(result)
# ('new-address, bbb@yyy.com, ccc@zzz.net', 1)

রেগুলার এক্সপ্রেশন প্যাটার্ন সহ স্ট্রিং বিভক্ত করা: split()

split() প্যাটার্নের সাথে মেলে এমন অংশে স্ট্রিংকে বিভক্ত করে এবং একটি তালিকা হিসাবে ফেরত দেয়।

মনে রাখবেন যে প্রথম এবং শেষ ম্যাচের ফলাফল তালিকার শুরুতে এবং শেষে খালি স্ট্রিং থাকবে।

s = '111aaa222bbb333'

result = re.split('[a-z]+', s)
print(result)
# ['111', '222', '333']

result = re.split('[0-9]+', s)
print(result)
# ['', 'aaa', 'bbb', '']

maxsplit আর্গুমেন্ট সর্বোচ্চ সংখ্যক বিভাজন (টুকরা) নির্দিষ্ট করে। শুধুমাত্র বাম দিক থেকে গণনা বিভক্ত করা হবে.

result = re.split('[a-z]+', s, 1)
print(result)
# ['111', '222bbb333']

পাইথনে রেগুলার এক্সপ্রেশন মেটাক্যারেক্টার, বিশেষ সিকোয়েন্স এবং সতর্কতা

Python 3 re মডিউলে ব্যবহার করা যেতে পারে এমন প্রধান রেগুলার এক্সপ্রেশন মেটা অক্ষর (বিশেষ অক্ষর) এবং বিশেষ ক্রমগুলি নিম্নরূপ

তাদের সব এই টেবিলে তালিকাভুক্ত করা হয় না. একটি সম্পূর্ণ তালিকার জন্য অফিসিয়াল ডকুমেন্টেশন দেখুন।

• re — Regular expression operations — Regular Expression Syntax — Python 3.10.0 Documentation

এছাড়াও মনে রাখবেন যে Python 2 এর কিছু অর্থ ভিন্ন।

• 7.2. re — Regular expression operations — Regular Expression Syntax — Python 2.7.18 Documentation

পতাকা স্থাপন

উপরের সারণীতে দেখানো হয়েছে, কিছু মেটা অক্ষর এবং বিশেষ ক্রম পতাকার উপর নির্ভর করে তাদের মোড পরিবর্তন করে।

এখানে শুধুমাত্র প্রধান পতাকাগুলো ঢাকা আছে। বাকি জন্য অফিসিয়াল ডকুমেন্টেশন দেখুন.

• re — Regular expression operations — Module Contents — Python 3.10.0 Documentation

ASCII অক্ষরের মধ্যে সীমাবদ্ধ: re.ASCII

\wএটি পাইথন 3 স্ট্রিং-এর জন্য ডিফল্টরূপে ডাবল-বাইট কাঞ্জি, আলফানিউমেরিক অক্ষর ইত্যাদির সাথেও মিলবে। এটি নিম্নলিখিতগুলির সমতুল্য নয় কারণ এটি একটি আদর্শ রেগুলার এক্সপ্রেশন নয়।[a-zA-Z0-9_]

m = re.match(r'\w+', '漢字ＡＢＣ１２３')
print(m)
# <re.Match object; span=(0, 11), match='漢字ＡＢＣ１２３'>

m = re.match('[a-zA-Z0-9_]+', '漢字ＡＢＣ１２３')
print(m)
# None

আপনি যদি প্রতিটি ফাংশনে আর্গুমেন্ট ফ্ল্যাগের জন্য re.ASCII নির্দিষ্ট করেন, বা রেগুলার এক্সপ্রেশন প্যাটার্ন স্ট্রিং এর শুরুতে নিম্নলিখিত ইনলাইন ফ্ল্যাগ যোগ করেন, তবে এটি শুধুমাত্র ASCII অক্ষরের সাথে মিলবে (এটি ডাবল-বাইট জাপানি, আলফানিউমেরিক অক্ষর ইত্যাদির সাথে মিলবে না .)
(?a)
এই ক্ষেত্রে, নিম্নলিখিত দুটি সমতুল্য।
\w#ERROR![a-zA-Z0-9_]

m = re.match(r'\w+', '漢字ＡＢＣ１２３', flags=re.ASCII)
print(m)
# None

m = re.match(r'(?a)\w+', '漢字ＡＢＣ１２３')
print(m)
# None

re.compile() দিয়ে কম্পাইল করার সময় একই প্রযোজ্য। আর্গুমেন্ট ফ্ল্যাগ বা ইনলাইন পতাকা ব্যবহার করুন।

p = re.compile(r'\w+', flags=re.ASCII)
print(p)
# re.compile('\\w+', re.ASCII)

print(p.match('漢字ＡＢＣ１２３'))
# None

p = re.compile(r'(?a)\w+')
print(p)
# re.compile('(?a)\\w+', re.ASCII)

print(p.match('漢字ＡＢＣ１２３'))
# None

ASCII সংক্ষিপ্ত ফর্ম re হিসাবে পাওয়া যায়. উ: আপনি যেকোনো একটি ব্যবহার করতে পারেন।

print(re.ASCII is re.A)
# True

\W, \W এর বিপরীত, এছাড়াও re.ASCII এবং ইনলাইন পতাকা দ্বারা প্রভাবিত হয়।

m = re.match(r'\W+', '漢字ＡＢＣ１２３')
print(m)
# None

m = re.match(r'\W+', '漢字ＡＢＣ１２３', flags=re.ASCII)
print(m)
# <re.Match object; span=(0, 11), match='漢字ＡＢＣ１２３'>

\w এর মতো, নিম্নলিখিত দুটি ডিফল্টরূপে একক-বাইট এবং ডাবল-বাইট অক্ষর উভয়ের সাথে মিলে যায়, তবে re.ASCII বা ইনলাইন ফ্ল্যাগ নির্দিষ্ট করা থাকলে তা একক-বাইট অক্ষরের মধ্যে সীমাবদ্ধ।

• সংখ্যাগুলো মিলিয়ে নিন\d
• একটি ফাঁকা স্থান মেলে\s
• অ-সংখ্যা মেলে\D
• যেকোন নন-স্পেস মেলে।\S

m = re.match(r'\d+', '123')
print(m)
# <re.Match object; span=(0, 3), match='123'>

m = re.match(r'\d+', '１２３')
print(m)
# <re.Match object; span=(0, 3), match='１２３'>

m = re.match(r'\d+', '123', flags=re.ASCII)
print(m)
# <re.Match object; span=(0, 3), match='123'>

m = re.match(r'\d+', '１２３', flags=re.ASCII)
print(m)
# None

m = re.match(r'\s+', '　')  # full-width space
print(m)
# <re.Match object; span=(0, 1), match='\u3000'>

m = re.match(r'\s+', '　', flags=re.ASCII)
print(m)
# None

কেস-সংবেদনশীল নয়:re.IGNORECASE

ডিফল্টরূপে, এটি কেস-সংবেদনশীল। উভয়ের সাথে মিল করার জন্য, আপনাকে প্যাটার্নে বড় হাতের এবং ছোট হাতের অক্ষর উভয়ই অন্তর্ভুক্ত করতে হবে।

re.IGNORECASEএটি নির্দিষ্ট করা থাকলে, এটি কেস-সংবেদনশীলভাবে মেলে। স্ট্যান্ডার্ড রেগুলার এক্সপ্রেশনে i পতাকার সমতুল্য।

m = re.match('[a-zA-Z]+', 'abcABC')
print(m)
# <re.Match object; span=(0, 6), match='abcABC'>

m = re.match('[a-z]+', 'abcABC', flags=re.IGNORECASE)
print(m)
# <re.Match object; span=(0, 6), match='abcABC'>

m = re.match('[A-Z]+', 'abcABC', flags=re.IGNORECASE)
print(m)
# <re.Match object; span=(0, 6), match='abcABC'>

আপনি এর চেয়ে কম বা সমান ব্যবহার করতে পারেন।

• ইনলাইন পতাকা(?i)
• সংক্ষেপণre.I

প্রতিটি লাইনের শুরু এবং শেষ মিল করুন:re.MULTILINE

^এই রেগুলার এক্সপ্রেশনের মেটা অক্ষরগুলি স্ট্রিংয়ের শুরুতে মেলে।

ডিফল্টরূপে, শুধুমাত্র পুরো স্ট্রিং এর শুরুর সাথে মিলে যায়, কিন্তু নিম্নলিখিতগুলি প্রতিটি লাইনের শুরুতেও মিলবে। স্ট্যান্ডার্ড রেগুলার এক্সপ্রেশনে m পতাকার সমতুল্য।
re.MULTILINE

s = '''aaa-xxx
bbb-yyy
ccc-zzz'''

print(s)
# aaa-xxx
# bbb-yyy
# ccc-zzz

result = re.findall('[a-z]+', s)
print(result)
# ['aaa', 'xxx', 'bbb', 'yyy', 'ccc', 'zzz']

result = re.findall('^[a-z]+', s)
print(result)
# ['aaa']

result = re.findall('^[a-z]+', s, flags=re.MULTILINE)
print(result)
# ['aaa', 'bbb', 'ccc']

$স্ট্রিংয়ের শেষের সাথে মেলে। ডিফল্টরূপে, সম্পূর্ণ স্ট্রিং এর শুধুমাত্র শেষ মেলে।
re.MULTILINEআপনি যদি এটি নির্দিষ্ট করেন তবে এটি প্রতিটি লাইনের শেষেও মিলবে।

result = re.findall('[a-z]+$', s)
print(result)
# ['zzz']

result = re.findall('[a-z]+$', s, flags=re.MULTILINE)
print(result)
# ['xxx', 'yyy', 'zzz']

আপনি এর চেয়ে কম বা সমান ব্যবহার করতে পারেন।

• ইনলাইন পতাকা(?m)
• সংক্ষেপণre.M

একাধিক পতাকা নির্দিষ্ট করুন

|আপনি যদি একই সময়ে একাধিক পতাকা সক্ষম করতে চান তবে এটি ব্যবহার করুন। ইনলাইন ফ্ল্যাগগুলির ক্ষেত্রে, প্রতিটি অক্ষর অবশ্যই নীচের মতো একটি অক্ষর দ্বারা অনুসরণ করা উচিত।
(?am)

s = '''aaa-xxx
漢漢漢-字字字
bbb-zzz'''

print(s)
# aaa-xxx
# 漢漢漢-字字字
# bbb-zzz

result = re.findall(r'^\w+', s, flags=re.M)
print(result)
# ['aaa', '漢漢漢', 'bbb']

result = re.findall(r'^\w+', s, flags=re.M | re.A)
print(result)
# ['aaa', 'bbb']

result = re.findall(r'(?am)^\w+', s)
print(result)
# ['aaa', 'bbb']

লোভী এবং অ-লোভী মেলে

এটি রেগুলার এক্সপ্রেশনের একটি সাধারণ সমস্যা, শুধুমাত্র পাইথনের সমস্যা নয়, তবে আমি এটি সম্পর্কে লিখব কারণ এটি আমাকে সমস্যায় ফেলতে পারে।

ডিফল্টরূপে, নিম্নলিখিতটি একটি লোভী ম্যাচ, যা সম্ভাব্য দীর্ঘতম স্ট্রিংয়ের সাথে মেলে।

• *
• +
• ?

s = 'aaa@xxx.com, bbb@yyy.com'

m = re.match(r'.+com', s)
print(m)
# <re.Match object; span=(0, 24), match='aaa@xxx.com, bbb@yyy.com'>

print(m.group())
# aaa@xxx.com, bbb@yyy.com

দ্য ? এর পরে এটি একটি অ-লোভী, ন্যূনতম ম্যাচ হবে, সংক্ষিপ্ততম সম্ভাব্য স্ট্রিংয়ের সাথে মেলে।

• *?
• +?
• ??

m = re.match(r'.+?com', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>

print(m.group())
# aaa@xxx.com

মনে রাখবেন যে ডিফল্ট লোভী ম্যাচ অপ্রত্যাশিত স্ট্রিংগুলির সাথে মেলে।