பைதான் ரெகுலர் எக்ஸ்பிரஷன் மாட்யூலை எவ்வாறு பயன்படுத்துவது (பொருத்தம், தேடல், துணை போன்றவை)

வணிக

பைத்தானில் வழக்கமான வெளிப்பாடு செயலாக்கத்தைச் செய்ய, நிலையான நூலகத்திலிருந்து மறு தொகுதியைப் பயன்படுத்துகிறோம். வழக்கமான வெளிப்பாடு வடிவங்களைப் பயன்படுத்தி சரங்களைப் பிரித்தெடுக்கவும், மாற்றவும் மற்றும் பிரிக்கவும் இது உங்களை அனுமதிக்கிறது.

இந்த பகுதியில், முதலில் re module இன் செயல்பாடுகள் மற்றும் முறைகளை விளக்குவோம்.

  • வழக்கமான வெளிப்பாடு வடிவங்களை தொகுத்தல்: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()எடுத்துக்காட்டாக, இந்த செயல்பாடுகளின் அதே செயல்முறையை வழக்கமான வெளிப்பாடு பொருள்களின் முறைகள் பொருத்தம்(),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() போன்ற சரங்கள் அல்ல, ஆனால் பொருந்தக்கூடிய பொருள்கள், எனவே நீங்கள் பொருந்திய பகுதிகளின் நிலையை (குறியீட்டு) பெறலாம்.

அதன் உள்ளடக்கங்களைப் பெற, மீண்டும் மீண்டும் அச்சிட்டு அச்சிட முடியாது. நீங்கள் உள்ளமைக்கப்பட்ட செயல்பாட்டை 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'>

இது பட்டியல்() கொண்ட பட்டியலாகவும் மாற்றப்படலாம்.

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

அடைப்புக்குறிக்குள் (), பொருத்தப்பட்ட சரத்தை மாற்றியமைக்கப்பட்ட சரத்தில் பயன்படுத்தலாம்.

முன்னிருப்பாக, பின்வருபவை ஆதரிக்கப்படும்: கச்சா சரங்கள் அல்லாத சாதாரண சரங்களுக்கு, பின்சாய்வுக்கு முன் பின்சாய்வுக்கு முன் ஒரு பின்சாய்வு பட்டியலிடப்பட வேண்டும் என்பதை நினைவில் கொள்ளவும்.

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

maxsplit வாதம் அதிகபட்ச எண்ணிக்கையிலான பிளவுகளை (துண்டுகள்) குறிப்பிடுகிறது. இடது பக்கத்தில் இருந்து எண்ணிக்கை மட்டுமே பிரிக்கப்படும்.

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

பைத்தானில் வழக்கமான வெளிப்பாடு மெட்டாக்ராக்டர்கள், சிறப்புத் தொடர்கள் மற்றும் எச்சரிக்கைகள்

பைதான் 3 மறு தொகுதியில் பயன்படுத்தக்கூடிய முக்கிய வழக்கமான வெளிப்பாடு மெட்டா எழுத்துகள் (சிறப்பு எழுத்துக்கள்) மற்றும் சிறப்பு வரிசைகள் பின்வருமாறு

மெட்டா பாத்திரம்உள்ளடக்கங்கள்
.புதிய வரியைத் தவிர வேறு எந்த ஒரு எழுத்தும் (DOTALL கொடியுடன் கூடிய புதிய வரி உட்பட)
^சரத்தின் ஆரம்பம் (ஒவ்வொரு வரியின் தொடக்கத்தையும் MULTILINE கொடியுடன் பொருத்துகிறது)
$சரத்தின் முடிவு (ஒவ்வொரு வரியின் முடிவையும் மல்டிலைன் கொடியுடன் பொருத்துகிறது)
*முந்தைய முறையை 0 முறைக்கு மேல் செய்யவும்
+முந்தைய முறையை ஒரு முறையாவது செய்யவும்.
?முந்தைய முறையை 0 அல்லது 1 முறை செய்யவும்
{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இது பைதான் 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

இயல்பு பேராசை பொருத்தம் எதிர்பாராத சரங்களுடன் பொருந்தக்கூடும் என்பதை நினைவில் கொள்ளவும்.