Python RegEx

பைத்தான் ரெகுலர் எக்ஸ்பிரஷன்களைக் கற்றுக்கொள்ளுங்கள்

பைத்தான் RegEx

ஒரு RegEx, அல்லது Regular Expression, என்பது ஒரு தேடல் முறையை உருவாக்கும் எழுத்துக்களின் வரிசை ஆகும்.

ஒரு சரம் குறிப்பிட்ட தேடல் முறையைக் கொண்டுள்ளதா எனச் சரிபார்க்க RegEx பயன்படுத்தப்படலாம்.

RegEx தொகுதி

பைத்தானில் re என்ற உள்ளமை தொகுப்பு உள்ளது, இது Regular Expressions உடன் பணியாற்ற பயன்படுத்தப்படலாம்.

import re

பைத்தானில் RegEx

நீங்கள் re தொகுதியை இறக்குமதி செய்த பிறகு, வழக்கமான வெளிப்பாடுகளைப் பயன்படுத்தத் தொடங்கலாம்:

எடுத்துக்காட்டு

சரம் "The" உடன் தொடங்கி "Spain" உடன் முடிகிறதா எனச் சரிபார்க்கவும்:

import re

txt = "The rain in Spain"
x = re.search("^The.*Spain$", txt)

RegEx செயல்பாடுகள்

re தொகுதி ஒரு சரத்தில் ஒரு பொருத்தத்தைத் தேட அனுமதிக்கும் செயல்பாடுகளின் தொகுப்பை வழங்குகிறது:

findall()

அனைத்து பொருத்தங்களையும் கொண்ட பட்டியலைத் திருப்பித் தருகிறது.

search()

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

split()

சரம் ஒவ்வொரு பொருத்தத்திலும் பிரிக்கப்பட்ட இடத்தில் பட்டியலைத் திருப்பித் தருகிறது.

sub()

பொருத்தங்களை உங்கள் தேர்வின் உரையுடன் மாற்றுகிறது.

findall() எடுத்துக்காட்டு

import re

txt = "The rain in Spain"
x = re.findall("ai", txt)
print(x)
வெளியீடு:
['ai', 'ai']

மெட்டாகேரக்டர்கள்

மெட்டாகேரக்டர்கள் சிறப்பு அர்த்தத்துடன் கூடிய எழுத்துக்கள்:

எழுத்து விளக்கம் எடுத்துக்காட்டு
[] எழுத்துக்களின் தொகுப்பு "[a-m]"
\ சிறப்பு வரிசையின் சமிக்ஞை (சிறப்பு எழுத்துக்களைத் தப்பிக்கவும் பயன்படுத்தலாம்) "\d"
. எந்த எழுத்தும் (புதிய வரி எழுத்து தவிர) "he..o"
^ தொடங்குகிறது "^hello"
$ முடிகிறது "planet$"
* பூஜ்யம் அல்லது அதற்கு மேற்பட்ட நிகழ்வுகள் "he.*o"
+ ஒன்று அல்லது அதற்கு மேற்பட்ட நிகழ்வுகள் "he.+o"
? பூஜ்யம் அல்லது ஒரு நிகழ்வு "he.?o"
{} குறிப்பிட்ட எண்ணிக்கையிலான நிகழ்வுகள் "he.{2}o"
| அல்லது "falls|stays"
() பிடித்து குழுவாக்கு

சிறப்பு வரிசைகள்

ஒரு சிறப்பு வரிசை என்பது \ மற்றும் கீழே உள்ள பட்டியலில் உள்ள எழுத்துகளில் ஒன்று ஆகும், மேலும் இது ஒரு சிறப்பு அர்த்தத்தைக் கொண்டுள்ளது:

எழுத்து விளக்கம் எடுத்துக்காட்டு
\A குறிப்பிட்ட எழுத்துகள் சரத்தின் தொடக்கத்தில் இருந்தால் பொருத்தத்தைத் தருகிறது "\AThe"
\b குறிப்பிட்ட எழுத்துகள் ஒரு வார்த்தையின் தொடக்கத்தில் அல்லது முடிவில் இருந்தால் பொருத்தத்தைத் தருகிறது r"\bain"
\B குறிப்பிட்ட எழுத்துகள் உள்ளன, ஆனால் ஒரு வார்த்தையின் தொடக்கத்தில் (அல்லது முடிவில்) இல்லை என்றால் பொருத்தத்தைத் தருகிறது r"\Bain"
\d சரம் இலக்கங்களைக் கொண்டிருந்தால் (0-9 இலிருந்து எண்கள்) பொருத்தத்தைத் தருகிறது "\d"
\D சரம் இலக்கங்களைக் கொண்டிருக்கவில்லை என்றால் பொருத்தத்தைத் தருகிறது "\D"
\s சரம் ஒரு வெள்ளை இட எழுத்தைக் கொண்டிருந்தால் பொருத்தத்தைத் தருகிறது "\s"
\S சரம் ஒரு வெள்ளை இட எழுத்தைக் கொண்டிருக்கவில்லை என்றால் பொருத்தத்தைத் தருகிறது "\S"
\w சரம் எந்த வார்த்தை எழுத்துக்களையும் கொண்டிருந்தால் (a முதல் Z வரை எழுத்துக்கள், 0-9 இலிருந்து இலக்கங்கள், மற்றும் அடிக்கோடு _ எழுத்து) பொருத்தத்தைத் தருகிறது "\w"
\W சரம் எந்த வார்த்தை எழுத்துக்களையும் கொண்டிருக்கவில்லை என்றால் பொருத்தத்தைத் தருகிறது "\W"
\Z குறிப்பிட்ட எழுத்துகள் சரத்தின் முடிவில் இருந்தால் பொருத்தத்தைத் தருகிறது "Spain\Z"

செட்கள்

ஒரு செட் என்பது சதுர அடைப்புக்குறிகளுக்குள் உள்ள எழுத்துக்களின் தொகுப்பாகும் [] இது ஒரு சிறப்பு அர்த்தத்தைக் கொண்டுள்ளது:

எடுத்துக்காட்டு

import re

txt = "The rain in Spain"
x = re.findall('[a-c]', txt)
print(x)

இந்த வெளிப்பாடு 'a', 'b', அல்லது 'c' எழுத்துக்களைத் தேடுகிறது.

செட் விளக்கம்
[arn] குறிப்பிட்ட எழுத்துகளில் ஒன்று (a, r, அல்லது n) இருக்கும் இடத்தில் பொருத்தத்தைத் தருகிறது
[a-n] a மற்றும் n க்கு இடையில் அகரவரிசையில் உள்ள எந்த சிறிய எழுத்துக்கும் பொருத்தத்தைத் தருகிறது
[^arn] a, r, மற்றும் n தவிர வேறு எந்த எழுத்துக்கும் பொருத்தத்தைத் தருகிறது
[0123] குறிப்பிட்ட இலக்கங்களில் ஏதேனும் (0, 1, 2, அல்லது 3) இருக்கும் இடத்தில் பொருத்தத்தைத் தருகிறது
[0-9] 0 மற்றும் 9 க்கு இடையில் உள்ள எந்த இலக்கத்திற்கும் பொருத்தத்தைத் தருகிறது
[a-zA-Z] a மற்றும் z க்கு இடையில் அகரவரிசையில் உள்ள எந்த எழுத்துக்கும், சிறிய எழுத்து அல்லது பெரிய எழுத்து, பொருத்தத்தைத் தருகிறது

பொருத்த பொருள்

ஒரு பொருத்த பொருள் என்பது தேடல் மற்றும் முடிவைப் பற்றிய தகவல்களைக் கொண்ட ஒரு பொருள் ஆகும்.

பொருத்த பொருளின் பண்புகள் மற்றும் முறைகள்:

.span()

பொருத்தத்தின் தொடக்க மற்றும் முடிவு நிலைகளைக் கொண்ட ஒரு டூப்பிளைத் தருகிறது.

.string

செயல்பாட்டிற்குள் அனுப்பப்பட்ட சரத்தைத் தருகிறது.

.group()

பொருத்தம் இருந்த சரத்தின் பகுதியைத் தருகிறது.

எடுத்துக்காட்டு

import re

txt = "The rain in Spain"
x = re.search(r"\bS\w+", txt)

print("Span:", x.span())
print("String:", x.string)
print("Group:", x.group())
வெளியீடு:
Span: (12, 17)
String: The rain in Spain
Group: Spain

பயிற்சி

பின்வரும் குறியீட்டைக் கவனியுங்கள்:

import re
txt = 'The rain in Spain'
x = re.findall('[a-c]', txt)
print(x)

அச்சிடப்பட்ட முடிவு என்னவாக இருக்கும்?

['a', 'a']
✓ சரி! [a-c] என்பது 'a', 'b', அல்லது 'c' எழுத்துக்களைத் தேடுகிறது. "The rain in Spain" சரத்தில் 'a' எழுத்து இரண்டு முறை தோன்றுகிறது: "rain" மற்றும் "Spain". 'b' அல்லது 'c' எழுத்துக்கள் இல்லை, எனவே findall() இரண்டு 'a' எழுத்துக்களின் பட்டியலைத் தருகிறது.
'The rin in Spin'
✗ தவறு! findall() பொருத்தங்களின் பட்டியலைத் தருகிறது, சரத்தை மாற்றாது. sub() செயல்பாடு சரத்தை மாற்றும், ஆனால் இங்கே findall() பயன்படுத்தப்படுகிறது.
2
✗ தவறு! findall() ஒரு பட்டியலைத் தருகிறது, எண்ணை அல்ல. பொருத்தங்களின் எண்ணிக்கையைப் பெற len() பயன்படுத்தலாம்: len(re.findall('[a-c]', txt)).