අමු නූල් සමඟ පයිතන් හි ගැලවීමේ අනුපිළිවෙල නොසලකා හැරීම (අබල කිරීම).

...',"..."Python හි, ඔබ පහත අක්ෂර වලින් එකක් සමඟ මෙම තන්තු වචන උපසර්ගය නම්, ගැලවීමේ අනුපිළිවෙල පුළුල් නොකර අගය තන්තුවක් බවට පත්වේ.

• r
• R

වින්ඩෝස් මාර්ග සහ සාමාන්‍ය ප්‍රකාශන රටා වැනි බොහෝ පසුතල භාවිතා කරන නූල් සමඟ ගනුදෙනු කිරීමේදී ප්‍රයෝජනවත් වේ.
පහත තොරතුරු මෙහි දක්වා ඇත.

• ගැලවීමේ අනුපිළිවෙල
• අමු තන්තු වල ගැලවීමේ අනුපිළිවෙල නොසලකා හරින්න (අක්‍රිය කරන්න).
• සාමාන්‍ය තන්තුව අමු නූල් බවට පරිවර්තනය කරන්න:repr()
• අවසානයේ ඇති backslash සටහන් කරන්න.

ගැලවීමේ අනුපිළිවෙල

Python හි, සාමාන්‍ය තන්තුවකින් නිරූපණය කළ නොහැකි අක්ෂර (ටැබ් සහ නව රේඛා වැනි) C භාෂාවට සමාන backslashes සමඟ ගැලවීමේ අනුපිළිවෙල භාවිතයෙන් විස්තර කෙරේ. ගැලවීමේ අනුපිළිවෙලක උදාහරණයක් පහත දැක්වේ.

• \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

අමු තන්තු වල ගැලවීමේ අනුපිළිවෙල නොසලකා හරින්න (අක්‍රිය කරන්න).

...',"..."ඔබ එවැනි තන්තුවක් පහත සඳහන් එකකින් වචනාර්ථයෙන් උපසර්ගය කළහොත්, ගැලවීමේ අනුක්‍රමය පුළුල් නොකර අගය තන්තුවක් බවට පත්වේ. එවැනි නූලක් raw string ලෙස හැඳින්වේ.

• r
• R

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

raw string type නමින් විශේෂ වර්ගයක් නොමැත, එය තන්තු වර්ගයක් පමණක් වන අතර පහත දැක්වෙන පරිදි backslash එකක් සහිත සාමාන්‍ය තන්තුවකට සමාන වේ.
\\

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']

වින්ඩෝස් මාර්ගය

ඔබට වින්ඩෝස් මාර්ගයක් තන්තුවක් ලෙස නිරූපණය කිරීමට අවශ්‍ය විට අමු තන්තුව භාවිතා කිරීම ප්‍රයෝජනවත් වේ.

Windows paths backslashes වලින් වෙන් කර ඇති නිසා සාමාන්‍ය string එකක් භාවිතා කරන්නේ නම් පහත ආකාරයට මාර්ගයෙන් බේරීමට සිදු වේ, නමුත් ඔබ raw string එකක් භාවිතා කරන්නේ නම් එය එලෙසම ලිවිය හැක. අගයන් සමාන වේ.
\\

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

repr() සමඟ සාමාන්‍ය නූල් අමු නූල් බවට පරිවර්තනය කරන්න

ඔබට සාමාන්‍ය තන්තුවක් ගැලවීමේ අනුපිළිවෙල නොසලකා හරිමින් (අක්‍රිය කරන) අමු තන්තුවක් බවට පරිවර්තනය කිරීමට අවශ්‍ය නම්, ඔබට ගොඩනඟන ලද කාර්යය 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

අවසානයේ ඇති backslash සටහන් කරන්න.

උපුටන අක්ෂරයෙන් පසු ඉක්බිතිව backslash එකක් ගැලවී යන බැවින්, තන්තුවේ අවසානයේ ඔත්තේ සංඛ්‍යාවක් backslashes තිබේ නම් දෝෂයක් ඇතිවේ. ඉරට්ටේ ඉරට්ටේ ගණනක් හරි.

• 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