Python ပုံမှန်အသုံးအနှုန်း module re (match, search, sub, etc.) ကိုအသုံးပြုနည်း

Python တွင် ပုံမှန် expression processing လုပ်ဆောင်ရန်၊ standard library မှ re module ကို အသုံးပြုပါသည်။ ၎င်းသည် သင့်အား ပုံမှန်ဖော်ပြမှုပုံစံများကို အသုံးပြု၍ ကြိုးများကို ထုတ်ယူရန်၊ အစားထိုးရန်နှင့် ခွဲရန်ခွင့်ပြုသည်။

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

ဤအပိုင်းတွင်၊ ကျွန်ုပ်တို့သည် re module ၏လုပ်ဆောင်ချက်များနှင့် နည်းလမ်းများကို ဦးစွာရှင်းပြပါမည်။

• ပုံမှန်ဖော်ပြမှုပုံစံများကို ပြုစုခြင်း-compile()
• ကိုက်ညီသောအရာဝတ္ထု
• စာကြောင်း၏အစတွင် ကိုက်ညီမှုရှိမရှိ စစ်ဆေးပါ၊ ဖြည်ပါ-match()
• အစတွင် အကန့်အသတ်မရှိ ကိုက်ညီမှုရှိမရှိ စစ်ဆေးပါ-search()
• စာကြောင်းတစ်ခုလုံး ကိုက်ညီမှုရှိမရှိ စစ်ဆေးပါ-fullmatch()
• ကိုက်ညီသော အစိတ်အပိုင်းများစာရင်းကို ရယူပါ-findall()
• ထပ်တူကျသော အစိတ်အပိုင်းများအားလုံးကို ထပ်လောင်းအဖြစ် ရယူပါ-finditer()
• ကိုက်ညီသောအပိုင်းကို အစားထိုးပါ။sub()၊subn()
• ပုံမှန်အသုံးအနှုန်းပုံစံများဖြင့် ကြိုးများခွဲခြင်း-split()

၎င်းနောက်၊ ကျွန်ုပ်သည် re module တွင်သုံးနိုင်သော ပုံမှန်အသုံးအနှုန်းများ၏ အထူးအစီအစဥ်များနှင့် meta ဇာတ်ကောင်များ (အထူးအက္ခရာများ) ကို ရှင်းပြပါမည်။ အခြေခံအားဖြင့်၊ ၎င်းသည် စံပုံမှန်ဖော်ပြချက်အထားအသိုဖြစ်သော်လည်း၊ အလံများသတ်မှတ်ခြင်း (အထူးသဖြင့် re.ASCII) ကို သတိထားပါ။

• Python တွင် ပုံမှန်ဖော်ပြချက် metacharacters၊ အထူးအစီအစဉ်များနှင့် သတိပေးချက်များ
• အလံသတ်မှတ်ခြင်း။
  • ASCII စာလုံးများကို ကန့်သတ်ထားသည်-re.ASCII
  • စာလုံးအကြီး-အကဲဆတ်မဟုတ်-re.IGNORECASE
  • စာကြောင်းတစ်ခုစီ၏ အစနှင့်အဆုံးကို ယှဉ်ကြည့်ပါ-re.MULTILINE
  • အလံများစွာကို သတ်မှတ်ပါ။
• လောဘနှင့် လောဘမဟုတ်သော တိုက်ဆိုင်မှု

ပုံမှန်အသုံးအနှုန်းပုံစံကို စုစည်းပါ- compile()

re module တွင် ပုံမှန် expression processing လုပ်ဆောင်ရန် နည်းလမ်းနှစ်ခုရှိသည်။

လုပ်ဆောင်ချက်ဖြင့် လုပ်ဆောင်ပါ။

ပထမတစ်ခုကတော့ function တစ်ခုပါ။re.match()၊re.sub()ပုံမှန်ဖော်ပြမှုပုံစံများကို အသုံးပြု၍ ထုတ်ယူခြင်း၊ အစားထိုးခြင်းနှင့် အခြားလုပ်ငန်းစဉ်များကို လုပ်ဆောင်ရန် ဤကဲ့သို့သောလုပ်ဆောင်ချက်များကို ရရှိနိုင်ပါသည်။

လုပ်ဆောင်ချက်များ၏အသေးစိတ်အချက်အလက်များကို နောက်ပိုင်းတွင်ဖော်ပြပါမည်၊ သို့သော် ၎င်းတို့အားလုံးတွင်၊ ပထမအငြင်းအခုံမှာ ပုံမှန်ဖော်ပြမှုပုံစံ၏ string ဖြစ်ပြီး၊ ၎င်းနောက်တွင် လုပ်ဆောင်ရမည့် string စသည်တို့ဖြစ်သည်။ ဥပမာအားဖြင့်၊ အစားထိုးမှုကိုလုပ်ဆောင်သည့် 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]+ သည် စာလုံးသေးတစ်လုံး သို့မဟုတ် ထို့ထက်ပိုသော အက္ခရာစာလုံးများကို ပြန်ဆိုသည့် မည်သည့်စာကြောင်းနှင့်မဆို ကိုက်ညီပါသည်။

. meta စာလုံး (အထူးအဓိပ္ပါယ်ရှိသော စာလုံး) ဖြစ်ပြီး backslash ဖြင့် လွတ်ရပါမည်။

ပုံမှန်ဖော်ပြမှုပုံစံ strings များသည် backslashes အများအပြားကိုအသုံးပြုလေ့ရှိသောကြောင့်၊ ဥပမာတွင်ရှိသကဲ့သို့အကြမ်းကြိုးများကိုအသုံးပြုရန်အဆင်ပြေသည်။

ပုံမှန်ဖော်ပြမှုပုံစံ အရာဝတ္ထုတစ်ခု၏ နည်းလမ်းတစ်ခုတွင် လုပ်ဆောင်သည်။

re module တွင် ပုံမှန်ဖော်ပြချက်များကို လုပ်ဆောင်ရန် ဒုတိယနည်းလမ်းမှာ ပုံမှန် expression pattern object method ဖြစ်သည်။

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()ဥပမာအားဖြင့်၊ ပုံမှန် expression objects ၏ method match(),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() လုပ်ဆောင်ချက်များအားလုံးကို ပုံမှန် expression object ၏ နည်းလမ်းများအဖြစ်လည်း ပံ့ပိုးပေးထားပါသည်။

အကယ်၍ သင်သည် တူညီသောပုံစံကိုအသုံးပြုသည့် လုပ်ငန်းစဉ်ကို ထပ်ခါတလဲလဲလုပ်နေပါက၊ ၎င်းကို re.compile() ဖြင့် ပုံမှန်အသုံးအနှုန်းအရာဝတ္တုကို ထုတ်လုပ်ပြီး ၎င်းကို အနီးအနားတွင် အသုံးပြုရန် ပိုမိုထိရောက်သည်။

အောက်ပါနမူနာကုဒ်တွင်၊ လုပ်ဆောင်ချက်ကို အဆင်ပြေစေရန်အတွက် compiling မလုပ်ဘဲ အသုံးပြုသော်လည်း တူညီသောပုံစံကို ထပ်ခါထပ်ခါ အသုံးပြုလိုပါက၊ ၎င်းကို ကြိုတင် compile လုပ်ပြီး ပုံမှန် expression object ၏ method တစ်ခုအဖြစ် လုပ်ဆောင်ရန် အကြံပြုထားသည်။

ကိုက်ညီသောအရာဝတ္ထု

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

ကိုက်ညီသည့် string နှင့် position ကို match object ၏ အောက်ပါနည်းလမ်းများကို အသုံးပြု၍ ရယူသည်။

• ပွဲ၏တည်နေရာကိုရယူပါ-start()၊end()၊span()
• လိုက်ဖက်သောစာကြောင်းကို ရယူပါgroup()
• အဖွဲ့တစ်ခုစီအတွက် စာကြောင်းရယူပါ-groups()

print(m.start())
# 0

print(m.end())
# 11

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

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

အကယ်၍ သင်သည် ပုံမှန်ဖော်ပြမှုပုံစံတစ်ခု၏ အစိတ်အပိုင်းတစ်ခုကို ကွင်းအတွင်း() ပါသော စာကြောင်းတစ်ခုတွင် ထည့်သွင်းပါက အပိုင်းကို အုပ်စုတစ်ခုအဖြစ် လုပ်ဆောင်မည်ဖြစ်သည်။ ဤကိစ္စတွင်၊ အုပ်စုတစ်ခုစီတွင် အုပ်စု() နှင့် ကိုက်ညီသည့်အပိုင်း၏ string ကို tuple အဖြစ် ရယူနိုင်သည်။

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() စာကြောင်း၏အစသည် ပုံစံနှင့်ကိုက်ညီပါက ကိုက်ညီသည့်အရာတစ်ခုကို ပြန်ပေးသည်။

အထက်တွင်ဖော်ပြခဲ့သည့်အတိုင်း၊ ကိုက်ညီသည့်အရာဝတ္တုကို လိုက်ဖက်သောစာကြောင်းခွဲကို ထုတ်ယူရန် သို့မဟုတ် ကိုက်ညီမှုရှိမရှိ စစ်ဆေးရန် ရိုးရိုးရှင်းရှင်း အသုံးပြုနိုင်သည်။

match() သည် အစကိုသာ စစ်ဆေးပါမည်။ အစတွင် တူညီသောစာကြောင်းမရှိပါက၊ ၎င်းသည် None ကိုပြန်ပေးသည်။

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

အစတွင် အကန့်အသတ်မရှိ ကိုက်ညီမှုများကို စစ်ဆေးပါ၊ ဖြည်ပါ- search()

match() ကဲ့သို့ပင် ၎င်းသည် တိုက်ဆိုင်ပါက အရာဝတ္ထုတစ်ခုကို ပြန်ပေးသည်။

လိုက်ဖက်ညီသော အပိုင်းများစွာရှိပါက၊ ပထမကိုက်ညီသောအပိုင်းကိုသာ ပြန်ပေးပါမည်။

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

fullmatch() ကို Python 3.4 တွင် ထည့်သွင်းထားသည်။ အစောပိုင်းဗားရှင်းများတွင် အလားတူလုပ်ဆောင်လိုပါက၊ အဆုံးတွင် match() နှင့် ကိုက်ညီသော meta character $ ကိုသုံးပါ။ အစမှအဆုံး စာကြောင်းတစ်ခုလုံး မကိုက်ညီပါက၊ ၎င်းသည် None ကို ပြန်ပေးသည်။

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

စာရင်းထဲရှိ အစိတ်အပိုင်းအရေအတွက်ကို ပြန်ပေးသည့် built-in function len() ကို အသုံးပြု၍ လိုက်ဖက်သော အစိတ်အပိုင်းအရေအတွက်ကို စစ်ဆေးနိုင်သည်။

print(len(result))
# 3

ကွင်းစဥ်() ဖြင့် အုပ်စုဖွဲ့ခြင်းသည် ပုံမှန်ဖော်ပြချက်ပုံစံတွင် အုပ်စုတစ်ခုစီ၏ ကြိုးများဖြစ်သည့် tuples စာရင်းကို ပြန်ပေးသည်။ ၎င်းသည် match object ရှိ group() နှင့် ညီမျှသည်။

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

အုပ်စုကွင်း () ကို nested ထားနိုင်သည်၊ ထို့ကြောင့် တစ်ပွဲလုံးကို ရယူလိုပါက၊ ကွင်းတစ်ခုလုံး () တွင် ပွဲစဉ်တစ်ခုလုံးကို ပေါင်းထည့်လိုက်ပါ။

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

ကိုက်ညီမှုမတွေ့ပါက ဗလာ tuple ကို ပြန်ပေးသည်။

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

iterator အဖြစ် လိုက်ဖက်သော အစိတ်အပိုင်းအားလုံးကို ရယူပါ- finditer()

finditer() သည် ထပ်တူကျသော အစိတ်အပိုင်းအားလုံးကို တိုင်တာတစ်ခုအဖြစ် ပြန်ပေးသည်။ ဒြပ်စင်များသည် findall() ကဲ့သို့ စာကြောင်းများမဟုတ်သော်လည်း အရာဝတ္တုများနှင့် ကိုက်ညီသောကြောင့် လိုက်ဖက်သောအစိတ်အပိုင်းများ၏ အနေအထား (အညွှန်း) ကို သင်ရနိုင်သည်။

Iterator ကိုယ်တိုင်က ၎င်း၏အကြောင်းအရာများကို ရယူရန်အတွက် print() ဖြင့် ရိုက်နှိပ်၍မရပါ။ သင် built-in function 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 comprehension notation သည် list() ထက် ပိုအဆင်ပြေပါသည်။

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

iterator သည် ဒြပ်စင်များကို စနစ်တကျ ထုတ်ယူသည်။ အဆုံးသို့ရောက်ပြီးနောက် နောက်ထပ်ဒြပ်စင်များကို ထုတ်ယူရန်ကြိုးစားပါက၊ သင်သည် ဘာမှမကျန်တော့ကြောင်း သတိပြုပါ။

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

ကွင်းစဥ်() ဖြင့် အုပ်စုဖွဲ့သည့်အခါ လိုက်ဖက်သောစာကြောင်းကို အစားထိုးထားသော စာကြောင်းတွင် အသုံးပြုနိုင်သည်။

ပုံမှန်အားဖြင့်၊ အောက်ပါတို့ကို ပံ့ပိုးပေးသည်- အကြမ်းလိုင်းများမဟုတ်သော ပုံမှန်စာကြောင်းများအတွက်၊ backslash မှလွတ်မြောက်ရန် backslash မတိုင်မီ စာရင်းသွင်းရပါမည်။

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() သည် အစားထိုးထားသော string ၏ tuple (sub() ၏ return value ကဲ့သို့) နှင့် အစားထိုးထားသော အစိတ်အပိုင်းများ အရေအတွက် (pattern နှင့် ကိုက်ညီသော နံပါတ်) ကို ပြန်ပေးသည်။

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

arguments သတ်မှတ်ခြင်းနည်းလမ်းသည် 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 တွင် ပုံမှန်ဖော်ပြချက် metacharacters၊ အထူးအစီအစဉ်များနှင့် သတိပေးချက်များ

Python 3 re module တွင် အသုံးပြုနိုင်သည့် အဓိက ပုံမှန် ပုံမှန်ဖော်ပြချက် meta ဇာတ်ကောင်များ (အထူးအက္ခရာများ) နှင့် အထူး sequence များသည် အောက်ပါအတိုင်းဖြစ်သည် ။

၎င်းတို့အားလုံးကို ဤဇယားတွင် မဖော်ပြထားပါ။ စာရင်းအပြည့်အစုံအတွက် တရားဝင်စာရွက်စာတမ်းကို ကြည့်ပါ။

• 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 strings များအတွက် မူရင်းအတိုင်း double-byte kanji၊ အက္ခရာဂဏန်း ဂဏန်းအက္ခရာများ စသည်တို့နှင့်လည်း ကိုက်ညီမည်ဖြစ်ပါသည်။ ၎င်းသည် စံပုံမှန်အသုံးအနှုန်းတစ်ခုမဟုတ်သောကြောင့် ၎င်းသည် အောက်ပါတို့နှင့် ညီမျှသည်။[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 ကို သတ်မှတ်ပါ သို့မဟုတ် ပုံမှန်ဖော်ပြမှုပုံစံစာကြောင်း၏အစတွင် အောက်ပါ inline အလံကို ထည့်ပါက၊ ၎င်းသည် 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 ကို short form re အဖြစ်လည်း ရရှိနိုင်ပါသည်။ A. ဖြစ်ဖြစ် သုံးလို့ရတယ်။

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

\W၊ \W ၏ဆန့်ကျင်ဘက်ဖြစ်သော၊ သည် re.ASCII နှင့် inline အလံများကြောင့်လည်း သက်ရောက်မှုရှိသည်။

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 ကဲ့သို့ပင်၊ အောက်ဖော်ပြပါ နှစ်ခုသည် ပုံသေအားဖြင့် single-byte နှင့် double-byte ဇာတ်ကောင်များနှင့် ကိုက်ညီသော်လည်း re.ASCII သို့မဟုတ် inline အလံများကို သတ်မှတ်ထားပါက single-byte စာလုံးများကို ကန့်သတ်ထားသည်။

• နံပါတ်များကို ယှဉ်ပါ။\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 flag နှင့် ညီမျှသည်။

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

ထက်နည်းသော သို့မဟုတ် ညီမျှစွာ သုံးနိုင်သည်။

• inline အလံ(?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']

ထက်နည်းသော သို့မဟုတ် ညီမျှစွာ သုံးနိုင်သည်။

• inline အလံ(?m)
• အတိုကောက်re.M

အလံများစွာကို သတ်မှတ်ပါ။

|အလံများစွာကို တစ်ပြိုင်နက်တည်း ဖွင့်လိုပါက ဤအရာကို အသုံးပြုပါ။ inline အလံများကိစ္စတွင်၊ စာလုံးတစ်လုံးစီသည် အောက်တွင်ပြထားသည့်အတိုင်း အက္ခရာတစ်ခုစီဖြင့် လိုက်ရပါမည်။
(?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

မူရင်း လောဘကြီးသော ပွဲစဉ်သည် မျှော်လင့်မထားသော စာကြောင်းများနှင့် ကိုက်ညီနိုင်သည်ကို သတိပြုပါ။