Python တွင် လိုင်းအသစ်များပါရှိသော စာကြောင်းများကို ထုတ်ခြင်း၊ ပေါင်းစပ်ခြင်း၊ ခွဲခြင်း၊ ဖျက်ခြင်းနှင့် အစားထိုးပါ။

အောက်ပါတို့သည် Python တွင် လိုင်းအသစ်များပါရှိသော စာကြောင်းများ၏ လုပ်ဆောင်မှုကို ဖော်ပြသည်။

• လိုင်းအသစ်များပါရှိသော စာကြောင်းကို ဖန်တီးပါ၊ ပရင့်ထုတ်ရန် (ပြသမှု)
  • လိုင်းအသစ်အက္ခရာ (စနစ်ပေါ်မူတည်၍ CR နှင့် LF နှစ်မျိုးလုံး သို့မဟုတ်)\n(LF)၊\r\n(CR+LF)
  • သုံးဆကိုးကား''၊"""
  • အင်တင်းလုပ်လိုပါက
• လိုင်းအသစ်များဖြင့် လိုင်းများစာရင်းကို ပေါင်းစပ်ပါ။
• စာကြောင်းအသစ်များနှင့် စာရင်းသို့ ခွဲပါ။:splitlines()
• လိုင်းဖိဒ်ကုဒ်များကို ဖယ်ရှားပြီး အစားထိုးပါ။
• လိုင်းအသစ်ကို နောက်မလိုက်ဘဲ ပရင့်ထုတ်ပါ။

လိုင်းအသစ်များပါရှိသော စာကြောင်းကို ဖန်တီးပါ၊ အထွက်ကို ပရင့်ထုတ်ပါ။

လိုင်းအသစ်အက္ခရာ (စနစ်ပေါ်မူတည်၍ CR နှင့် LF နှစ်မျိုးလုံး သို့မဟုတ်)\n(LF)၊\r\n(CR+LF)

စာကြောင်းတစ်ခုအတွင်း မျဉ်းစာဖိဒ်ကုဒ်ကို ထည့်သွင်းခြင်းသည် လိုင်းအသစ်တစ်ခု ဖြစ်ပေါ်မည်ဖြစ်သည်။

s = 'Line1\nLine2\nLine3'
print(s)
# Line1
# Line2
# Line3

s = 'Line1\r\nLine2\r\nLine3'
print(s)
# Line1
# Line2
# Line3

Line feed ကုဒ်များကို အောက်ပါနည်းလမ်းများဖြင့် အသုံးပြုနိုင်ပါသည်။ တည်းဖြတ်သူအချို့က သင့်အား လိုင်းခွဲကုဒ်ကို ရွေးချယ်ခွင့်ပြုသည်။

သုံးဆကိုးကား''၊"""

စာကြောင်းကို ဖုံးကွယ်ရန် သုံးဆကိုးကားများကို အသုံးပြုပါက၊ ၎င်းသည် လိုင်းအသစ်များအပါအဝင် ယခင်ကဲ့သို့ မျဉ်းတစ်ကြောင်းဖြစ်လိမ့်မည်။

s = '''Line1
Line2
Line3'''
print(s)
# Line1
# Line2
# Line3

အင်တင်းလုပ်လိုပါက

Triple quotes များသည် စာကြောင်းတစ်ခုတွင် space များဖြစ်သည်၊ ထို့ကြောင့် အောက်တွင်ပြထားသည့်အတိုင်း code တွင် သေသေသပ်သပ်ရေးပြီး အင်တင်းရေးရန်ကြိုးစားပါက၊ မလိုအပ်သော space များကို ထည့်သွင်းပါမည်။

s = '''
    Line1
    Line2
    Line3
    '''
print(s)
# 
#     Line1
#     Line2
#     Line3
#     

ကုဒ်ရှိ လိုင်းအသစ်များကို လျစ်လျူရှုပြီး ၎င်းအား ဆက်ရန်မျဉ်းအဖြစ် ပြုလုပ်ရန် backslash ကို အသုံးပြုခြင်းဖြင့်၊ ၎င်းကို အောက်ပါအတိုင်း ရေးသားနိုင်သည်။

စာကြောင်းတစ်ခုစီကို ” သို့မဟုတ် “ ” ဖြင့် ဖြည့်ပြီး ဝါကျအဆုံးတွင် စာလုံးအသစ် ←n ကို ထည့်ပါ။

s = 'Line1\n'\
    'Line2\n'\
    'Line3'
print(s)
# Line1
# Line2
# Line3

ဤတွင်၊ syntax သည် string literals အဆက်ဆက်ကို ပေါင်းစပ်ထားခြင်းဖြစ်သည်။ အသေးစိတ်အတွက် အောက်ပါဆောင်းပါးကို ကြည့်ပါ။

• ဆက်စပ်ဆောင်းပါးများ:Python တွင် စာကြောင်းများ ပေါင်းစပ်ခြင်းနှင့် ချိတ်ဆက်ခြင်း (+ အော်ပရေတာ၊ ချိတ်ဆက်ရန် စသည်ဖြင့်)

string တစ်ခုတွင် indentation ထည့်လိုပါက လိုင်းတစ်ခုစီရှိ string တွင် space တစ်ခုထည့်ရုံသာဖြစ်သည်။

s = 'Line1\n'\
    '    Line2\n'\
    '        Line3'
print(s)
# Line1
#     Line2
#         Line3

ထို့အပြင်၊ မျဉ်းကွက်များကို ကွင်းပိတ်များဖြင့် လွတ်လွတ်လပ်လပ် ပြုလုပ်နိုင်သောကြောင့်၊ အောက်ဖော်ပြပါကို ကွင်းပိတ်များသုံးပြီး backslashes များကို အသုံးပြု၍ ရေးသားနိုင်ပါသည်။

s = ('Line1\n'
     'Line2\n'
     'Line3')
print(s)
# Line1
# Line2
# Line3

s = ('Line1\n'
     '    Line2\n'
     '        Line3')
print(s)
# Line1
#     Line2
#         Line3

စာကြောင်းတစ်ခု၏အစကို ချိန်ညှိလိုပါက၊ သုံးဆကိုးကားများ၏ ပထမစာကြောင်းသို့ backslash တစ်ခုထည့်ပါ။

s = '''\
Line1
Line2
Line3'''
print(s)
# Line1
# Line2
# Line3

s = '''\
Line1
    Line2
        Line3'''
print(s)
# Line1
#     Line2
#         Line3

လိုင်းအသစ်များဖြင့် လိုင်းများစာရင်းကို ပေါင်းစပ်ပါ။

string method join() ကို string များစာရင်းကို string တစ်ခုထဲသို့ ပေါင်းစပ်ရန် အသုံးပြုနိုင်သည်။

• ဆက်စပ်ဆောင်းပါးများ:Python တွင် စာကြောင်းများ ပေါင်းစပ်ခြင်းနှင့် ချိတ်ဆက်ခြင်း (+ အော်ပရေတာ၊ ချိတ်ဆက်ရန် စသည်ဖြင့်)

Join() ကို လိုင်းအသစ်တစ်ခုမှ ခေါ်သောအခါ၊ string element တစ်ခုစီကို လိုင်းအသစ်တစ်ခုနှင့် ပေါင်းစပ်ထားသည်။

l = ['Line1', 'Line2', 'Line3']

s_n = '\n'.join(l)
print(s_n)
# Line1
# Line2
# Line3

print(repr(s_n))
# 'Line1\nLine2\nLine3'

s_rn = '\r\n'.join(l)
print(s_rn)
# Line1
# Line2
# Line3

print(repr(s_rn))
# 'Line1\r\nLine2\r\nLine3'

အထက်ဖော်ပြပါ ဥပမာတွင် ကဲ့သို့ပင်၊ လိုင်းကုဒ်အသစ်များပါရှိသော စာကြောင်းများကို စစ်ဆေးရန် built-in function repr() ကို အသုံးပြုနိုင်သည်။

• repr(object) — Built-in Functions — Python 3.10.2 Documentation

စာကြောင်းအသစ်များနှင့် စာရင်းသို့ ခွဲပါ။:splitlines()

string method ကို splitlines() ကို လိုင်းအသစ်များစာရင်းသို့ ခွဲရန် အသုံးပြုနိုင်သည်။

splitlines() သည် အောက်ပါလိုင်းခွဲကုဒ်များကို ခွဲခြမ်းပေးပါမည်။ ဒေါင်လိုက်တက်ဘ်များနှင့် စာမျက်နှာခွဲခြင်းများလည်း ကွဲသွားပါသည်။

• \n
• \r\n
• \v
• \f

s = 'Line1\nLine2\r\nLine3'
print(s.splitlines())
# ['Line1', 'Line2', 'Line3']

• str.splitlines() — Built-in Types — Python 3.10.2 Documentation

လိုင်းဖိဒ်ကုဒ်များကို ဖယ်ရှားပြီး အစားထိုးပါ။

splitlines() နှင့် join() တို့ကို ပေါင်းစပ်ခြင်းဖြင့် လိုင်းအသစ်များပါရှိသော စာကြောင်းများမှ ဖယ်ရှားရန် (ဖယ်ရှားရန်) သို့မဟုတ် ၎င်းတို့အား အခြားစာကြောင်းများဖြင့် အစားထိုးနိုင်ပါသည်။

s = 'Line1\nLine2\r\nLine3'

print(''.join(s.splitlines()))
# Line1Line2Line3

print(' '.join(s.splitlines()))
# Line1 Line2 Line3

print(','.join(s.splitlines()))
# Line1,Line2,Line3

လိုင်းဖိဒ်ကုဒ်များ အတွဲလိုက် အပြောင်းအလဲလည်း ဖြစ်နိုင်သည်။ လိုင်းခွဲကုဒ်များ ရောနှောနေသည် သို့မဟုတ် မသိပါကပင်၊ ၎င်းတို့ကို splitlines() ဖြင့် ခွဲထုတ်နိုင်ပြီး အလိုရှိသော လိုင်းခွဲကုဒ်များနှင့် ပေါင်းစပ်နိုင်သည်။

s_n = '\n'.join(s.splitlines())
print(s_n)
# Line1
# Line2
# Line3

print(repr(s_n))
# 'Line1\nLine2\nLine3'

အထက်တွင်ဖော်ပြခဲ့သည့်အတိုင်း၊ splitlines() သည် newline code နှစ်ခုလုံးကို ပိုင်းခြားသွားမည်ဖြစ်ပြီး၊ ထို့ကြောင့် splitlines() နှင့် join() တို့ကို ပေါင်းစပ်သည့်နည်းလမ်းအတွက် newline codes များအတွက် အထူးစိုးရိမ်နေစရာ မလိုအပ်ပါ။

လိုင်းအသစ်ကုဒ်သည် ရှင်းလင်းပါက၊ ၎င်းကို string() အစားထိုးသည့်နည်းလမ်းဖြင့်လည်း အစားထိုးနိုင်ပါသည်။

s = 'Line1\nLine2\nLine3'

print(s.replace('\n', ''))
# Line1Line2Line3

print(s.replace('\n', ','))
# Line1,Line2,Line3

သို့သော်၊ ၎င်းတွင် မျှော်လင့်ထားသည်ထက် မတူညီသော လိုင်းအစာကုဒ်များ ပါဝင်နေပါက ၎င်းတွင် အလုပ်မဖြစ်ကြောင်း သတိပြုပါ။

s = 'Line1\nLine2\r\nLine3'

s_error = s.replace('\n', ',')
print(s_error)
# ,Line3Line2

print(repr(s_error))
# 'Line1,Line2\r,Line3'

s_error = s.replace('\r\n', ',')
print(s_error)
# Line1
# Line2,Line3

print(repr(s_error))
# 'Line1\nLine2,Line3'

အစားထိုး()ကို ထပ်ခါတလဲလဲလုပ်ခြင်းဖြင့် လိုင်းအသစ်ကုဒ်များစွာကို အစားထိုးရန် ဖြစ်နိုင်သော်လည်း “ \r\n” တွင် “ \n” ပါသောကြောင့် မှာယူမှု မှားယွင်းပါက အလုပ်မဖြစ်ပါ။ အထက်တွင်ဖော်ပြထားသော splitlines() နှင့် join() ပေါင်းစပ်ထားသောနည်းလမ်းသည် line feed codes များအတွက် စိတ်ပူစရာမလိုသောကြောင့် ပိုမိုလုံခြုံပါသည်။

s = 'Line1\nLine2\r\nLine3'

print(s.replace('\r\n', ',').replace('\n', ','))
# Line1,Line2,Line3

s_error = s.replace('\n', ',').replace('\r\n', ',')
print(s_error)
# ,Line3Line2

print(repr(s_error))
# 'Line1,Line2\r,Line3'

print(','.join(s.splitlines()))
# Line1,Line2,Line3

ဝါကျတစ်ခု၏အဆုံးတွင် စာကြောင်းစာကြောင်းများကို ဖယ်ရှားရန် rstrip() နည်းလမ်းကို အသုံးပြုပါ။ rstrip() သည် စာကြောင်းတစ်ခု၏ ညာဘက်စွန်းရှိ အဖြူရောင် space စာလုံးများ (စာကြောင်းစာကြောင်းများ အပါအဝင်) ကို ဖယ်ရှားရန် နည်းလမ်းတစ်ခုဖြစ်သည်။

s = 'aaa\n'
print(s + 'bbb')
# aaa
# bbb

print(s.rstrip() + 'bbb')
# aaabbb

လိုင်းအသစ်ကို နောက်မလိုက်ဘဲ ပရင့်ထုတ်ပါ။

print() လုပ်ဆောင်ချက်သည် မူရင်းအတိုင်း နောက်ကောက်ကြောင်းအသစ်တစ်ခုကို ပေါင်းထည့်သည်။ ထို့ကြောင့် print() ကို ဆက်တိုက်လုပ်ဆောင်ပါက၊ output ရလဒ်တစ်ခုစီကို စာကြောင်းအသစ်တွင် ပြသမည်ဖြစ်ပါသည်။

print('a')
print('b')
print('c')
# a
# b
# c

အဘယ်ကြောင့်ဆိုသော် အဆုံးတွင် ထည့်သွင်းမည့် string() ၏ အကြောင်းပြချက်အဆုံးတွင် ပုံသေတန်ဖိုးသည် လိုင်းအသစ်သင်္ကေတဖြစ်သောကြောင့် ဖြစ်သည်။

အဆုံးတွင် လိုင်းအသစ်မလိုချင်ပါက၊ အငြင်းအခုံအဆုံးကို အလွတ်စာကြောင်းတစ်ခုအဖြစ် သတ်မှတ်ပြီး အဆုံးတွင် လိုင်းအသစ်မပါဘဲ အထွက်ကို ထုတ်ပေးမည်ဖြစ်သည်။

print('a', end='')
print('b', end='')
print('c', end='')
# abc

အငြင်းအခုံအဆုံးသည် မည်သည့်စာကြောင်းမဆို ဖြစ်နိုင်သည်။

print('a', end='-')
print('b', end='-')
print('c')
# a-b-c

သို့သော်၊ သင်သည် output အတွက် strings များကို ပေါင်းစပ်လိုပါက၊ print() ၏အဆုံးသတ် argument တွင် ၎င်းတို့ကို သတ်မှတ်ခြင်းထက် မူရင်းစာကြောင်းများကို ပေါင်းစည်းရန် ပိုမိုလွယ်ကူပါသည်။ အောက်ပါဆောင်းပါးကိုကြည့်ပါ။

• ဆက်စပ်ဆောင်းပါးများ:Python တွင် စာကြောင်းများ ပေါင်းစပ်ခြင်းနှင့် ချိတ်ဆက်ခြင်း (+ အော်ပရေတာ၊ ချိတ်ဆက်ရန် စသည်ဖြင့်)