...',"..."పైథాన్‌లో, మీరు ఈ క్రింది అక్షరాలలో ఒకదానితో ఈ స్ట్రింగ్ లిటరల్స్‌ను ప్రిఫిక్స్ చేస్తే, ఎస్కేప్ సీక్వెన్స్‌ని విస్తరించకుండా విలువ స్ట్రింగ్‌గా మారుతుంది.
rR
విండోస్ పాత్‌లు మరియు సాధారణ వ్యక్తీకరణ నమూనాలు వంటి చాలా బ్యాక్‌స్లాష్‌లను ఉపయోగించే స్ట్రింగ్‌లతో వ్యవహరించేటప్పుడు ఉపయోగకరంగా ఉంటుంది.
కింది సమాచారం ఇక్కడ అందించబడింది.
- తప్పించుకునే క్రమం
- ముడి స్ట్రింగ్‌లలో ఎస్కేప్ సీక్వెన్స్‌లను విస్మరించండి (డిసేబుల్ చేయండి).
- సాధారణ స్ట్రింగ్‌ను ముడి స్ట్రింగ్‌గా మార్చండి:
repr() - చివర బ్యాక్‌స్లాష్‌ని గమనించండి.
తప్పించుకునే క్రమం
పైథాన్‌లో, సాధారణ స్ట్రింగ్‌లో ప్రాతినిధ్యం వహించలేని అక్షరాలు (ట్యాబ్‌లు మరియు న్యూలైన్‌లు వంటివి) C లాంగ్వేజ్ మాదిరిగానే బ్యాక్‌స్లాష్‌లతో ఎస్కేప్ సీక్వెన్స్‌లను ఉపయోగించి వివరించబడ్డాయి. ఎస్కేప్ సీక్వెన్స్ యొక్క ఉదాహరణ క్రింద చూపబడింది.
\t\n
s = 'a\tb\nA\tB'
print(s)
# a b
# A B
ముడి స్ట్రింగ్‌లలో ఎస్కేప్ సీక్వెన్స్‌లను విస్మరించండి (డిసేబుల్ చేయండి).
...',"..."మీరు అటువంటి స్ట్రింగ్‌ని లిటరల్‌గా కింది వాటిలో ఒకదానితో ప్రిఫిక్స్ చేస్తే, ఎస్కేప్ సీక్వెన్స్‌ని విస్తరించకుండా విలువ స్ట్రింగ్‌గా మారుతుంది. అటువంటి తీగను ముడి స్ట్రింగ్ అంటారు.
rR
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']
విండోస్ పాత్
మీరు Windows పాత్‌ను స్ట్రింగ్‌గా సూచించాలనుకున్నప్పుడు ముడి స్ట్రింగ్‌ని ఉపయోగించడం ఉపయోగకరంగా ఉంటుంది.
విండోస్ పాత్‌లు బ్యాక్‌స్లాష్‌లతో వేరు చేయబడ్డాయి, కాబట్టి మీరు సాధారణ స్ట్రింగ్‌ని ఉపయోగిస్తే, మీరు ఈ క్రింది విధంగా మార్గం నుండి తప్పించుకోవాలి, కానీ మీరు ముడి స్ట్రింగ్‌ని ఉపయోగిస్తే, మీరు దానిని అలాగే వ్రాయవచ్చు. విలువలు సమానంగా ఉంటాయి.\\
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()ని ఉపయోగించవచ్చు.
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
చివర బ్యాక్‌స్లాష్‌ని గమనించండి.
ఒక బ్యాక్‌స్లాష్ కోటింగ్ అక్షరం తర్వాత వెంటనే తప్పించుకుంటుంది కాబట్టి, స్ట్రింగ్ చివరిలో బేసి సంఖ్యలో బ్యాక్‌స్లాష్‌లు ఉంటే ఎర్రర్ ఏర్పడుతుంది. బ్యాక్‌స్లాష్‌ల సరి సంఖ్య సరే.
# print(r'\')
# SyntaxError: EOL while scanning string literal
print(r'\\')
# \\
# print(r'\\\')
# SyntaxError: EOL while scanning string literal
