કાચા શબ્દમાળાઓ સાથે પાયથોનમાં એસ્કેપ સિક્વન્સને અવગણવું (અક્ષમ કરવું).

...',"..."પાયથોનમાં, જો તમે નીચેનામાંથી એક અક્ષર સાથે આ સ્ટ્રિંગ લિટરલ્સનો ઉપસર્ગ કરો છો, તો મૂલ્ય એસ્કેપ સિક્વન્સને વિસ્તૃત કર્યા વિના સ્ટ્રિંગ બની જશે.

• r
• R

ઘણી બધી બેકસ્લેશનો ઉપયોગ કરતી સ્ટ્રિંગ્સ સાથે કામ કરતી વખતે ઉપયોગી, જેમ કે Windows પાથ અને રેગ્યુલર એક્સપ્રેશન પેટર્ન.
નીચેની માહિતી અહીં આપવામાં આવી છે.

• એસ્કેપ ક્રમ
• કાચા શબ્દમાળાઓમાં એસ્કેપ સિક્વન્સને અવગણો (અક્ષમ કરો).
• સામાન્ય સ્ટ્રિંગને કાચી સ્ટ્રિંગમાં કન્વર્ટ કરો:repr()
• અંતે બેકસ્લેશ નોંધો.

એસ્કેપ ક્રમ

પાયથોનમાં, અક્ષરો કે જે સામાન્ય સ્ટ્રિંગમાં રજૂ કરી શકાતા નથી (જેમ કે ટૅબ્સ અને નવી લાઇન્સ) 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

કાચો શબ્દમાળા પ્રકાર તરીકે ઓળખાતો કોઈ વિશેષ પ્રકાર નથી, તે માત્ર એક શબ્દમાળા પ્રકાર છે અને નીચે પ્રમાણે રજૂ કરાયેલ બેકસ્લેશ સાથે સામાન્ય સ્ટ્રિંગની બરાબર છે.
\\

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