ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳಲ್ಲಿ ಗ್ರೂಪ್‌ಗಳು ಮತ್ತು ಕ್ಯಾಪ್ಚರಿಂಗ್

ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳಲ್ಲಿ, ಪ್ಯಾರಂಥೆಸಿಸ್ () ಬಳಸಿ ಗ್ರೂಪ್‌ಗಳನ್ನು ರಚಿಸಲಾಗುತ್ತದೆ. ಗ್ರೂಪ್‌ಗಳು ಹಲವು ಉದ್ದೇಶಗಳನ್ನು ಪೂರೈಸುತ್ತವೆ:

ಪ್ಯಾಟರ್ನ್‌ಗಳನ್ನು ಒಟ್ಟುಗೂಡಿಸಲು: ಕ್ವಾಂಟಿಫಯರ್‌ಗಳನ್ನು (*, +, ?, {}) ಇಡೀ ಗ್ರೂಪ್‌ಗೆ ಅನ್ವಯಿಸಲು.
ಮ್ಯಾಚ್ ಆದ ಭಾಗವನ್ನು ಕ್ಯಾಪ್ಚರ್ ಮಾಡಲು: ಮ್ಯಾಚ್ ಆದ ಸ್ಟ್ರಿಂಗ್‌ನ ನಿರ್ದಿಷ್ಟ ಭಾಗಗಳನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಹಿಂಪಡೆಯಲು.

1. ಕ್ಯಾಪ್ಚರಿಂಗ್ ಗ್ರೂಪ್‌ಗಳು (Capturing Groups)

ಸರಳವಾದ () ಬಳಸಿ ರಚಿಸಿದ ಗ್ರೂಪ್‌ಗಳು "ಕ್ಯಾಪ್ಚರಿಂಗ್ ಗ್ರೂಪ್‌ಗಳು". ಇವು ಮ್ಯಾಚ್ ಆದ ಭಾಗವನ್ನು ಕ್ಯಾಪ್ಚರ್ ಮಾಡುತ್ತವೆ. ಮ್ಯಾಚ್ ಆಬ್ಜೆಕ್ಟ್‌ನ group() ಅಥವಾ groups() ಮೆಥಡ್‌ಗಳನ್ನು ಬಳಸಿ ಈ ಕ್ಯಾಪ್ಚರ್ ಮಾಡಿದ ಭಾಗಗಳನ್ನು ಹಿಂಪಡೆಯಬಹುದು.

match.group(0) ಅಥವಾ match.group(): ಸಂಪೂರ್ಣ ಮ್ಯಾಚ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
match.group(1): ಮೊದಲನೇ ಗ್ರೂಪ್ ಕ್ಯಾಪ್ಚರ್ ಮಾಡಿದ ಭಾಗವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
match.group(2): ಎರಡನೇ ಗ್ರೂಪ್ ಕ್ಯಾಪ್ಚರ್ ಮಾಡಿದ ಭಾಗವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
match.groups(): ಎಲ್ಲಾ ಕ್ಯಾಪ್ಚರ್ ಮಾಡಿದ ಗ್ರೂಪ್‌ಗಳ ಒಂದು ಟ್ಯೂಪಲ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ: ದಿನಾಂಕವನ್ನು (DD-MM-YYYY) ಪಾರ್ಸ್ ಮಾಡುವುದು.

import re

text = "ಇಂದಿನ ದಿನಾಂಕ: 20-12-2025"
pattern = r"(\d{2})-(\d{2})-(\d{4})" # ಮೂರು ಕ್ಯಾಪ್ಚರಿಂಗ್ ಗ್ರೂಪ್‌ಗಳು

match = re.search(pattern, text)

if match:
    print(f"ಸಂಪೂರ್ಣ ಮ್ಯಾಚ್ (group 0): {match.group(0)}")
    print(f"ದಿನ (group 1): {match.group(1)}")
    print(f"ತಿಂಗಳು (group 2): {match.group(2)}")
    print(f"ವರ್ಷ (group 3): {match.group(3)}")
    print(f"ಎಲ್ಲಾ ಗ್ರೂಪ್‌ಗಳು (groups()): {match.groups()}")

ಔಟ್‌ಪುಟ್:

ಸಂಪೂರ್ಣ ಮ್ಯಾಚ್ (group 0): 20-12-2025
ದಿನ (group 1): 20
ತಿಂಗಳು (group 2): 22
ವರ್ಷ (group 3): 2025
ಎಲ್ಲಾ ಗ್ರೂಪ್‌ಗಳು (groups()): ('20', '12', '2025')

2. ನಾನ್-ಕ್ಯಾಪ್ಚರಿಂಗ್ ಗ್ರೂಪ್‌ಗಳು (Non-capturing Groups)

ಕೆಲವೊಮ್ಮೆ, ಪ್ಯಾಟರ್ನ್‌ಗಳನ್ನು ಒಟ್ಟುಗೂಡಿಸಲು ಮಾತ್ರ ಗ್ರೂಪ್ ಬೇಕಾಗುತ್ತದೆ, ಆದರೆ ಆ ಭಾಗವನ್ನು ಕ್ಯಾಪ್ಚರ್ ಮಾಡುವ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ. ಅಂತಹ ಸಂದರ್ಭಗಳಲ್ಲಿ, ನಾನ್-ಕ್ಯಾಪ್ಚರಿಂಗ್ ಗ್ರೂಪ್‌ಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

ಇದನ್ನು (?:...) ಸಿಂಟ್ಯಾಕ್ಸ್ ಬಳಸಿ ರಚಿಸಲಾಗುತ್ತದೆ.

ಉದಾಹರಣೆ: http:// ಅಥವಾ https:// ನೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಗುವ URL ಗಳನ್ನು ಮ್ಯಾಚ್ ಮಾಡೋಣ, ಆದರೆ http ಅಥವಾ https ಅನ್ನು ಕ್ಯಾಪ್ಚರ್ ಮಾಡುವುದು ಬೇಡ.

import re

text = "ನನ್ನ ವೆಬ್‌ಸೈಟ್: https://www.example.com"
# 'http' ಅಥವಾ 'https' ಅನ್ನು ಮ್ಯಾಚ್ ಮಾಡುತ್ತದೆ, ಆದರೆ ಕ್ಯಾಪ್ಚರ್ ಮಾಡುವುದಿಲ್ಲ.
pattern = r"(?:https?)://(www\..+\.com)" 

match = re.search(pattern, text)

if match:
    print(f"ಸಂಪೂರ್ಣ ಮ್ಯಾಚ್: {match.group(0)}")
    print(f"ಕ್ಯಾಪ್ಚರ್ ಆದ ಗ್ರೂಪ್‌ಗಳು: {match.groups()}")
    print(f"ಮೊದಲ ಕ್ಯಾಪ್ಚರ್ (ಡೊಮೇನ್): {match.group(1)}")

ಔಟ್‌ಪುಟ್:

ಸಂಪೂರ್ಣ ಮ್ಯಾಚ್: https://www.example.com
ಕ್ಯಾಪ್ಚರ್ ಆದ ಗ್ರೂಪ್‌ಗಳು: ('www.example.com',)
ಮೊದಲ ಕ್ಯಾಪ್ಚರ್ (ಡೊಮೇನ್): www.example.com

ಇಲ್ಲಿ, (?:https?) ಒಂದು ನಾನ್-ಕ್ಯಾಪ್ಚರಿಂಗ್ ಗ್ರೂಪ್ ಆಗಿರುವುದರಿಂದ, match.groups() ನಲ್ಲಿ https ಸೇರಿಲ್ಲ.

3. ನೇಮ್ಡ್ ಗ್ರೂಪ್‌ಗಳು (Named Groups)

ಗ್ರೂಪ್‌ಗಳನ್ನು ಸಂಖ್ಯೆಗಳ (1, 2, 3...) ಬದಲು ಹೆಸರುಗಳಿಂದ ಗುರುತಿಸುವುದು ಹೆಚ್ಚು ಓದಬಲ್ಲದು. ನೇಮ್ಡ್ ಗ್ರೂಪ್‌ಗಳನ್ನು (?P<name>...) ಸಿಂಟ್ಯಾಕ್ಸ್ ಬಳಸಿ ರಚಿಸಲಾಗುತ್ತದೆ.

match.group('name') ಬಳಸಿ ಈ ಗ್ರೂಪ್‌ಗಳನ್ನು ಹಿಂಪಡೆಯಬಹುದು.

ಉದಾಹರಣೆ: ದಿನಾಂಕದ ಉದಾಹರಣೆಯನ್ನೇ ನೇಮ್ಡ್ ಗ್ರೂಪ್‌ಗಳೊಂದಿಗೆ ಬರೆಯೋಣ.

import re

text = "ಇಂದಿನ ದಿನಾಂಕ: 20-12-2025"
pattern = r"(?P<day>\d{2})-(?P<month>\d{2})-(?P<year>\d{4})"

match = re.search(pattern, text)

if match:
    print(f"ದಿನ: {match.group('day')}")
    print(f"ತಿಂಗಳು: {match.group('month')}")
    print(f"ವರ್ಷ: {match.group('year')}")

    # groupdict() ಮೆಥಡ್ ಬಳಸಿ ಎಲ್ಲಾ ನೇಮ್ಡ್ ಗ್ರೂಪ್‌ಗಳನ್ನು ಡಿಕ್ಷನರಿಯಾಗಿ ಪಡೆಯಬಹುದು
    print(f"ಗ್ರೂಪ್ ಡಿಕ್ಷನರಿ: {match.groupdict()}")

ಔಟ್‌ಪುಟ್:

ದಿನ: 20
ತಿಂಗಳು: 12
ವರ್ಷ: 2025
ಗ್ರೂಪ್ ಡಿಕ್ಷನರಿ: {'day': '20', 'month': '12', 'year': '2025'}

4. ಬ್ಯಾಕ್‌ರೆಫರೆನ್ಸ್‌ಗಳು (Backreferences)

ಒಮ್ಮೆ ಒಂದು ಗ್ರೂಪ್ ಏನನ್ನಾದರೂ ಕ್ಯಾಪ್ಚರ್ ಮಾಡಿದರೆ, ಅದೇ ಪ್ಯಾಟರ್ನ್‌ನೊಳಗೆ ಆ ಕ್ಯಾಪ್ಚರ್ ಮಾಡಿದ ಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಪುನಃ ಮ್ಯಾಚ್ ಮಾಡಲು ಬ್ಯಾಕ್‌ರೆಫರೆನ್ಸ್‌ಗಳನ್ನು ಬಳಸಬಹುದು.

\1: ಮೊದಲನೇ ಗ್ರೂಪ್ ಕ್ಯಾಪ್ಚರ್ ಮಾಡಿದ ಟೆಕ್ಸ್ಟ್‌ಗೆ ಮ್ಯಾಚ್ ಆಗುತ್ತದೆ.
\2: ಎರಡನೇ ಗ್ರೂಪ್ ಕ್ಯಾಪ್ಚರ್ ಮಾಡಿದ ಟೆಕ್ಸ್ಟ್‌ಗೆ ಮ್ಯಾಚ್ ಆಗುತ್ತದೆ.
ನೇಮ್ಡ್ ಗ್ರೂಪ್‌ಗಳಿಗಾಗಿ: (?P=name)

ಉದಾಹರಣೆ 1: ಪುನರಾವರ್ತಿತ ಪದಗಳನ್ನು ಹುಡುಕುವುದು

import re

text = "hello hello world world"
pattern = r"\b(\w+)\s+\1\b" # ಒಂದು ಪದ, ನಂತರ ಸ್ಪೇಸ್, ನಂತರ ಅದೇ ಪದ

matches = re.findall(pattern, text)
print(matches)

ಔಟ್‌ಪುಟ್:

['hello', 'world']

ವಿವರಣೆ: * \b(\w+)\b: ಒಂದು ಪದವನ್ನು ಕ್ಯಾಪ್ಚರ್ ಮಾಡುತ್ತದೆ (ಗ್ರೂಪ್ 1). * \s+: ಒಂದು ಅಥವಾ ಹೆಚ್ಚು ಸ್ಪೇಸ್‌ಗಳು. * \1: ಗ್ರೂಪ್ 1 ರಲ್ಲಿ ಕ್ಯಾಪ್ಚರ್ ಆದ ಅದೇ ಪದಕ್ಕೆ ಮ್ಯಾಚ್ ಆಗುತ್ತದೆ.

ಉದಾಹರಣೆ 2: ಕೋಟ್ಸ್‌ನೊಳಗಿನ ಟೆಕ್ಸ್ಟ್

import re

text = "'hello' ಮತ್ತು \"world\""
# ಒಂದೇ ರೀತಿಯ ಕೋಟ್ (ಸಿಂಗಲ್ ಅಥವಾ ಡಬಲ್) ಇದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುವುದು
pattern = r"(['\"])(.*?)\1" 

matches = re.findall(pattern, text)
print(matches)

ಔಟ್‌ಪುಟ್:

[("'", 'hello'), ('"', 'world')]

ವಿವರಣೆ: * (['"]): ಸಿಂಗಲ್ ಅಥವಾ ಡಬಲ್ ಕೋಟ್ ಅನ್ನು ಕ್ಯಾಪ್ಚರ್ ಮಾಡುತ್ತದೆ (ಗ್ರೂಪ್ 1). * (.*?): ಯಾವುದೇ ಕ್ಯಾರೆಕ್ಟರ್‌ಗಳನ್ನು ನಾನ್-ಗ್ರೀಡಿ ರೀತಿಯಲ್ಲಿ ಕ್ಯಾಪ್ಚರ್ ಮಾಡುತ್ತದೆ (ಗ್ರೂಪ್ 2). * \1: ಗ್ರೂಪ್ 1 ರಲ್ಲಿ ಕ್ಯಾಪ್ಚರ್ ಆದ ಅದೇ ಕೋಟ್‌ಗೆ (ಸಿಂಗಲ್ ಅಥವಾ ಡಬಲ್) ಮ್ಯಾಚ್ ಆಗುತ್ತದೆ.