పైథాన్ రెగ్యులర్ ఎక్స్‌ప్రెషన్ మాడ్యూల్ రీ (మ్యాచ్, సెర్చ్, సబ్, మొదలైనవి) ఎలా ఉపయోగించాలి.

పైథాన్‌లో రెగ్యులర్ ఎక్స్‌ప్రెషన్ ప్రాసెసింగ్ చేయడానికి, మేము ప్రామాణిక లైబ్రరీ నుండి రీ మాడ్యూల్‌ని ఉపయోగిస్తాము. ఇది సాధారణ వ్యక్తీకరణ నమూనాలను ఉపయోగించి స్ట్రింగ్‌లను సంగ్రహించడానికి, భర్తీ చేయడానికి మరియు విభజించడానికి మిమ్మల్ని అనుమతిస్తుంది.

• 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
  • బహుళ జెండాలను పేర్కొనండి
• అత్యాశ మరియు అత్యాశ లేని మ్యాచ్‌లు

సాధారణ వ్యక్తీకరణ నమూనాను కంపైల్ చేయండి: కంపైల్()

రీ మాడ్యూల్‌లో రెగ్యులర్ ఎక్స్‌ప్రెషన్ ప్రాసెసింగ్ చేయడానికి రెండు మార్గాలు ఉన్నాయి.

ఫంక్షన్‌తో అమలు చేయండి

మొదటిది ఒక ఫంక్షన్.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()ని ఉపయోగించండి.

మొత్తం స్ట్రింగ్ సరిపోలుతుందో లేదో తనిఖీ చేయండి: 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

ఫుల్‌మ్యాచ్() పైథాన్ 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() వంటి స్ట్రింగ్‌లు కావు, కానీ సరిపోలిన వస్తువులు, కాబట్టి మీరు సరిపోలిన భాగాల స్థానాన్ని (సూచిక) పొందవచ్చు.

ఇటరేటర్ దాని కంటెంట్‌లను పొందడానికి ప్రింట్()తో ముద్రించబడదు. మీరు అంతర్నిర్మిత ఫంక్షన్ తదుపరి() లేదా స్టేట్‌మెంట్ కోసం ఉపయోగిస్తే, మీరు కంటెంట్‌లను ఒక్కొక్కటిగా పొందవచ్చు.

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

సబ్()ని ఉపయోగించి, మీరు సరిపోలిన భాగాన్ని మరొక స్ట్రింగ్‌తో భర్తీ చేయవచ్చు. ప్రత్యామ్నాయ స్ట్రింగ్ తిరిగి ఇవ్వబడుతుంది.

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)

ఆర్గ్యుమెంట్‌లను పేర్కొనే పద్ధతి ఉప() వలె ఉంటుంది. మీరు కుండలీకరణాల ద్వారా సమూహం చేయబడిన భాగాన్ని ఉపయోగించవచ్చు లేదా వాదన గణనను పేర్కొనవచ్చు.

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 రీ మాడ్యూల్‌లో ఉపయోగించబడే ప్రధాన సాధారణ వ్యక్తీకరణ మెటా అక్షరాలు (ప్రత్యేక అక్షరాలు) మరియు ప్రత్యేక శ్రేణులు క్రింది విధంగా ఉన్నాయి

అవన్నీ ఈ పట్టికలో జాబితా చేయబడలేదు. పూర్తి జాబితా కోసం అధికారిక డాక్యుమెంటేషన్ చూడండి.

• 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ఇది పైథాన్ 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 చిన్న ఫారమ్ రీగా కూడా అందుబాటులో ఉంది. ఎ. మీరు దేనినైనా ఉపయోగించవచ్చు.

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

డిఫాల్ట్ గ్రీడీ మ్యాచ్ ఊహించని స్ట్రింగ్‌లతో సరిపోలుతుందని గమనించండి.