पाइथन रेगुलर एक्सप्रेशन मोड्युल पुन (मिल्ने, खोज, उप, आदि) कसरी प्रयोग गर्ने

व्यापार

पाइथनमा नियमित अभिव्यक्ति प्रशोधन गर्न, हामी मानक पुस्तकालयबाट पुन मोड्युल प्रयोग गर्छौं। यसले तपाईंलाई नियमित अभिव्यक्ति ढाँचाहरू प्रयोग गरेर स्ट्रिङहरू निकाल्न, प्रतिस्थापन गर्न र विभाजन गर्न अनुमति दिन्छ।

यस खण्डमा, हामी पहिले पुन मोड्युलको कार्य र विधिहरू व्याख्या गर्नेछौं।

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

त्यस पछि, म मेटा क्यारेक्टरहरू (विशेष क्यारेक्टरहरू) र रे मोड्युलमा प्रयोग गर्न सकिने रेगुलर एक्सप्रेशनहरूको विशेष अनुक्रमहरू व्याख्या गर्नेछु। सामान्यतया, यो मानक नियमित अभिव्यक्ति वाक्य रचना हो, तर झण्डाहरू (विशेष गरी re.ASCII) सेट गर्ने ’bout सावधान रहनुहोस्।

  • पाइथनमा नियमित अभिव्यक्ति मेटाक्यारेक्टरहरू, विशेष अनुक्रमहरू, र चेतावनीहरू
  • झण्डा सेट गर्दै
    • 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

fullmatch() पाइथन 3.4 मा थपिएको थियो। यदि तपाइँ अघिल्लो संस्करणहरूमा पनि त्यस्तै गर्न चाहनुहुन्छ भने, अन्त्यमा 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

नियमित अभिव्यक्ति ढाँचामा कोष्ठक () को साथ समूहीकरणले टुपलहरूको सूची फर्काउँछ जसका तत्वहरू प्रत्येक समूहका स्ट्रिङहरू हुन्। यो मिल्दो वस्तुमा group() को बराबर छ।

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() जस्ता स्ट्रिङहरू होइनन्, तर वस्तुहरूसँग मेल खान्छ, त्यसैले तपाईंले मिल्दो भागहरूको स्थिति (सूचकाङ्क) प्राप्त गर्न सक्नुहुन्छ।

पुनरावृत्ति आफैं प्रिन्ट () सँग यसको सामग्रीहरू प्राप्त गर्न प्रिन्ट गर्न सकिँदैन। यदि तपाइँ बिल्ट-इन प्रकार्य next() वा कथनको लागि प्रयोग गर्नुहुन्छ भने, तपाइँ सामग्रीहरू एक एक गरेर प्राप्त गर्न सक्नुहुन्छ।

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

कोष्ठक () संग समूहबद्ध गर्दा, मिलाइएको स्ट्रिङ प्रतिस्थापित स्ट्रिङमा प्रयोग गर्न सकिन्छ।

पूर्वनिर्धारित रूपमा, निम्न समर्थित छ: ध्यान दिनुहोस् कि कच्चा स्ट्रिङहरू नभएका सामान्य स्ट्रिङहरूका लागि, ब्याकस्ल्याशबाट बच्नको लागि ब्याकस्ल्याश अघि सूचीबद्ध हुनुपर्छ।

\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() ले प्रतिस्थापित स्ट्रिङको टुपल फर्काउँछ (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', '']

अधिकतम स्प्लिट तर्कले विभाजनको अधिकतम संख्या (टुक्राहरू) निर्दिष्ट गर्दछ। बायाँ तर्फबाट मात्र गणना विभाजित हुनेछ।

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

पाइथनमा नियमित अभिव्यक्ति मेटाक्यारेक्टरहरू, विशेष अनुक्रमहरू, र चेतावनीहरू

Python 3 re मोड्युलमा प्रयोग गर्न सकिने मुख्य नियमित अभिव्यक्ति मेटा क्यारेक्टरहरू (विशेष क्यारेक्टरहरू) र विशेष अनुक्रमहरू निम्नानुसार छन्।

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

तिनीहरू सबै यस तालिकामा सूचीबद्ध छैनन्। पूर्ण सूचीको लागि आधिकारिक कागजात हेर्नुहोस्।

यो पनि ध्यान दिनुहोस् कि पाइथन 2 मा केहि अर्थहरू फरक छन्।

झण्डा सेट गर्दै

माथिको तालिकामा देखाइए अनुसार, केही मेटा क्यारेक्टरहरू र विशेष अनुक्रमहरूले झण्डाको आधारमा तिनीहरूको मोड परिवर्तन गर्दछ।

यहाँ मुख्य झण्डाहरू मात्र ढाकेका छन्। बाँकीको लागि आधिकारिक कागजात हेर्नुहोस्।

ASCII वर्णहरूमा सीमित: re.ASCII

\wयसले Python 3 स्ट्रिङका लागि पूर्वनिर्धारित रूपमा डबल-बाइट कान्जी, अल्फान्यूमेरिक क्यारेक्टरहरू, आदिसँग पनि मेल खान्छ। यो निम्नसँग बराबर छैन ’cause यो मानक नियमित अभिव्यक्ति होइन।[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 छोटो फारम पुनको रूपमा पनि उपलब्ध छ। 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']

लोभी र गैर-लोभी मिलान

यो नियमित अभिव्यक्तिको सामान्य समस्या हो, पाइथनको समस्या मात्र होइन, तर म यसको ’boutमा लेख्नेछु ’cause यसले मलाई समस्यामा पार्ने गर्छ।

पूर्वनिर्धारित रूपमा, निम्न लोभी मिलान हो, जुन सबैभन्दा लामो सम्भव स्ट्रिङसँग मेल खान्छ।

  • *
  • +
  • ?
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

नोट गर्नुहोस् कि पूर्वनिर्धारित लोभी मिलानले अप्रत्याशित स्ट्रिङहरूसँग मेल खान सक्छ।

Copied title and URL