ازگر کے ریگولر ایکسپریشن ماڈیول کا استعمال کیسے کریں (میچ، سرچ، سب، وغیرہ)

Python میں ریگولر ایکسپریشن پروسیسنگ کرنے کے لیے، ہم معیاری لائبریری سے ری ماڈیول استعمال کرتے ہیں۔ یہ آپ کو ریگولر ایکسپریشن پیٹرن کا استعمال کرتے ہوئے تاروں کو نکالنے، تبدیل کرنے اور تقسیم کرنے کی اجازت دیتا ہے۔

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

اس حصے میں، ہم پہلے ری ماڈیول کے افعال اور طریقوں کی وضاحت کریں گے۔

• باقاعدہ اظہار کے نمونوں کو مرتب کرنا: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.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()مثال کے طور پر، ان فنکشنز جیسا ہی عمل ریگولر ایکسپریشن آبجیکٹ کے میچ()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

اگر آپ ریگولر ایکسپریشن پیٹرن کے کسی حصے کو قوسین () کے ساتھ سٹرنگ میں بند کرتے ہیں تو اس حصے پر ایک گروپ کے طور پر کارروائی کی جائے گی۔ اس صورت میں، اس حصے کی سٹرنگ جو گروپس() میں ہر گروپ سے میل کھاتی ہے اسے ٹپل کے طور پر حاصل کیا جا سکتا ہے۔

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')

چیک کریں کہ آیا سٹرنگ کا آغاز میل کھاتا ہے، نکالیں: میچ()

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 میں شامل کیا گیا تھا۔ اگر آپ پہلے والے ورژن میں بھی ایسا کرنا چاہتے ہیں تو آخر میں میچ() اور مماثل میٹا کریکٹر $ استعمال کریں۔ اگر شروع سے آخر تک پوری تار مماثل نہیں ہے، تو یہ کوئی نہیں لوٹاتا ہے۔

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()

finditer() تمام مماثل حصوں کو ایک تکرار کرنے والے کے طور پر واپس کرتا ہے۔ عناصر findall() کی طرح تار نہیں ہیں، بلکہ اشیاء سے ملتے ہیں، لہذا آپ مماثل حصوں کی پوزیشن (انڈیکس) حاصل کر سکتے ہیں۔

اس کے مشمولات حاصل کرنے کے لیے خود تکرار کرنے والے کو print() کے ساتھ پرنٹ نہیں کیا جا سکتا۔ اگر آپ بلٹ ان فنکشن next() یا for statement استعمال کرتے ہیں، تو آپ ایک ایک کرکے مواد حاصل کرسکتے ہیں۔

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'>

اسے list() والی فہرست میں بھی تبدیل کیا جا سکتا ہے۔

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() متبادل سٹرنگ کا ایک ٹپل (سب() کی واپسی کی قدر کے برابر) اور متبادل حصوں کی تعداد (وہ نمبر جو پیٹرن سے مماثل ہے) واپس کرتا ہے۔

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

آرگیومینٹس کی وضاحت کرنے کا طریقہ وہی ہے جو sub() ہے۔ آپ قوسین کے ذریعہ گروپ کردہ حصہ استعمال کرسکتے ہیں، یا دلیل کی گنتی کی وضاحت کرسکتے ہیں۔

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یہ Python 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 کے طور پر بھی دستیاب ہے۔ A. آپ یا تو استعمال کر سکتے ہیں۔

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']

لالچی اور غیر لالچی میچ

یہ ریگولر ایکسپریشنز کا ایک عام مسئلہ ہے، نہ صرف Python کا مسئلہ، لیکن میں اس کے بارے میں لکھوں گا کیونکہ یہ مجھے پریشانی میں ڈال دیتا ہے۔

پہلے سے طے شدہ طور پر، مندرجہ ذیل ایک لالچی میچ ہے، جو ممکنہ طویل ترین سٹرنگ سے میل کھاتا ہے۔

• *
• +
• ?

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

نوٹ کریں کہ ڈیفالٹ لالچی میچ غیر متوقع تاروں سے مماثل ہو سکتا ہے۔