Python တွင် အကြမ်းကြိုးများပါသော လွတ်မြောက်မှု အစီအစဉ်များကို လျစ်လျူရှုခြင်း (ပိတ်ခြင်း)

...'၊"..."Python တွင်၊ အောက်ပါအက္ခရာများအနက်မှ စာလုံးတစ်လုံးဖြင့် ဤ string literals ကို ရှေ့ဆက်မည်ဆိုပါက၊ value သည် escape sequence ကို တိုးချဲ့ခြင်းမပြုဘဲ string တစ်ခု ဖြစ်လာပါမည်။

• r
• R

Windows လမ်းကြောင်းများနှင့် ပုံမှန်ဖော်ပြမှုပုံစံများကဲ့သို့သော backslash အများအပြားကိုအသုံးပြုသည့် စာကြောင်းများနှင့် ကိုင်တွယ်ရာတွင် အသုံးဝင်သည်။
အောက်ပါအချက်အလက်များကို ဤနေရာတွင် ဖော်ပြပေးထားပါသည်။

• လွတ်မြောက်မှု အစီအစဥ်
• ကြိုးအကြမ်းများတွင် လွတ်မြောက်ခြင်း အစီအစဉ်များကို လျစ်လျူရှု (ပိတ်ပါ)
• ပုံမှန် string ကို အကြမ်း string သို့ ပြောင်းပါ။:repr()
• အဆုံးတွင် backslash ကိုမှတ်သားပါ။

လွတ်မြောက်မှု အစီအစဥ်

Python တွင်၊ ပုံမှန်စာကြောင်းတစ်ခုတွင် ကိုယ်စားပြုမရနိုင်သော အက္ခရာများ (တဘ်များနှင့် စာကြောင်းအသစ်များကဲ့သို့) ကို C language နှင့် ဆင်တူသော backslashes များဖြင့် escape sequences များကို အသုံးပြု၍ ဖော်ပြထားပါသည်။ Escape sequence ၏ ဥပမာကို အောက်တွင် ပြထားသည်။

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

ကြိုးအကြမ်းများတွင် လွတ်မြောက်ခြင်း အစီအစဉ်များကို လျစ်လျူရှု (ပိတ်ပါ)

...'၊"..."အကယ်၍ သင်သည် အောက်ပါများထဲမှ တစ်ခုနှင့် စာလုံးတစ်လုံးကို စာသားအတိုင်း ရှေ့ဆက်ပါက၊ တန်ဖိုးသည် Escape sequence ကို တိုးချဲ့ခြင်းမပြုဘဲ string တစ်ခု ဖြစ်လာပါမည်။ ထိုသို့သောကြိုးကို အကြမ်းကြိုးဟုခေါ်သည်။

• r
• R

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

raw string type ဟုခေါ်သော အထူးအမျိုးအစားမရှိပါ၊ ၎င်းသည် string type တစ်ခုမျှသာဖြစ်ပြီး အောက်ပါအတိုင်း backslash ကိုယ်စားပြုထားသော ပုံမှန်စာကြောင်းနှင့် ညီမျှသည်
\\

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

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

ပုံမှန် string တစ်ခုတွင်၊ escape sequence ကို စာလုံးတစ်လုံးတည်းဟု ယူဆသော်လည်း အကြမ်း string တစ်ခုတွင် backslashes များကို ဇာတ်ကောင်များအဖြစ်လည်း ရေတွက်ပါသည်။ စာကြောင်း၏အရှည်နှင့် စာလုံးတစ်ခုစီသည် အောက်ပါအတိုင်းဖြစ်သည်။

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 လမ်းကြောင်း

Windows လမ်းကြောင်းကို string တစ်ခုအဖြစ် ကိုယ်စားပြုလိုသည့်အခါ အကြမ်းကြိုးကို အသုံးပြုခြင်းသည် အသုံးဝင်သည်။

Windows လမ်းကြောင်းများကို backslashes များဖြင့် ပိုင်းခြားထားသောကြောင့် ပုံမှန် string ကိုအသုံးပြုပါက အောက်ပါအတိုင်း လမ်းကြောင်းမှ လွတ်မြောက်ရန် လိုအပ်သော်လည်း raw string ကိုအသုံးပြုပါက ၎င်းကို မူရင်းအတိုင်း ရေးနိုင်ပါသည်။ တန်ဖိုးများသည် တူညီသည်။
\\

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

အောက်ဖော်ပြပါအတိုင်း ထူးဆန်းသော backslashes အရေအတွက်ဖြင့် အဆုံးသတ်သော စာကြောင်းတစ်ခုသည် အမှားအယွင်းဖြစ်သွားသည်ကို သတိပြုပါ။ ဤကိစ္စတွင်၊ ကြိုးတစ်ချောင်းကို ပုံမှန်စာကြောင်းအဖြစ် ရေးရန် လိုအပ်သည်၊ သို့မဟုတ် ကြိုး၏အဆုံးကိုသာ ပုံမှန်စာကြောင်းအဖြစ် ရေးခြင်းဖြင့် ၎င်းကို ပေါင်းစပ်ရန် လိုအပ်သည်။

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() ဖြင့် အကြမ်းကြိုးများအဖြစ် ပြောင်းပါ

ပုံမှန် string ကို လျစ်လျူရှုခြင်း (ပိတ်ခြင်း) လွတ်မြောက်ခြင်း အတွဲများကို အကြမ်းမျဉ်းအဖြစ်သို့ ပြောင်းလဲလိုပါက၊ built-in လုပ်ဆောင်ချက် 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 သည် ၎င်းပြီးနောက် ကိုးကားထားသော စာလုံးကို ချက်ချင်း လွတ်သွားသည့်အတွက်၊ string ၏ အဆုံးတွင် ထူးဆန်းသော 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