ਕੱਚੀਆਂ ਸਤਰਾਂ ਨਾਲ ਪਾਈਥਨ ਵਿੱਚ ਬਚਣ ਦੇ ਕ੍ਰਮ ਨੂੰ ਅਣਡਿੱਠ ਕਰਨਾ (ਅਯੋਗ ਕਰਨਾ)

...',"..."ਪਾਈਥਨ ਵਿੱਚ, ਜੇਕਰ ਤੁਸੀਂ ਇਹਨਾਂ ਸਟ੍ਰਿੰਗ ਲਿਟਰਲ ਨੂੰ ਅੱਗੇ ਦਿੱਤੇ ਅੱਖਰਾਂ ਵਿੱਚੋਂ ਇੱਕ ਨਾਲ ਜੋੜਦੇ ਹੋ, ਤਾਂ ਮੁੱਲ ਬਚਣ ਦੇ ਕ੍ਰਮ ਨੂੰ ਫੈਲਾਏ ਬਿਨਾਂ ਇੱਕ ਸਤਰ ਬਣ ਜਾਵੇਗਾ।

• r
• R

ਬਹੁਤ ਸਾਰੀਆਂ ਬੈਕਸਲੈਸ਼ਾਂ, ਜਿਵੇਂ ਕਿ ਵਿੰਡੋਜ਼ ਪਾਥ ਅਤੇ ਨਿਯਮਤ ਸਮੀਕਰਨ ਪੈਟਰਨ ਦੀ ਵਰਤੋਂ ਕਰਨ ਵਾਲੀਆਂ ਸਤਰਾਂ ਨਾਲ ਨਜਿੱਠਣ ਵੇਲੇ ਉਪਯੋਗੀ।
ਹੇਠਾਂ ਦਿੱਤੀ ਜਾਣਕਾਰੀ ਇੱਥੇ ਦਿੱਤੀ ਗਈ ਹੈ।

• ਬਚਣ ਦਾ ਕ੍ਰਮ
• ਕੱਚੀਆਂ ਸਤਰਾਂ ਵਿੱਚ ਬਚਣ ਦੇ ਕ੍ਰਮ ਨੂੰ ਅਣਡਿੱਠ ਕਰੋ (ਅਯੋਗ)
• ਸਧਾਰਣ ਸਟ੍ਰਿੰਗ ਨੂੰ ਕੱਚੀ ਸਤਰ ਵਿੱਚ ਬਦਲੋ:repr()
• ਅੰਤ ਵਿੱਚ ਬੈਕਸਲੈਸ਼ ਨੂੰ ਨੋਟ ਕਰੋ।

ਬਚਣ ਦਾ ਕ੍ਰਮ

ਪਾਈਥਨ ਵਿੱਚ, ਅੱਖਰ ਜੋ ਇੱਕ ਸਧਾਰਨ ਸਤਰ ਵਿੱਚ ਨਹੀਂ ਦਰਸਾਏ ਜਾ ਸਕਦੇ ਹਨ (ਜਿਵੇਂ ਕਿ ਟੈਬਸ ਅਤੇ ਨਵੀਆਂ ਲਾਈਨਾਂ) ਨੂੰ ਸੀ ਭਾਸ਼ਾ ਵਾਂਗ, ਬੈਕਸਲੈਸ਼ਾਂ ਦੇ ਨਾਲ ਐਸਕੇਪ ਕ੍ਰਮ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵਰਣਨ ਕੀਤਾ ਗਿਆ ਹੈ। ਇੱਕ ਬਚਣ ਦੇ ਕ੍ਰਮ ਦੀ ਇੱਕ ਉਦਾਹਰਨ ਹੇਠਾਂ ਦਿਖਾਈ ਗਈ ਹੈ।

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

ਇੱਥੇ ਕੋਈ ਖਾਸ ਕਿਸਮ ਨਹੀਂ ਹੈ ਜਿਸਨੂੰ ਕੱਚੀ ਸਟ੍ਰਿੰਗ ਕਿਸਮ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਇਹ ਸਿਰਫ਼ ਇੱਕ ਸਟ੍ਰਿੰਗ ਕਿਸਮ ਹੈ ਅਤੇ ਇੱਕ ਬੈਕਸਲੈਸ਼ ਦੇ ਨਾਲ ਇੱਕ ਸਧਾਰਨ ਸਤਰ ਦੇ ਬਰਾਬਰ ਹੈ ਜਿਸ ਨੂੰ ਹੇਠਾਂ ਦਰਸਾਇਆ ਗਿਆ ਹੈ
\\

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

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

ਅੰਤ ਵਿੱਚ ਬੈਕਸਲੈਸ਼ ਨੂੰ ਨੋਟ ਕਰੋ।

ਕਿਉਂਕਿ ਇੱਕ ਬੈਕਸਲੈਸ਼ ਇਸਦੇ ਤੁਰੰਤ ਬਾਅਦ ਹਵਾਲਾ ਦੇਣ ਵਾਲੇ ਅੱਖਰ ਤੋਂ ਬਚ ਜਾਂਦਾ ਹੈ, ਜੇਕਰ ਸਤਰ ਦੇ ਅੰਤ ਵਿੱਚ ਬੈਕਸਲੈਸ਼ਾਂ ਦੀ ਇੱਕ ਅਜੀਬ ਸੰਖਿਆ ਹੋਵੇ ਤਾਂ ਇੱਕ ਗਲਤੀ ਆਵੇਗੀ। ਬੈਕਸਲੈਸ਼ਾਂ ਦੀ ਇੱਕ ਬਰਾਬਰ ਸੰਖਿਆ ਠੀਕ ਹੈ।

• 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