పైథాన్‌లో కొత్త లైన్‌లను కలిగి ఉన్న స్ట్రింగ్‌లను అవుట్‌పుట్ చేయండి, కలపండి, విభజించండి, తొలగించండి మరియు భర్తీ చేయండి

పైథాన్‌లో కొత్త లైన్‌లను కలిగి ఉన్న స్ట్రింగ్‌ల ఆపరేషన్‌ను క్రింది వివరిస్తుంది.

• కొత్త లైన్‌లు, ప్రింట్ అవుట్‌పుట్ (ప్రదర్శన) కలిగి ఉన్న స్ట్రింగ్‌ను సృష్టించండి
  • కొత్త లైన్ క్యారెక్టర్ (సిస్టమ్‌పై ఆధారపడి 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
#     

కోడ్‌లోని కొత్త లైన్‌లను విస్మరించడానికి మరియు దానిని కొనసాగింపు లైన్‌గా చేయడానికి బ్యాక్‌స్లాష్‌ను ఉపయోగించడం ద్వారా, దానిని ఈ క్రింది విధంగా వ్రాయవచ్చు

ప్రతి పంక్తిని ” లేదా “”తో జతపరచండి మరియు వాక్యం చివరిలో ←n అనే కొత్త లైన్ అక్షరాన్ని జోడించండి.

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

కొత్త లైన్‌లతో స్ట్రింగ్‌ల జాబితాను కలపండి

స్ట్రింగ్ మెథడ్ జాయిన్()ని స్ట్రింగ్‌ల జాబితాను ఒకే స్ట్రింగ్‌గా కలపడానికి ఉపయోగించవచ్చు.

• సంబంధిత కథనాలు:పైథాన్ (+ ఆపరేటర్, జాయిన్ మొదలైనవి)లో స్ట్రింగ్‌లను కలపడం మరియు చేరడం

జాయిన్()ని కొత్త లైన్ క్యారెక్టర్ నుండి పిలిచినప్పుడు, ప్రతి స్ట్రింగ్ ఎలిమెంట్ కొత్త లైన్‌తో కలుస్తుంది.

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() క్రింది లైన్ బ్రేక్ కోడ్‌లలో దేనినైనా విభజిస్తుంది. నిలువు ట్యాబ్‌లు మరియు పేజీ విరామాలు కూడా విభజించబడ్డాయి.

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

లైన్ ఫీడ్ కోడ్‌లను తీసివేసి, భర్తీ చేయండి

స్ప్లిట్‌లైన్‌లు() మరియు జాయిన్() కలపడం ద్వారా, కొత్త లైన్‌లను కలిగి ఉన్న స్ట్రింగ్ నుండి కొత్త లైన్ కోడ్‌లను తీసివేయడం (తొలగించడం) లేదా వాటిని ఇతర స్ట్రింగ్‌లతో భర్తీ చేయడం సాధ్యపడుతుంది.

s = 'Line1\nLine2\r\nLine3'

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

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

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

లైన్ ఫీడ్ కోడ్‌ల బ్యాచ్ మార్పు కూడా సాధ్యమే. లైన్ బ్రేక్ కోడ్‌లు మిశ్రమంగా ఉన్నా లేదా తెలియకపోయినా, వాటిని స్ప్లిట్‌లైన్‌లు() ఉపయోగించి విభజించి, ఆపై కావలసిన లైన్ బ్రేక్ కోడ్‌తో కలపవచ్చు.

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

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

పైన పేర్కొన్నట్లుగా, స్ప్లిట్‌లైన్‌లు() కొత్త లైన్ కోడ్‌ని విభజించవచ్చు, కాబట్టి స్ప్లిట్‌లైన్‌లు() మరియు జాయిన్()లను కలపడం విషయంలో కొత్త లైన్ కోడ్‌ల గురించి ప్రత్యేకంగా ఆందోళన చెందాల్సిన అవసరం లేదు.

కొత్త లైన్ కోడ్ స్పష్టంగా ఉంటే, అది స్ట్రింగ్‌ను భర్తీ చేసే రీప్లేస్() పద్ధతి ద్వారా కూడా భర్తీ చేయబడుతుంది.

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” ఉన్నందున ఆర్డర్ తప్పుగా ఉంటే అది పని చేయదు. లైన్ ఫీడ్ కోడ్‌ల గురించి ఆందోళన చెందాల్సిన అవసరం లేనందున పైన వివరించిన స్ప్లిట్‌లైన్‌లు() మరియు జాయిన్()లను కలపడం సురక్షితమైనది.

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('a', end='')
print('b', end='')
print('c', end='')
# abc

ఆర్గ్యుమెంట్ ముగింపు ఏదైనా స్ట్రింగ్ కావచ్చు.

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

అయితే, మీరు అవుట్‌పుట్ కోసం స్ట్రింగ్‌లను సంగ్రహించాలనుకుంటే, ప్రింట్() యొక్క ఎండ్ ఆర్గ్యుమెంట్‌లో వాటిని పేర్కొనడం కంటే అసలైన స్ట్రింగ్‌లను కలపడం సులభం. కింది కథనాన్ని చూడండి.

• సంబంధిత కథనాలు:పైథాన్ (+ ఆపరేటర్, జాయిన్ మొదలైనవి)లో స్ట్రింగ్‌లను కలపడం మరియు చేరడం