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

ಪೈಥಾನ್ ರೆಜೆಕ್ಸ್ (ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್ಸ್): ಸಂದರ್ಶನ ಪ್ರಶ್ನೆಗಳು

1. ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್ (ರೆಜೆಕ್ಸ್) ಎಂದರೇನು?

ಉತ್ತರ: ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್ (ಅಥವಾ ರೆಜೆಕ್ಸ್) ಎನ್ನುವುದು ಸ್ಟ್ರಿಂಗ್‌ಗಳಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಪ್ಯಾಟರ್ನ್‌ಗಳನ್ನು ಹುಡುಕಲು, ಹೊಂದಿಸಲು, ಮತ್ತು ನಿರ್ವಹಿಸಲು ಬಳಸುವ ಒಂದು ಸೀಕ್ವೆನ್ಸ್ ಆಫ್ ಕ್ಯಾರೆಕ್ಟರ್ಸ್. ಇದನ್ನು "ಸರ್ಚ್ ಪ್ಯಾಟರ್ನ್" ಎಂದೂ ಕರೆಯಬಹುದು.

ಉಪಯೋಗಗಳು:

  • ಡೇಟಾ ವ್ಯಾಲಿಡೇಶನ್ (ಉದಾ: ಇಮೇಲ್, ಫೋನ್ ಸಂಖ್ಯೆ).
  • ಸ್ಟ್ರಿಂಗ್‌ಗಳಲ್ಲಿ ಮಾಹಿತಿ ಹುಡುಕುವುದು ಮತ್ತು ಹೊರತೆಗೆಯುವುದು (Information Extraction).
  • ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಹುಡುಕಿ ಬದಲಾಯಿಸುವುದು (Find and Replace).

ಪೈಥಾನ್‌ನಲ್ಲಿ, re ಮಾಡ್ಯೂಲ್ ಬಳಸಿ ರೆಜೆಕ್ಸ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಮಾಡಲಾಗುತ್ತದೆ.

2. re.search() ಮತ್ತು re.match() ನಡುವಿನ ವ್ಯತ್ಯಾಸವೇನು?

ಉತ್ತರ:

  • re.match(pattern, string):

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

  • re.search(pattern, string):

    • ಇದು ಸಂಪೂರ್ಣ ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ಎಲ್ಲಿಯಾದರೂ ಪ್ಯಾಟರ್ನ್ ಅನ್ನು ಹುಡುಕುತ್ತದೆ.
    • ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ಮೊದಲ ಬಾರಿಗೆ ಪ್ಯಾಟರ್ನ್ ಮ್ಯಾಚ್ ಆದ ತಕ್ಷಣ ಮ್ಯಾಚ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಮ್ಯಾಚ್ ಸಿಗದಿದ್ದರೆ None ನೀಡುತ್ತದೆ.

ಉದಾಹರಣೆ:

import re

text = "Python is fun"

# 'match' ಆರಂಭದಲ್ಲಿ ಮಾತ್ರ ಹುಡುಕುತ್ತದೆ
match_obj = re.match("Python", text)
print(match_obj)  # <re.Match object; span=(0, 6), match='Python'>

match_obj_fail = re.match("is", text)
print(match_obj_fail)  # None

# 'search' ಎಲ್ಲಿಯಾದರೂ ಹುಡುಕುತ್ತದೆ
search_obj = re.search("is", text)
print(search_obj)  # <re.Match object; span=(7, 9), match='is'>

3. re.findall() ಮತ್ತು re.finditer() ನಡುವಿನ ವ್ಯತ್ಯಾಸವೇನು?

ಉತ್ತರ:

  • re.findall(pattern, string):

    • ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ಪ್ಯಾಟರ್ನ್‌ಗೆ ಹೊಂದುವ ಎಲ್ಲಾ ನಾನ್-ಓವರ್‌ಲ್ಯಾಪಿಂಗ್ ಮ್ಯಾಚ್‌ಗಳನ್ನು ಒಂದು ಲಿಸ್ಟ್ ಆಗಿ ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
    • ಇದು ಕೇವಲ ಮ್ಯಾಚ್ ಆದ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಮಾತ್ರ ನೀಡುತ್ತದೆ, ಮ್ಯಾಚ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನಲ್ಲ.

  • re.finditer(pattern, string):

    • findall ನಂತೆಯೇ ಎಲ್ಲಾ ಮ್ಯಾಚ್‌ಗಳನ್ನು ಹುಡುಕುತ್ತದೆ, ಆದರೆ ಫಲಿತಾಂಶವನ್ನು ಲಿಸ್ಟ್ ಆಗಿ ಹಿಂತಿರುಗಿಸುವ ಬದಲು, ಇಟರೇಟರ್ ಆಗಿ ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
    • ಈ ಇಟರೇಟರ್‌ನ ಪ್ರತಿಯೊಂದು ಐಟಂ ಒಂದು ಮ್ಯಾಚ್ ಆಬ್ಜೆಕ್ಟ್ ಆಗಿರುತ್ತದೆ, ಇದರಿಂದ ಮ್ಯಾಚ್ ಆದ ಸ್ಟ್ರಿಂಗ್ ಜೊತೆಗೆ ಅದರ ಪೊಸಿಷನ್ ( span) ನಂತಹ ಹೆಚ್ಚಿನ ಮಾಹಿತಿ ಲಭ್ಯವಾಗುತ್ತದೆ.
    • ದೊಡ್ಡ ಡೇಟಾದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಇದು ಹೆಚ್ಚು ಮೆಮೊರಿ-ಸಮರ್ಥವಾಗಿದೆ.

ಉದಾಹರಣೆ:

import re

text = "The rain in Spain falls mainly in the plain."

# findall
matches_list = re.findall("ai", text)
print(matches_list)  # ['ai', 'ai', 'ai', 'ai']

# finditer
matches_iter = re.finditer("ai", text)
for match in matches_iter:
    print(match.group(), match.span())
# 'ai' (5, 7)
# 'ai' (12, 14)
# 'ai' (23, 25)
# 'ai' (36, 38)

4. ರೆಜೆಕ್ಸ್‌ನಲ್ಲಿ ಗ್ರೂಪ್ (Group) ಎಂದರೇನು?

ಉತ್ತರ: ಪ್ಯಾಟರ್ನ್‌ನ ಒಂದು ಭಾಗವನ್ನು ಪೇರೆಂಥಿಸಿಸ್ () ಒಳಗೆ ಇರಿಸುವ ಮೂಲಕ ಗ್ರೂಪ್‌ಗಳನ್ನು ರಚಿಸಬಹುದು. ಇದು ಹಲವಾರು ಉಪಯೋಗಗಳನ್ನು ಹೊಂದಿದೆ:

  1. ಮ್ಯಾಚ್‌ನ ಭಾಗವನ್ನು ಹೊರತೆಗೆಯಲು: ಮ್ಯಾಚ್ ಆದ ಸಂಪೂರ್ಣ ಸ್ಟ್ರಿಂಗ್ ಬದಲು, ಕೇವಲ ಗ್ರೂಪ್‌ನೊಳಗಿನ ಭಾಗವನ್ನು ಮಾತ್ರ ಪಡೆಯಬಹುದು.
  2. ಕ್ವಾಂಟಿಫೈಯರ್‌ಗಳನ್ನು ಅನ್ವಯಿಸಲು: *, +, ? ನಂತಹ ಕ್ವಾಂಟಿಫೈಯರ್‌ಗಳನ್ನು ಸಂಪೂರ್ಣ ಗ್ರೂಪ್‌ಗೆ ಅನ್ವಯಿಸಬಹುದು.

ಮ್ಯಾಚ್ ಆಬ್ಜೆಕ್ಟ್‌ನ group() ಮೆಥಡ್ ಬಳಸಿ ಗ್ರೂಪ್‌ಗಳನ್ನು ಆಕ್ಸೆಸ್ ಮಾಡಬಹುದು.

  • group(0) ಅಥವಾ group(): ಸಂಪೂರ್ಣ ಮ್ಯಾಚ್.
  • group(1): ಮೊದಲ ಗ್ರೂಪ್.
  • group(2): ಎರಡನೇ ಗ್ರೂಪ್.

ಉದಾಹರಣೆ:

import re

text = "My email is [email protected]"
match = re.search(r"(\w+\.\w+)@(\w+\.\w+)", text)

if match:
    print("Full match:", match.group(0))  # [email protected]
    print("Username part:", match.group(1))  # example.user
    print("Domain part:", match.group(2))  # email.com

5. ಗ್ರೀಡಿ (Greedy) ಮತ್ತು ನಾನ್-ಗ್ರೀಡಿ (Non-Greedy) ಮ್ಯಾಚಿಂಗ್ ಎಂದರೇನು?

ಉತ್ತರ: ಕ್ವಾಂಟಿಫೈಯರ್‌ಗಳು (*, +, {m,n}) ಎಷ್ಟು ಸಾಧ್ಯವೋ ಅಷ್ಟು ಉದ್ದದ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಮ್ಯಾಚ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿದರೆ, ಅದನ್ನು * ಗ್ರೀಡಿ ಮ್ಯಾಚಿಂಗ್* ಎನ್ನುತ್ತಾರೆ. ಇದು ಡೀಫಾಲ್ಟ್ ನಡವಳಿಕೆ.

  • *: 0 ಅಥವಾ ಹೆಚ್ಚು ಬಾರಿ (ಗ್ರೀಡಿ)
  • +: 1 ಅಥವಾ ಹೆಚ್ಚು ಬಾರಿ (ಗ್ರೀಡಿ)

ಕ್ವಾಂಟಿಫೈಯರ್‌ಗಳು ಸಾಧ್ಯವಾದಷ್ಟು ಕಡಿಮೆ ಉದ್ದದ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಮ್ಯಾಚ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿದರೆ, ಅದನ್ನು ನಾನ್-ಗ್ರೀಡಿ (ಅಥವಾ ಲೇಜಿ) ಮ್ಯಾಚಿಂಗ್ ಎನ್ನುತ್ತಾರೆ. ಇದನ್ನು ಕ್ವಾಂಟಿಫೈಯರ್‌ನ ನಂತರ ? ಚಿಹ್ನೆಯನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ಸಾಧಿಸಲಾಗುತ್ತದೆ.

  • *?: 0 ಅಥವಾ ಹೆಚ್ಚು ಬಾರಿ (ನಾನ್-ಗ್ರೀಡಿ)
  • +?: 1 ಅಥವಾ ಹೆಚ್ಚು ಬಾರಿ (ನಾನ್-ಗ್ರೀಡಿ)

ಉದಾಹರಣೆ:

import re

text = "<html><head><title>Title</title></head></html>"

# ಗ್ರೀಡಿ ಮ್ಯಾಚಿಂಗ್
greedy_match = re.search(r"<.*>", text)
print(greedy_match.group(0))  # <html><head><title>Title</title></head></html>

# ನಾನ್-ಗ್ರೀಡಿ ಮ್ಯಾಚಿಂಗ್
non_greedy_match = re.search(r"<.*?>", text)
print(non_greedy_match.group(0))  # <html>