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

රේඛීය පෝෂක කේත පහත ආකාරවලින් භාවිතා කළ හැක. සමහර සංස්කාරකවරුන් ඔබට රේඛා බිඳීමේ කේතයක් තෝරා ගැනීමට ඉඩ සලසයි.

ත්‍රිත්ව උපුටා දැක්වීම'',"""

තන්තුව කොටු කිරීමට ත්‍රිත්ව උද්ධෘත භාවිතා කරන්නේ නම්, එය නව රේඛා ඇතුළුව තන්තුවක් වනු ඇත.

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

ඔබට ඉන්ඩෙන්ට් කිරීමට අවශ්‍ය නම්

ත්‍රිත්ව උද්ධෘත යනු තන්තුවක ඇති හිස්තැන් වේ, එබැවින් ඔබ පහත රූපයේ පරිදි කේතය සහ ඉන්ඩෙන්ට් වලින් පිළිවෙලට ලිවීමට උත්සාහ කළහොත් අනවශ්‍ය හිස්තැන් ඇතුළත් වේ.

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

කේතයේ නව රේඛා නොසලකා හැරීමට සහ එය අඛණ්ඩ රේඛාවක් බවට පත් කිරීමට backslash භාවිතා කිරීමෙන්, එය පහත පරිදි ලිවිය හැක.

සෑම පේළියක්ම ” හෝ “” සමඟින් කොට වාක්‍යයේ අවසානයේ නව රේඛා අක්ෂරයක් ←n එක් කරන්න.

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

මෙහිදී, වාක්‍ය ඛණ්ඩය යනු අනුක්‍රමික තන්තු අක්ෂර සංකලනය වී ඇති බවයි. විස්තර සඳහා පහත ලිපිය බලන්න.

• අදාළ ලිපි:Python (+ ක්‍රියාකරු, සම්බන්ධ කිරීම, ආදිය) තුළ නූල් සම්බන්ධ කිරීම සහ සම්බන්ධ කිරීම

ඔබට තන්තුවක ඉන්ඩෙන්ටේෂන් එක් කිරීමට අවශ්‍ය නම්, එක් එක් පේළියේ ඇති තන්තුවට ඉඩක් එක් කරන්න.

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

මීට අමතරව, රේඛා බිඳීම් වරහන් තුළ නිදහසේ සෑදිය හැකි බැවින්, පසු තීරු වෙනුවට වරහන් භාවිතයෙන් පහත දේ ලිවිය හැකිය.

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

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

ඔබට පේළියක ආරම්භය පෙළගස්වීමට අවශ්‍ය නම්, ත්‍රිත්ව උද්ධෘතවල පළමු පේළියට පසුතලයක් එක් කරන්න.

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

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

නව රේඛා සමඟ නූල් ලැයිස්තුවක් ඒකාබද්ධ කරන්න

තන්තු ලැයිස්තුවක් තනි තන්තුවකට ඒකාබද්ධ කිරීමට තන්තු ක්‍රමය join() භාවිතා කළ හැක.

• අදාළ ලිපි:Python (+ ක්‍රියාකරු, සම්බන්ධ කිරීම, ආදිය) තුළ නූල් සම්බන්ධ කිරීම සහ සම්බන්ධ කිරීම

join() නව රේඛා අක්ෂරයකින් ඇමතූ විට, සෑම තන්තු මූලද්‍රව්‍යයක්ම නව රේඛාවක් සමඟ සංයුක්ත වේ.

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'

ඉහත උදාහරණයේ දී මෙන්, නව රේඛා කේත අඩංගු තන්තු පරීක්ෂා කිරීමට ගොඩනඟන ලද repr() ශ්‍රිතය භාවිතා කළ හැක.

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

තන්තුව නව රේඛා සහ ලැයිස්තුවට බෙදන්න:splitlines()

තන්තු ක්‍රමය 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() විසින් නව රේඛා කේතයක් බෙදනු ඇත, එබැවින් splitlines() සහ join() ඒකාබද්ධ කරන ක්‍රමයේදී නව රේඛා කේත ගැන විශේෂයෙන් සැලකිලිමත් විය යුතු නැත.

නව රේඛා කේතය පැහැදිලි නම්, එය තන්තුව ප්‍රතිස්ථාපනය කරන ප්‍රතිස්ථාපන () ක්‍රමය මගින් ද ප්‍රතිස්ථාපනය කළ හැක.

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() ඒකාබද්ධ කිරීමේ ක්‍රමය ආරක්ෂිතයි.

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() යනු තන්තුවක දකුණු කෙළවරේ ඇති සුදු අවකාශ අක්ෂර (රේඛා සංග්‍රහ ඇතුළුව) ඉවත් කිරීමේ ක්‍රමයකි.

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

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

නව රේඛාව පසුපස හඹා නොගොස් ප්‍රතිදානය මුද්‍රණය කරන්න

මුද්‍රණ() ශ්‍රිතය පෙරනිමියෙන් නව රේඛාවක් එක් කරයි. එබැවින්, මුද්‍රණය () අනුක්‍රමිකව ක්‍රියාත්මක කරන්නේ නම්, සෑම ප්‍රතිදාන ප්‍රතිඵලයක්ම නව රේඛාවක දර්ශනය වේ.

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

මක්නිසාද යත්, අවසානයේ එකතු කළ යුතු තන්තුව සඳහන් කරන print() හි තර්ක අන්තයේ පෙරනිමි අගය නව රේඛා සංකේතය වන බැවිනි.

ඔබට අවසානයේ නව රේඛාවක් අවශ්‍ය නැතිනම්, තර්කයේ අවසානය හිස් තන්තුවකට සකසන්න, එවිට ප්‍රතිදානය අවසානයේ නව රේඛාවක් නොමැතිව ප්‍රතිදානය වනු ඇත.

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

තර්ක අවසානය ඕනෑම තන්තුවක් විය හැක.

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

කෙසේ වෙතත්, ඔබට ප්‍රතිදානය සඳහා නූල් සම්බන්ධ කිරීමට අවශ්‍ය නම්, මුද්‍රණ () හි අවසාන තර්කයේ ඒවා සඳහන් කිරීමට වඩා මුල් තන්තු සම්බන්ධ කිරීම පහසුය. පහත ලිපිය බලන්න.

• අදාළ ලිපි:Python (+ ක්‍රියාකරු, සම්බන්ධ කිරීම, ආදිය) තුළ නූල් සම්බන්ධ කිරීම සහ සම්බන්ධ කිරීම