पायथनमध्ये नवीन रेषा असलेल्या स्ट्रिंग्स आउटपुट, एकत्र करा, विभाजित करा, हटवा आणि बदला

पायथनमध्ये नवीन रेषा असलेल्या स्ट्रिंगच्या ऑपरेशनचे वर्णन खालीलप्रमाणे आहे.

• नवीन रेषा असलेली स्ट्रिंग तयार करा, प्रिंट आउटपुट (प्रदर्शन)
  • नवीन वर्ण (सीआर आणि एलएफ दोन्हीपैकी एक किंवा सिस्टीमवर अवलंबून)\n(LF),\r\n(CR+LF)
  • तिहेरी कोट'',"""
  • तुम्हाला इंडेंट करायचे असल्यास
• नवीन रेषांसह स्ट्रिंगची सूची एकत्र करा
• नवीन ओळी आणि सूचीमध्ये स्ट्रिंग विभाजित करा:splitlines()
• लाइन फीड कोड काढा आणि बदला
• नवीन ओळीच्या मागे न जाता प्रिंट आउटपुट

नवीन ओळी, प्रिंट आउटपुट असलेली स्ट्रिंग तयार करा

नवीन वर्ण (सीआर आणि एलएफ दोन्हीपैकी एक किंवा सिस्टीमवर अवलंबून)\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

नवीन रेषांसह स्ट्रिंगची सूची एकत्र करा

स्ट्रिंग मेथड 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() खालीलपैकी कोणतेही लाइन ब्रेक कोड विभाजित करेल. अनुलंब टॅब आणि पृष्ठ ब्रेक देखील विभाजित आहेत.

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

लाइन फीड कोड काढा आणि बदला

स्प्लिटलाइन्स() आणि 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

लाइन फीड कोडचा बॅच बदल देखील शक्य आहे. जरी लाइन ब्रेक कोड मिश्रित किंवा अज्ञात असले तरीही, ते स्प्लिटलाइन्स() वापरून विभाजित केले जाऊ शकतात आणि नंतर इच्छित लाइन ब्रेक कोडसह जोडले जाऊ शकतात.

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

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

वर नमूद केल्याप्रमाणे, स्प्लिटलाइन्स() एकतर नवीन लाइन कोड विभाजित करेल, त्यामुळे स्प्लिटलाइन() आणि 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” समाविष्ट आहे. वर वर्णन केलेली स्प्लिटलाइन() आणि 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() एकापाठोपाठ एक कार्यान्वित केले तर, प्रत्येक आउटपुट परिणाम नवीन ओळीवर प्रदर्शित केला जाईल.

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

तथापि, जर तुम्हाला आउटपुटसाठी स्ट्रिंग्स एकत्र करायच्या असतील तर, प्रिंट() च्या शेवटच्या युक्तिवादात निर्दिष्ट करण्यापेक्षा मूळ स्ट्रिंग्स एकत्र करणे सोपे आहे. पुढील लेख पहा.

• संबंधित लेख:पायथन (+ ऑपरेटर, जॉइन इ.) मध्ये स्ट्रिंग्स जोडणे आणि जोडणे