ರಾ ಸ್ಟ್ರಿಂಗ್‌ಗಳು (Raw Strings)

ಪೈಥಾನ್‌ನಲ್ಲಿ, ರಾ ಸ್ಟ್ರಿಂಗ್ (Raw String) ಎಂದರೆ ಎಸ್ಕೇಪ್ ಸೀಕ್ವೆನ್ಸ್‌ಗಳನ್ನು (\n, \t, \\ ಇತ್ಯಾದಿ) ಅವುಗಳ ವಿಶೇಷ ಅರ್ಥದಲ್ಲಿ ಪರಿಗಣಿಸದ ಒಂದು ರೀತಿಯ ಸ್ಟ್ರಿಂಗ್. ರಾ ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ, ಬ್ಯಾಕ್‌ಸ್ಲ್ಯಾಶ್ (\) ಕೇವಲ ಒಂದು ಸಾಮಾನ್ಯ ಅಕ್ಷರವಾಗಿ ಪರಿಗಣಿಸಲ್ಪಡುತ್ತದೆ.

ರಾ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಸ್ಟ್ರಿಂಗ್‌ನ ಪ್ರಾರಂಭದಲ್ಲಿ r ಅಥವಾ R ಅಕ್ಷರವನ್ನು ಇರಿಸುವ ಮೂಲಕ ರಚಿಸಲಾಗುತ್ತದೆ.

ರಾ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಏಕೆ ಬಳಸಬೇಕು?

ಎಸ್ಕೇಪ್ ಸೀಕ್ವೆನ್ಸ್‌ಗಳು ವಿಶೇಷ ಅರ್ಥವನ್ನು ಹೊಂದಿರುವ ಸಂದರ್ಭಗಳಲ್ಲಿ, ಅವುಗಳನ್ನು ಅಕ್ಷರಶಃ (literally) ಬಳಸಬೇಕಾದಾಗ ರಾ ಸ್ಟ್ರಿಂಗ್‌ಗಳು ಅತ್ಯಂತ ಉಪಯುಕ್ತ.

1. ಫೈಲ್ ಪಾತ್‌ಗಳು (File Paths)

ವಿಂಡೋಸ್ ಫೈಲ್ ಸಿಸ್ಟಮ್ ಪಾತ್‌ಗಳಲ್ಲಿ ಬ್ಯಾಕ್‌ಸ್ಲ್ಯಾಶ್ (\) ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಸಾಮಾನ್ಯ ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ, ಪ್ರತಿ ಬ್ಯಾಕ್‌ಸ್ಲ್ಯಾಶ್ ಅನ್ನು ಎಸ್ಕೇಪ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ (\\).

ಸಾಮಾನ್ಯ ಸ್ಟ್ರಿಂಗ್:

path = "C:\\Users\\Nishkala\\Documents"
print(path)

ರಾ ಸ್ಟ್ರಿಂಗ್ (ಉತ್ತಮ ವಿಧಾನ):

raw_path = r"C:\Users\Nishkala\Documents"
print(raw_path)

ಎರಡೂ ಒಂದೇ ಔಟ್‌ಪುಟ್ (C:\Users\Nishkala\Documents) ಅನ್ನು ನೀಡುತ್ತವೆ, ಆದರೆ ರಾ ಸ್ಟ್ರಿಂಗ್ ಹೆಚ್ಚು ಓದಬಲ್ಲದು ಮತ್ತು ಬರೆಯಲು ಸುಲಭ.

2. ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳು (Regular Expressions)

ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳಲ್ಲಿ (RegEx) ಬ್ಯಾಕ್‌ಸ್ಲ್ಯಾಶ್ ಅನ್ನು ಮೆಟಾ-ಕ್ಯಾರೆಕ್ಟರ್‌ಗಳನ್ನು (\d, \w, \s ಇತ್ಯಾದಿ) ಡಿಫೈನ್ ಮಾಡಲು ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ರಾ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಬಳಸುವುದರಿಂದ, ಪೈಥಾನ್ ಇಂಟರ್‌ಪ್ರಿಟರ್ ಮತ್ತು RegEx ಇಂಜಿನ್ ನಡುವಿನ ಸಂಘರ್ಷವನ್ನು ತಪ್ಪಿಸಬಹುದು.

ಸಾಮಾನ್ಯ ಸ್ಟ್ರಿಂಗ್ (ತಪ್ಪಾಗುವ ಸಾಧ್ಯತೆ ಹೆಚ್ಚು):

import re
# ಇಲ್ಲಿ '\\d' ಅನ್ನು ಬಳಸಬೇಕು ಏಕೆಂದರೆ ಒಂದು '\' ಅನ್ನು ಪೈಥಾನ್ ಎಸ್ಕೇಪ್ ಮಾಡುತ್ತದೆ
pattern = "\\d{3}-\\d{4}"

ರಾ ಸ್ಟ್ರಿಂಗ್ (ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ):

import re
pattern = r"\d{3}-\d{4}" # RegEx ಇಂಜಿನ್‌ಗೆ ನೇರವಾಗಿ '\d' ಸಿಗುತ್ತದೆ
text = "ನನ್ನ ಫೋನ್ ಸಂಖ್ಯೆ 123-4567."
match = re.search(pattern, text)
if match:
    print(f"ಸಂಖ್ಯೆ ಕಂಡುಬಂದಿದೆ: {match.group()}")

ಸಿಂಟ್ಯಾಕ್ಸ್

ರಾ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಏಕ, ದ್ವಿ, ಅಥವಾ ತ್ರಿವಳಿ ಉಲ್ಲೇಖಗಳೊಂದಿಗೆ ಬಳಸಬಹುದು.

r'...'
r"..."
r'''...'''
r"""..."""

ಉದಾಹರಣೆ:

raw_multiline = r"""
ಇದು ಒಂದು ರಾ ಸ್ಟ್ರಿಂಗ್.
ಇಲ್ಲಿ \n ಮತ್ತು \t ಗಳು ವಿಶೇಷ ಅರ್ಥವನ್ನು ಹೊಂದಿಲ್ಲ.
ಅವು ಕೇವಲ ಅಕ್ಷರಗಳಾಗಿ ಪ್ರಿಂಟ್ ಆಗುತ್ತವೆ.
"""
print(raw_multiline)

ಒಂದು ಮಿತಿ (A Limitation)

ಒಂದು ರಾ ಸ್ಟ್ರಿಂಗ್ ಬ್ಯಾಕ್‌ಸ್ಲ್ಯಾಶ್‌ನಿಂದ ಕೊನೆಗೊಳ್ಳುವಂತಿಲ್ಲ.

# invalid_string = r"This ends with a backslash\" # SyntaxError

ಇದನ್ನು ತಪ್ಪಿಸಲು, ನೀವು ಬ್ಯಾಕ್‌ಸ್ಲ್ಯಾಶ್ ಅನ್ನು ಸ್ಟ್ರಿಂಗ್‌ನ ಹೊರಗೆ ಸೇರಿಸಬಹುದು:

valid_string = r"This ends with a backslash" + "\\"
print(valid_string)

ಸಾರಾಂಶದಲ್ಲಿ, ನಿಮ್ಮ ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ಬ್ಯಾಕ್‌ಸ್ಲ್ಯಾಶ್‌ಗಳು ಹೆಚ್ಚಾಗಿದ್ದಾಗ ಮತ್ತು ಅವುಗಳನ್ನು ಅಕ್ಷರಶಃ ಬಳಸಬೇಕಾದಾಗ, ರಾ ಸ್ಟ್ರಿಂಗ್‌ಗಳು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ಸ್ವಚ್ಛ ಮತ್ತು ದೋಷ-ಮುಕ್ತವಾಗಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತವೆ.