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

ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳಲ್ಲಿ ಫ್ಲ್ಯಾಗ್‌ಗಳು (Flags)

ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳ ವರ್ತನೆಯನ್ನು ಬದಲಾಯಿಸಲು re ಮಾಡ್ಯೂಲ್ ಕೆಲವು ವಿಶೇಷ ಫ್ಲ್ಯಾಗ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ಈ ಫ್ಲ್ಯಾಗ್‌ಗಳನ್ನು re.compile(), re.search(), re.findall() ಮುಂತಾದ ಫಂಕ್ಷನ್‌ಗಳಿಗೆ ಹೆಚ್ಚುವರಿ ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿ ಪಾಸ್ ಮಾಡಬಹುದು.

1. re.IGNORECASE ಅಥವಾ re.I

ಈ ಫ್ಲ್ಯಾಗ್ ಬಳಸಿದಾಗ, ಪ್ಯಾಟರ್ನ್ ಮ್ಯಾಚಿಂಗ್ ಕೇಸ್-ಇನ್‌ಸೆನ್ಸಿಟಿವ್ (case-insensitive) ಆಗುತ್ತದೆ. ಅಂದರೆ, ದೊಡ್ಡಕ್ಷರ ಮತ್ತು ಸಣ್ಣಕ್ಷರಗಳ ನಡುವೆ ವ್ಯತ್ಯಾಸವನ್ನು ಪರಿಗಣಿಸುವುದಿಲ್ಲ.

ಉದಾಹರಣೆ: 

import re

text = "Python is fun. PYTHON is powerful."
pattern = r"python"

# ಫ್ಲ್ಯಾಗ್ ಇಲ್ಲದೆ (ಕೇಸ್-ಸೆನ್ಸಿಟಿವ್)
matches1 = re.findall(pattern, text)
print(f"ಫ್ಲ್ಯಾಗ್ ಇಲ್ಲದೆ: {matches1}")

# re.IGNORECASE ಫ್ಲ್ಯಾಗ್‌ನೊಂದಿಗೆ
matches2 = re.findall(pattern, text, flags=re.IGNORECASE)
print(f"ಫ್ಲ್ಯಾಗ್‌ನೊಂದಿಗೆ: {matches2}")
ಔಟ್‌ಪುಟ್: 
ಫ್ಲ್ಯಾಗ್ ಇಲ್ಲದೆ: []
ಫ್ಲ್ಯಾಗ್‌ನೊಂದಿಗೆ: ['Python', 'PYTHON']
(ಗಮನಿಸಿ: findall ಮೂಲ ಸ್ಟ್ರಿಂಗ್‌ನಿಂದ ಮ್ಯಾಚ್ ಆದ ಭಾಗವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಪ್ಯಾಟರ್ನ್ ಅನ್ನು ಅಲ್ಲ).

2. re.MULTILINE ಅಥವಾ re.M

ಈ ಫ್ಲ್ಯಾಗ್ ಬಳಸಿದಾಗ, ^ ಮತ್ತು $ ಮೆಟಾಕ್ಯಾರೆಕ್ಟರ್‌ಗಳು ವಿಭಿನ್ನವಾಗಿ ವರ್ತಿಸುತ್ತವೆ. * ^: ಸಾಮಾನ್ಯವಾಗಿ ಸ್ಟ್ರಿಂಗ್‌ನ ಪ್ರಾರಂಭಕ್ಕೆ ಮಾತ್ರ ಮ್ಯಾಚ್ ಆಗುತ್ತದೆ. re.MULTILINE ನೊಂದಿಗೆ, ಇದು ಪ್ರತಿ ಸಾಲಿನ ಪ್ರಾರಂಭಕ್ಕೂ ಮ್ಯಾಚ್ ಆಗುತ್ತದೆ. * $: ಸಾಮಾನ್ಯವಾಗಿ ಸ್ಟ್ರಿಂಗ್‌ನ ಅಂತ್ಯಕ್ಕೆ ಮಾತ್ರ ಮ್ಯಾಚ್ ಆಗುತ್ತದೆ. re.MULTILINE ನೊಂದಿಗೆ, ಇದು ಪ್ರತಿ ಸಾಲಿನ ಅಂತ್ಯಕ್ಕೂ ಮ್ಯಾಚ್ ಆಗುತ್ತದೆ.

ಉದಾಹರಣೆ: ಪ್ರತಿ ಸಾಲಿನ ಮೊದಲ ಪದವನ್ನು ಹುಡುಕುವುದು. 

import re

text = """hello world
this is a test
another line"""

# ಪ್ರತಿ ಸಾಲಿನ ಪ್ರಾರಂಭದಲ್ಲಿರುವ ಪದವನ್ನು ಹುಡುಕುವುದು
pattern = r"^\w+"

# ಫ್ಲ್ಯಾಗ್ ಇಲ್ಲದೆ
matches1 = re.findall(pattern, text)
print(f"ಫ್ಲ್ಯಾಗ್ ಇಲ್ಲದೆ: {matches1}")

# re.MULTILINE ಫ್ಲ್ಯಾಗ್‌ನೊಂದಿಗೆ
matches2 = re.findall(pattern, text, flags=re.MULTILINE)
print(f"ಫ್ಲ್ಯಾಗ್‌ನೊಂದಿಗೆ: {matches2}")
ಔಟ್‌ಪುಟ್: 
ಫ್ಲ್ಯಾಗ್ ಇಲ್ಲದೆ: ['hello']
ಫ್ಲ್ಯಾಗ್‌ನೊಂದಿಗೆ: ['hello', 'this', 'another']

3. re.DOTALL ಅಥವಾ re.S

ಸಾಮಾನ್ಯವಾಗಿ, . (ಡಾಟ್) ಮೆಟಾಕ್ಯಾರೆಕ್ಟರ್ ನ್ಯೂಲೈನ್ (\n) ಕ್ಯಾರೆಕ್ಟರ್‌ಗೆ ಮ್ಯಾಚ್ ಆಗುವುದಿಲ್ಲ. re.DOTALL ಫ್ಲ್ಯಾಗ್ ಬಳಸಿದಾಗ, . ನ್ಯೂಲೈನ್ ಸೇರಿದಂತೆ ಯಾವುದೇ ಕ್ಯಾರೆಕ್ಟರ್‌ಗೆ ಮ್ಯಾಚ್ ಆಗುತ್ತದೆ. "DOTALL" ಎಂದರೆ ಡಾಟ್ ಎಲ್ಲದಕ್ಕೂ ಮ್ಯಾಚ್ ಆಗುತ್ತದೆ.

ಉದಾಹರಣೆ: 

import re

text = "hello\nworld"
pattern = r"hello.world"

# ಫ್ಲ್ಯಾಗ್ ಇಲ್ಲದೆ
match1 = re.search(pattern, text)
print(f"ಫ್ಲ್ಯಾಗ್ ಇಲ್ಲದೆ: {match1}")

# re.DOTALL ಫ್ಲ್ಯಾಗ್‌ನೊಂದಿಗೆ
match2 = re.search(pattern, text, flags=re.DOTALL)
print(f"ಫ್ಲ್ಯಾಗ್‌ನೊಂದಿಗೆ: {match2}")
ಔಟ್‌ಪುಟ್: 
ಫ್ಲ್ಯಾಗ್ ಇಲ್ಲದೆ: None
ಫ್ಲ್ಯಾಗ್‌ನೊಂದಿಗೆ: <re.Match object; span=(0, 11), match='hello\nworld'>

4. re.VERBOSE ಅಥವಾ re.X

ಈ ಫ್ಲ್ಯಾಗ್ ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್ ಪ್ಯಾಟರ್ನ್‌ಗಳನ್ನು ಹೆಚ್ಚು ಓದಬಲ್ಲಂತೆ (readable) ಮಾಡಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಇದು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಅನುಮತಿಸುತ್ತದೆ: * ಪ್ಯಾಟರ್ನ್‌ನಲ್ಲಿ ವೈಟ್‌ಸ್ಪೇಸ್‌ಗಳನ್ನು (spaces, newlines) ನಿರ್ಲಕ್ಷಿಸಲಾಗುತ್ತದೆ. * # ನಿಂದ ಪ್ರಾರಂಭವಾಗುವ ಕಾಮೆಂಟ್‌ಗಳನ್ನು ಪ್ಯಾಟರ್ನ್‌ನೊಳಗೆ ಸೇರಿಸಬಹುದು.

ಉದಾಹರಣೆ: ಇಮೇಲ್ ವ್ಯಾಲಿಡೇಶನ್ ಪ್ಯಾಟರ್ನ್ ಅನ್ನು re.VERBOSE ಬಳಸಿ ಬರೆಯುವುದು.

re.VERBOSE ಇಲ್ಲದೆ: 

pattern_normal = r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"

re.VERBOSE ನೊಂದಿಗೆ: 

pattern_verbose = r"""
    [a-zA-Z0-9._%+-]+  # ಬಳಕೆದಾರರ ಹೆಸರು (username)
    @                  # '@' ಸಿಂಬಲ್
    [a-zA-Z0-9.-]+     # ಡೊಮೇನ್ ಹೆಸರು (domain name)
    \.                 # '.' (ಡಾಟ್)
    [a-zA-Z]{2,}       # ಟಾಪ್-ಲೆವೆಲ್ ಡೊಮೇನ್ (e.g., com, org)
"""

text = "ನನ್ನ ಇಮೇಲ್: test.user@example.com"
match = re.search(pattern_verbose, text, flags=re.VERBOSE)
print(match)
ಔಟ್‌ಪುಟ್: 
<re.Match object; span=(12, 33), match='test.user@example.com'>
ಸಂಕೀರ್ಣ ಪ್ಯಾಟರ್ನ್‌ಗಳನ್ನು ಬರೆಯುವಾಗ re.VERBOSE ಅತ್ಯಂತ ಉಪಯುಕ್ತವಾಗಿದೆ.

ಹಲವು ಫ್ಲ್ಯಾಗ್‌ಗಳನ್ನು ಸಂಯೋಜಿಸುವುದು

ಹಲವು ಫ್ಲ್ಯಾಗ್‌ಗಳನ್ನು ಒಟ್ಟಿಗೆ ಬಳಸಲು, ಅವುಗಳ ನಡುವೆ | (ಬಿಟ್‌ವೈಸ್ OR) ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಿ.

ಉದಾಹರಣೆ: re.IGNORECASE ಮತ್ತು re.MULTILINE ಎರಡನ್ನೂ ಬಳಸುವುದು. 

import re

text = """First Line: Apple
Second Line: apple"""

pattern = r"^apple"
matches = re.findall(pattern, text, flags=re.IGNORECASE | re.MULTILINE)
print(matches)
ಔಟ್‌ಪುಟ್: 
['Apple', 'apple']
ಈ ಫ್ಲ್ಯಾಗ್‌ಗಳು ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳ ನಮ್ಯತೆಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತವೆ ಮತ್ತು ವಿವಿಧ ಸಂದರ್ಭಗಳಿಗೆ ತಕ್ಕಂತೆ ಅವುಗಳ ವರ್ತನೆಯನ್ನು ಸರಿಹೊಂದಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತವೆ.