பைத்தானில் மூல சரங்களைக் கொண்டு தப்பிக்கும் தொடர்களை புறக்கணித்தல் (முடக்குதல்).

...',"..."Python இல், பின்வரும் எழுத்துகளில் ஒன்றின் மூலம் இந்த ஸ்டிரிங் லிட்டரல்களை முன்னொட்டினால், தப்பிக்கும் வரிசையை விரிவாக்காமல் மதிப்பு ஒரு சரமாக மாறும்.

• r
• R

விண்டோஸ் பாதைகள் மற்றும் வழக்கமான வெளிப்பாடு வடிவங்கள் போன்ற பல பின்சாய்வுகளைப் பயன்படுத்தும் சரங்களைக் கையாளும் போது பயனுள்ளதாக இருக்கும்.
பின்வரும் தகவல்கள் இங்கே கொடுக்கப்பட்டுள்ளன.

• தப்பிக்கும் வரிசை
• மூல சரங்களில் தப்பிக்கும் தொடர்களை புறக்கணிக்கவும் (முடக்கவும்).
• சாதாரண சரத்தை மூல சரமாக மாற்றவும்:repr()
• இறுதியில் பின்னிணைப்பைக் கவனியுங்கள்.

தப்பிக்கும் வரிசை

Python இல், ஒரு சாதாரண சரத்தில் (தாவல்கள் மற்றும் புதிய வரிகள் போன்றவை) குறிப்பிட முடியாத எழுத்துக்கள், C மொழியைப் போலவே பின்சாய்வுகளுடன் தப்பிக்கும் தொடர்களைப் பயன்படுத்தி விவரிக்கப்படுகின்றன. தப்பிக்கும் வரிசையின் உதாரணம் கீழே காட்டப்பட்டுள்ளது.

• \t
• \n

• 2.4.1. String and Bytes literals — Lexical analysis — Python 3.10.2 Documentation

s = 'a\tb\nA\tB'
print(s)
# a b
# A B

மூல சரங்களில் தப்பிக்கும் தொடர்களை புறக்கணிக்கவும் (முடக்கவும்).

...',"..."பின்வருவனவற்றில் ஒன்றின் மூலம் அத்தகைய சரத்தை முன்னொட்டாக இணைத்தால், தப்பிக்கும் வரிசையை விரிவாக்காமல் மதிப்பு ஒரு சரமாக மாறும். அத்தகைய சரம் ஒரு மூல சரம் என்று அழைக்கப்படுகிறது.

• r
• R

rs = r'a\tb\nA\tB'
print(rs)
# a\tb\nA\tB

raw string type என்று அழைக்கப்படும் சிறப்பு வகை எதுவும் இல்லை, இது ஒரு சரம் வகை மற்றும் பின்சாய்வு கொண்ட ஒரு சாதாரண சரத்திற்கு சமமாக பின்வருமாறு குறிப்பிடப்படுகிறது
\\

print(type(rs))
# <class 'str'>

print(rs == 'a\\tb\\nA\\tB')
# True

ஒரு சாதாரண சரத்தில், தப்பிக்கும் வரிசை ஒரு எழுத்தாகக் கருதப்படுகிறது, ஆனால் ஒரு மூல சரத்தில், பின்சாய்வுகளும் எழுத்துக்களாகக் கணக்கிடப்படுகின்றன. சரத்தின் நீளம் மற்றும் ஒவ்வொரு எழுத்தும் பின்வருமாறு.

print(len(s))
# 7

print(list(s))
# ['a', '\t', 'b', '\n', 'A', '\t', 'B']

print(len(rs))
# 10

print(list(rs))
# ['a', '\\', 't', 'b', '\\', 'n', 'A', '\\', 't', 'B']

விண்டோஸ் பாதை

நீங்கள் விண்டோஸ் பாதையை ஒரு சரமாகப் பிரதிநிதித்துவப்படுத்த விரும்பினால், மூல சரத்தைப் பயன்படுத்துவது பயனுள்ளதாக இருக்கும்.

விண்டோஸ் பாதைகள் பின்சாய்வுகளால் பிரிக்கப்படுகின்றன, எனவே நீங்கள் ஒரு சாதாரண சரத்தைப் பயன்படுத்தினால், நீங்கள் பின்வரும் பாதையில் தப்பிக்க வேண்டும், ஆனால் நீங்கள் ஒரு மூல சரத்தைப் பயன்படுத்தினால், அதை அப்படியே எழுதலாம். மதிப்புகள் சமமானவை.
\\

path = 'C:\\Windows\\system32\\cmd.exe'
rpath = r'C:\Windows\system32\cmd.exe'
print(path == rpath)
# True

கீழே விவரிக்கப்பட்டுள்ளபடி ஒற்றைப்படை எண்ணிக்கையிலான பின்சாய்வுகளுடன் முடிவடையும் சரம் பிழையை ஏற்படுத்தும் என்பதை நினைவில் கொள்ளவும். இந்த வழக்கில், சரத்தை ஒரு சாதாரண சரமாக எழுதுவது அவசியம், அல்லது சரத்தின் முடிவை மட்டும் சாதாரண சரமாக எழுதுவதன் மூலம் அதை இணைக்க வேண்டும்.

path2 = 'C:\\Windows\\system32\\'
# rpath2 = r'C:\Windows\system32\'
# SyntaxError: EOL while scanning string literal
rpath2 = r'C:\Windows\system32' + '\\'
print(path2 == rpath2)
# True

rep() மூலம் சாதாரண சரங்களை மூல சரங்களாக மாற்றவும்

தப்பிக்கும் தொடர்களைப் புறக்கணித்து (முடக்குதல்) ஒரு சாதாரண சரத்தை மூல சரமாக மாற்ற விரும்பினால், நீங்கள் உள்ளமைக்கப்பட்ட செயல்பாடு repr() ஐப் பயன்படுத்தலாம்.

• repr(object) — Built-in Functions — Python 3.10.2 Documentation

s_r = repr(s)
print(s_r)
# 'a\tb\nA\tB'

repr() என்பது ஒரு பொருளைக் குறிக்கும் சரம் ஆகும், அது முன்னணி மற்றும் பின்தங்கிய எழுத்துகளுடன் eval() க்கு அனுப்பப்பட்ட அதே மதிப்பைக் கொண்டிருக்கும்.

print(list(s_r))
# ["'", 'a', '\\', 't', 'b', '\\', 'n', 'A', '\\', 't', 'B', "'"]

துண்டுகளைப் பயன்படுத்தி, r இணைக்கப்பட்ட மூல சரத்திற்கு சமமான சரத்தை நாம் பெறலாம்.

s_r2 = repr(s)[1:-1]
print(s_r2)
# a\tb\nA\tB

print(s_r2 == rs)
# True

print(r'\t' == repr('\t')[1:-1])
# True

இறுதியில் பின்னிணைப்பைக் கவனியுங்கள்.

ஒரு பின்சாய்வு அதன் பின் உடனடியாக மேற்கோள் எழுத்திலிருந்து தப்பித்துவிடும் என்பதால், சரத்தின் முடிவில் ஒற்றைப்படை எண்ணிக்கையிலான பின்சாய்வுகள் இருந்தால் பிழை ஏற்படும். பின்சாய்வுகளின் இரட்டை எண்ணிக்கை சரி.

• Why can’t raw strings (r-strings) end with a backslash? — Design and History FAQ — Python 3.10.2 Documentation

# print(r'\')
# SyntaxError: EOL while scanning string literal

print(r'\\')
# \\

# print(r'\\\')
# SyntaxError: EOL while scanning string literal