ವಿಷಯಕ್ಕೆ ತೆರಳಿ

re ಮಾಡ್ಯೂಲ್‌ನ ಪ್ರಮುಖ ಫಂಕ್ಷನ್‌ಗಳು

re ಮಾಡ್ಯೂಲ್ ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಹಲವು ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ಅವುಗಳಲ್ಲಿ ಪ್ರಮುಖವಾದವುಗಳನ್ನು ಇಲ್ಲಿ ವಿವರಿಸಲಾಗಿದೆ.

1. re.search(pattern, string)

ಈ ಫಂಕ್ಷನ್ ಇಡೀ ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ಪ್ಯಾಟರ್ನ್‌ಗಾಗಿ ಹುಡುಕುತ್ತದೆ ಮತ್ತು ಮೊದಲ ಮ್ಯಾಚ್ ಸಿಕ್ಕಿದ ತಕ್ಷಣ ನಿಲ್ಲಿಸುತ್ತದೆ. * ಮ್ಯಾಚ್ ಸಿಕ್ಕರೆ, ಅದು ಒಂದು ಮ್ಯಾಚ್ ಆಬ್ಜೆಕ್ಟ್ (Match Object) ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. * ಮ್ಯಾಚ್ ಸಿಗದಿದ್ದರೆ, None ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ: 

import re

text = "ಪೈಥಾನ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ತುಂಬಾ ಸುಲಭ ಮತ್ತು ಪೈಥಾನ್ ಜನಪ್ರಿಯವಾಗಿದೆ."
pattern = r"ಪೈಥಾನ್"

match = re.search(pattern, text)

if match:
    print("ಪ್ಯಾಟರ್ನ್ ಕಂಡುಬಂದಿದೆ!")
    print(f"ಮ್ಯಾಚ್ ಆದ ಸ್ಟ್ರಿಂಗ್: '{match.group()}'")
    print(f"ಪ್ರಾರಂಭದ ಇಂಡೆಕ್ಸ್: {match.start()}")
    print(f"ಅಂತ್ಯದ ಇಂಡೆಕ್ಸ್: {match.end()}")
else:
    print("ಪ್ಯಾಟರ್ನ್ ಕಂಡುಬಂದಿಲ್ಲ.")
ಔಟ್‌ಪುಟ್: 
ಪ್ಯಾಟರ್ನ್ ಕಂಡುಬಂದಿದೆ!
ಮ್ಯಾಚ್ ಆದ ಸ್ಟ್ರಿಂಗ್: 'ಪೈಥಾನ್'
ಪ್ರಾರಂಭದ ಇಂಡೆಕ್ಸ್: 0
ಅಂತ್ಯದ ಇಂಡೆಕ್ಸ್: 7
search() ಇಡೀ ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ಹುಡುಕುತ್ತದೆ, ಆದರೆ ಮೊದಲ ಮ್ಯಾಚ್ ಸಿಕ್ಕ ತಕ್ಷಣ ನಿಲ್ಲಿಸುತ್ತದೆ.

2. re.match(pattern, string)

ಈ ಫಂಕ್ಷನ್ ಸ್ಟ್ರಿಂಗ್‌ನ ಪ್ರಾರಂಭದಲ್ಲಿ ಮಾತ್ರ ಪ್ಯಾಟರ್ನ್‌ಗಾಗಿ ಹುಡುಕುತ್ತದೆ. * ಸ್ಟ್ರಿಂಗ್‌ನ ಪ್ರಾರಂಭವು ಪ್ಯಾಟರ್ನ್‌ಗೆ ಮ್ಯಾಚ್ ಆದರೆ ಮಾತ್ರ ಮ್ಯಾಚ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. * ಇಲ್ಲದಿದ್ದರೆ, None ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ: 

import re

text1 = "ಪೈಥಾನ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್"
text2 = "ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಪೈಥಾನ್"
pattern = r"ಪೈಥಾನ್"

match1 = re.match(pattern, text1)
print(f"text1 ಗಾಗಿ ಮ್ಯಾಚ್: {match1}") # ಮ್ಯಾಚ್ ಆಗುತ್ತದೆ

match2 = re.match(pattern, text2)
print(f"text2 ಗಾಗಿ ಮ್ಯಾಚ್: {match2}") # ಮ್ಯಾಚ್ ಆಗುವುದಿಲ್ಲ (None)
ಔಟ್‌ಪುಟ್: 
text1 ಗಾಗಿ ಮ್ಯಾಚ್: <re.Match object; span=(0, 7), match='ಪೈಥಾನ್'>
text2 ಗಾಗಿ ಮ್ಯಾಚ್: None

3. re.findall(pattern, string)

ಈ ಫಂಕ್ಷನ್ ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ಪ್ಯಾಟರ್ನ್‌ಗೆ ಮ್ಯಾಚ್ ಆಗುವ ಎಲ್ಲಾ ನಾನ್-ಓವರ್‌ಲ್ಯಾಪಿಂಗ್ (non-overlapping) ಭಾಗಗಳನ್ನು ಹುಡುಕಿ, ಅವುಗಳನ್ನು ಒಂದು ಲಿಸ್ಟ್ ಆಗಿ ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ: 

import re

text = "ನನ್ನ ಇಮೇಲ್ ವಿಳಾಸಗಳು: user1@example.com ಮತ್ತು user2@work.org"
pattern = r"\w+@\w+\.\w+" # ಇಮೇಲ್ ವಿಳಾಸಕ್ಕಾಗಿ ಒಂದು ಸರಳ ಪ್ಯಾಟರ್ನ್

emails = re.findall(pattern, text)
print(emails)
ಔಟ್‌ಪುಟ್: 
['user1@example.com', 'user2@work.org']
findall() ಮ್ಯಾಚ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಬದಲು, ಮ್ಯಾಚ್ ಆದ ಸ್ಟ್ರಿಂಗ್‌ಗಳ ಲಿಸ್ಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

4. re.finditer(pattern, string)

ಇದು findall() ನಂತೆಯೇ ಕೆಲಸ ಮಾಡುತ್ತದೆ, ಆದರೆ ಸ್ಟ್ರಿಂಗ್‌ಗಳ ಲಿಸ್ಟ್ ಬದಲು, ಇದು ಮ್ಯಾಚ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಇಟರೇಟರ್ (iterator) ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ದೊಡ್ಡ ಸಂಖ್ಯೆಯ ಮ್ಯಾಚ್‌ಗಳಿದ್ದಾಗ ಇದು ಹೆಚ್ಚು ಮೆಮೊರಿ-ಸಮರ್ಥವಾಗಿದೆ.

ಉದಾಹರಣೆ: 

import re

text = "ನನ್ನ ಇಮೇಲ್ ವಿಳಾಸಗಳು: user1@example.com ಮತ್ತು user2@work.org"
pattern = r"\w+@\w+\.\w+"

matches = re.finditer(pattern, text)

for match in matches:
    print(f"ಕಂಡುಬಂದ ಇಮೇಲ್: {match.group()}, ಸ್ಥಾನ: {match.span()}")
ಔಟ್‌ಪುಟ್: 
ಕಂಡುಬಂದ ಇಮೇಲ್: user1@example.com, ಸ್ಥಾನ: (20, 37)
ಕಂಡುಬಂದ ಇಮೇಲ್: user2@work.org, ಸ್ಥಾನ: (42, 56)

5. re.sub(pattern, replacement, string)

ಈ ಫಂಕ್ಷನ್ ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ಪ್ಯಾಟರ್ನ್‌ಗೆ ಮ್ಯಾಚ್ ಆಗುವ ಎಲ್ಲಾ ಭಾಗಗಳನ್ನು replacement ಸ್ಟ್ರಿಂಗ್‌ನೊಂದಿಗೆ ಬದಲಾಯಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ: 

import re

text = "ನನ್ನ ಫೋನ್ ಸಂಖ್ಯೆ 123-456-7890 ಆಗಿದೆ."
pattern = r"\d{3}-\d{3}-\d{4}"
replacement = "[ಸಂಖ್ಯೆಯನ್ನು ಮರೆಮಾಡಲಾಗಿದೆ]"

new_text = re.sub(pattern, replacement, text)
print(new_text)
ಔಟ್‌ಪುಟ್: 
ನನ್ನ ಫೋನ್ ಸಂಖ್ಯೆ [ಸಂಖ್ಯೆಯನ್ನು ಮರೆಮಾಡಲಾಗಿದೆ] ಆಗಿದೆ.

6. re.split(pattern, string)

ಈ ಫಂಕ್ಷನ್ ಪ್ಯಾಟರ್ನ್ ಮ್ಯಾಚ್ ಆಗುವ ಸ್ಥಳಗಳಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ವಿಭಜಿಸಿ, ಭಾಗಗಳ ಲಿಸ್ಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ: 

import re

text = "apple,banana;cherry orange"
# ಅಲ್ಪವಿರಾಮ, ಅರ್ಧವಿರಾಮ, ಅಥವಾ ಸ್ಪೇಸ್ ಬಳಸಿ ವಿಭಜಿಸುವುದು
pattern = r"[,;\s]+"

parts = re.split(pattern, text)
print(parts)
ಔಟ್‌ಪುಟ್: 
['apple', 'banana', 'cherry', 'orange']

7. re.compile(pattern)

ಒಂದು ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್ ಪ್ಯಾಟರ್ನ್ ಅನ್ನು ನೀವು ಹಲವು ಬಾರಿ ಬಳಸುವುದಾದರೆ, ಅದನ್ನು re.compile() ಬಳಸಿ ಕಂಪೈಲ್ ಮಾಡಬಹುದು. ಇದು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಸ್ವಲ್ಪ ವೇಗಗೊಳಿಸುತ್ತದೆ. ಕಂಪೈಲ್ ಮಾಡಿದ ಪ್ಯಾಟರ್ನ್ ಆಬ್ಜೆಕ್ಟ್ ಮೇಲೆ search(), findall() ಮುಂತಾದ ಎಲ್ಲಾ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಮೆಥಡ್‌ಗಳಾಗಿ ಕರೆಯಬಹುದು.

ಉದಾಹರಣೆ: 

import re

# ಪ್ಯಾಟರ್ನ್ ಅನ್ನು ಒಮ್ಮೆ ಕಂಪೈಲ್ ಮಾಡುವುದು
email_pattern = re.compile(r"\w+@\w+\.\w+")

text1 = "ಇಮೇಲ್: test1@email.com"
text2 = "ಇನ್ನೊಂದು ಇಮೇಲ್: test2@provider.net"

# ಕಂಪೈಲ್ ಮಾಡಿದ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಬಳಸುವುದು
print(email_pattern.findall(text1))
print(email_pattern.findall(text2))
ಔಟ್‌ಪುಟ್: 
['test1@email.com']
['test2@provider.net']
ಈ ಫಂಕ್ಷನ್‌ಗಳು ಪೈಥಾನ್‌ನಲ್ಲಿ ಟೆಕ್ಸ್ಟ್ ಪ್ರೊಸೆಸಿಂಗ್‌ಗೆ ಬೇಕಾದ ಹೆಚ್ಚಿನ ರೆಜೆಕ್ಸ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ.