पायथन रेग्युलर एक्सप्रेशन मॉड्यूल re (जुळणे, शोध, उप, इ.) कसे वापरावे

पायथनमध्ये रेग्युलर एक्सप्रेशन प्रोसेसिंग करण्यासाठी, आम्ही स्टँडर्ड लायब्ररीमधील 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.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

जर तुम्ही रेग्युलर एक्सप्रेशन पॅटर्नचा एक भाग कंस () सह स्ट्रिंगमध्ये जोडला असेल, तर त्या भागावर गट म्हणून प्रक्रिया केली जाईल. या प्रकरणात, प्रत्येक गटाशी जुळणार्‍या भागाची स्ट्रिंग ग्रुप() मध्ये टपल म्हणून मिळवता येते.

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() फक्त सुरुवात तपासेल. जर सुरुवातीला जुळणारी स्ट्रिंग नसेल, तर ती काहीही मिळवते.

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

सुरुवातीस मर्यादित नसलेल्या जुळण्या तपासा, अर्क करा: शोध()

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

फुलमॅच() पायथन ३.४ मध्ये जोडले गेले. तुम्हाला पूर्वीच्या आवृत्त्यांमध्ये असेच करायचे असल्यास, शेवटी match() आणि जुळणारे मेटा वर्ण $ वापरा. जर सुरुवातीपासून शेवटपर्यंत संपूर्ण स्ट्रिंग जुळत नसेल, तर ते काहीही मिळवत नाही.

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() सारख्या स्ट्रिंग नसतात, परंतु ऑब्जेक्ट्सशी जुळतात, त्यामुळे तुम्ही जुळलेल्या भागांची स्थिती (इंडेक्स) मिळवू शकता.

इटरेटर स्वतः प्रिंट () सह मुद्रित केले जाऊ शकत नाही आणि त्यातील सामग्री मिळवू शकत नाही. तुम्ही बिल्ट-इन फंक्शन नेक्स्ट() किंवा फॉर स्टेटमेंट वापरल्यास, तुम्ही एक एक करून कंटेंट मिळवू शकता.

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)

जर तुम्हाला सर्व जुळणार्‍या भागांची स्थिती मिळवायची असेल, तर सूची () पेक्षा सूची आकलन नोटेशन अधिक सोयीस्कर आहे.

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)

आर्ग्युमेंट्स निर्दिष्ट करण्याची पद्धत 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() पॅटर्नशी जुळणार्‍या भागावर स्ट्रिंग विभाजित करते आणि सूची म्हणून परत करते.

लक्षात घ्या की पहिल्या आणि शेवटच्या सामन्यांमध्ये परिणामी सूचीच्या सुरूवातीस आणि शेवटी रिक्त स्ट्रिंग असतील.

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 module मध्ये वापरता येणारे मुख्य रेग्युलर एक्स्प्रेशन मेटा कॅरेक्टर (विशेष वर्ण) आणि विशेष क्रम खालीलप्रमाणे आहेत

ते सर्व या टेबलमध्ये सूचीबद्ध नाहीत. संपूर्ण यादीसाठी अधिकृत दस्तऐवज पहा.

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

हे देखील लक्षात घ्या की पायथन 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']

लोभी आणि लोभी नसलेले जुळते

ही रेग्युलर एक्स्प्रेशन्सची एक सामान्य समस्या आहे, केवळ पायथनची समस्या नाही, परंतु मी त्याबद्दल लिहीन कारण ते मला अडचणीत आणते.

डीफॉल्टनुसार, खालील एक लोभी जुळणी आहे, जी सर्वात लांब संभाव्य स्ट्रिंगशी जुळते.

• *
• +
• ?

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

लक्षात ठेवा की डीफॉल्ट लोभी जुळणी अनपेक्षित स्ट्रिंगशी जुळू शकते.