पायथन रेगुलर एक्सप्रेशन मॉड्यूल का उपयोग कैसे करें पुनः (मिलान, खोज, उप, आदि)

व्यापार

पायथन में नियमित अभिव्यक्ति प्रसंस्करण करने के लिए, हम मानक पुस्तकालय से पुनः मॉड्यूल का उपयोग करते हैं। यह आपको रेगुलर एक्सप्रेशन पैटर्न का उपयोग करके स्ट्रिंग्स को निकालने, बदलने और विभाजित करने की अनुमति देता है।

इस खंड में, हम सबसे पहले री मॉड्यूल के कार्यों और विधियों की व्याख्या करेंगे।

  • नियमित अभिव्यक्ति पैटर्न संकलित करना:compile()
  • वस्तु का मिलान करें
  • जांचें कि क्या स्ट्रिंग की शुरुआत मेल खाती है, निकालें:match()
  • शुरुआत तक सीमित न होने वाले मैचों की जाँच करें:search()
  • जांचें कि क्या पूरी स्ट्रिंग मेल खाती है:fullmatch()
  • सभी मिलान भागों की सूची प्राप्त करें:findall()
  • सभी मिलान भागों को एक पुनरावर्तक के रूप में प्राप्त करें:finditer()
  • मिलान वाले हिस्से को बदलें:sub(),subn()
  • रेगुलर एक्सप्रेशन पैटर्न के साथ बंटवारे के तार:split()

उसके बाद, मैं मेटा कैरेक्टर (स्पेशल कैरेक्टर) और रेगुलर एक्सप्रेशन के स्पेशल सीक्वेंस के बारे में बताऊंगा जिनका उपयोग री मॉड्यूल में किया जा सकता है। मूल रूप से, यह मानक रेगुलर एक्सप्रेशन सिंटैक्स है, लेकिन फ़्लैग सेट करने के बारे में सावधान रहें (विशेषकर re.ASCII)।

  • पायथन में नियमित अभिव्यक्ति मेटाएक्टैक्टर, विशेष अनुक्रम और चेतावनी
  • झंडा लगाना
    • ASCII वर्णों तक सीमित:re.ASCII
    • केस – संवे्दनशील नहीं:re.IGNORECASE
    • प्रत्येक पंक्ति की शुरुआत और अंत का मिलान करें:re.MULTILINE
    • एकाधिक झंडे निर्दिष्ट करें
  • लालची और गैर लालची मैच

नियमित अभिव्यक्ति पैटर्न संकलित करें: संकलित करें ()

रे मॉड्यूल में रेगुलर एक्सप्रेशन प्रोसेसिंग करने के दो तरीके हैं।

समारोह के साथ चलाएँ

पहला एक समारोह है।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() के साथ उत्पन्न करने और इसे चारों ओर उपयोग करने के लिए अधिक कुशल है।

निम्नलिखित नमूना कोड में, सुविधा के लिए संकलन किए बिना फ़ंक्शन का उपयोग किया जाता है, लेकिन यदि आप एक ही पैटर्न का बार-बार उपयोग करना चाहते हैं, तो इसे पहले से संकलित करने और इसे नियमित अभिव्यक्ति ऑब्जेक्ट की विधि के रूप में निष्पादित करने की अनुशंसा की जाती है।

वस्तु का मिलान करें

मैच (), खोज (), आदि एक मैच ऑब्जेक्ट लौटाएं।

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

जांचें कि क्या स्ट्रिंग की शुरुआत मेल खाती है, निकालें: मैच ()

मैच () एक मैच ऑब्जेक्ट देता है यदि स्ट्रिंग की शुरुआत पैटर्न से मेल खाती है।

जैसा कि ऊपर उल्लेख किया गया है, मैच ऑब्जेक्ट का उपयोग मिलान किए गए सबस्ट्रिंग को निकालने के लिए किया जा सकता है, या बस यह जांचने के लिए कि क्या मैच बनाया गया था।

मैच() केवल शुरुआत की जांच करेगा। यदि शुरुआत में कोई मिलान स्ट्रिंग नहीं है, तो यह कोई नहीं लौटाता है।

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() का उपयोग करें।

जांचें कि क्या पूरी स्ट्रिंग मेल खाती है: फुलमैच ()

यह जांचने के लिए कि क्या पूरी स्ट्रिंग नियमित अभिव्यक्ति पैटर्न से मेल खाती है, फुलमैच () का उपयोग करें। यह उपयोगी है, उदाहरण के लिए, यह जांचने के लिए कि कोई स्ट्रिंग ईमेल पते के रूप में मान्य है या नहीं।

यदि पूरी स्ट्रिंग मेल खाती है, तो एक मैच ऑब्जेक्ट वापस कर दिया जाता है।

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

फुलमैच () को पायथन 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']

मिलान किए गए भागों की संख्या को अंतर्निहित फ़ंक्शन लेन () का उपयोग करके जांचा जा सकता है, जो सूची में तत्वों की संख्या देता है।

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)
# []

सभी मिलान भागों को एक पुनरावर्तक के रूप में प्राप्त करें: खोजक ()

खोजक () सभी मिलान भागों को पुनरावृत्त के रूप में लौटाता है। तत्व फाइंडॉल () जैसे तार नहीं हैं, लेकिन वस्तुओं से मेल खाते हैं, इसलिए आप मिलान किए गए भागों की स्थिति (सूचकांक) प्राप्त कर सकते हैं।

इसकी सामग्री प्राप्त करने के लिए इटरेटर को प्रिंट() के साथ मुद्रित नहीं किया जा सकता है। यदि आप बिल्ट-इन फ़ंक्शन अगला () या कथन के लिए उपयोग करते हैं, तो आप सामग्री को एक-एक करके प्राप्त कर सकते हैं।

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))
# []

मिलान करने वाले भागों को बदलें: उप (), सबन ()

उप () का उपयोग करके, आप मिलान किए गए भाग को दूसरी स्ट्रिंग से बदल सकते हैं। प्रतिस्थापित स्ट्रिंग वापस कर दी जाएगी।

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

कोष्ठक () के साथ समूहीकृत करते समय, मिलान की गई स्ट्रिंग को प्रतिस्थापित स्ट्रिंग में उपयोग किया जा सकता है।

डिफ़ॉल्ट रूप से, निम्नलिखित समर्थित है: ध्यान दें कि सामान्य स्ट्रिंग्स के लिए जो कच्ची स्ट्रिंग्स नहीं हैं, बैकस्लैश से बचने के लिए बैकस्लैश को बैकस्लैश से पहले सूचीबद्ध किया जाना चाहिए।

\1पहला कोष्ठक
\2दूसरा कोष्ठक
\3तीसरा कोष्ठक
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)

तर्कों को निर्दिष्ट करने की विधि उप () के समान है। आप कोष्ठक द्वारा समूहीकृत भाग का उपयोग कर सकते हैं, या तर्क गणना निर्दिष्ट कर सकते हैं।

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)

रेगुलर एक्सप्रेशन पैटर्न के साथ बंटवारे तार: विभाजन ()

स्प्लिट () स्ट्रिंग को उस हिस्से में विभाजित करता है जो पैटर्न से मेल खाता है, और इसे एक सूची के रूप में लौटाता है।

ध्यान दें कि पहले और आखिरी मैचों में परिणामी सूची की शुरुआत और अंत में खाली तार होंगे।

s = '111aaa222bbb333'

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

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

अधिकतम विभाजन तर्क विभाजन (टुकड़ों) की अधिकतम संख्या निर्दिष्ट करता है। केवल बाईं ओर से गिनती विभाजित की जाएगी।

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

पायथन में नियमित अभिव्यक्ति मेटाएक्टैक्टर, विशेष अनुक्रम और चेतावनी

मुख्य नियमित अभिव्यक्ति मेटा वर्ण (विशेष वर्ण) और विशेष अनुक्रम जिनका उपयोग पायथन 3 री मॉड्यूल में किया जा सकता है, वे इस प्रकार हैं

रूपकअंतर्वस्तु
.नई पंक्ति के अलावा कोई एकल वर्ण (DOTALL ध्वज के साथ एक नई पंक्ति सहित)
^स्ट्रिंग की शुरुआत (मल्टीलाइन ध्वज के साथ प्रत्येक पंक्ति की शुरुआत से भी मेल खाती है)
$स्ट्रिंग का अंत (मल्टीलाइन ध्वज के साथ प्रत्येक पंक्ति के अंत से भी मेल खाता है)
*पिछले पैटर्न को 0 से अधिक बार दोहराएं
+पिछले पैटर्न को कम से कम एक बार दोहराएं।
?पिछले पैटर्न को 0 या 1 बार दोहराएं
{m}पिछले पैटर्न को m बार दोहराएं
{m, n}अंतिम पैटर्न।m~nदोहराना
[]पात्रों का एक सेट[]इनमें से किसी एक वर्ण से मेल खाता है
|याA|Bया तो ए या बी पैटर्न से मेल खाता है
विशेष क्रमअंतर्वस्तु
\dयूनिकोड दशमलव संख्या (ASCII ध्वज द्वारा ASCII संख्या तक सीमित)
\D\dमतलब इसके विपरीत।
\sयूनिकोड व्हाइटस्पेस वर्ण (ASCII ध्वज द्वारा ASCII व्हाइटस्पेस वर्णों तक सीमित)
\S\sमतलब इसके विपरीत।
\wयूनिकोड शब्द वर्ण और अंडरस्कोर (ASCII अल्फ़ान्यूमेरिक वर्णों तक सीमित और ASCII ध्वज द्वारा अंडरस्कोर)
\W\wमतलब इसके विपरीत।

वे सभी इस तालिका में सूचीबद्ध नहीं हैं। पूरी सूची के लिए आधिकारिक दस्तावेज देखें।

यह भी ध्यान दें कि पायथन 2 में कुछ अर्थ भिन्न हैं।

झंडा लगाना

जैसा कि ऊपर की तालिका में दिखाया गया है, कुछ मेटा वर्ण और विशेष अनुक्रम ध्वज के आधार पर अपना मोड बदलते हैं।

यहां केवल मुख्य झंडे ढके हुए हैं। बाकी के लिए आधिकारिक दस्तावेज देखें।

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

^इस रेगुलर एक्सप्रेशन में मेटा वर्ण स्ट्रिंग की शुरुआत से मेल खाते हैं।

डिफ़ॉल्ट रूप से, केवल पूरी स्ट्रिंग की शुरुआत का मिलान किया जाता है, लेकिन निम्नलिखित प्रत्येक पंक्ति की शुरुआत से भी मेल खाएगा। मानक नियमित अभिव्यक्तियों में एम ध्वज के बराबर।
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

NS ? इसके बाद कम से कम संभव स्ट्रिंग से मेल खाते हुए एक गैर-लालची, न्यूनतम मिलान होगा।

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

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

ध्यान दें कि डिफ़ॉल्ट लालची मैच अप्रत्याशित स्ट्रिंग से मेल खा सकता है।