પાયથોનમાં નવી લાઇન ધરાવતી સ્ટ્રીંગ્સને આઉટપુટ કરો, જોડો, વિભાજિત કરો, કાઢી નાખો અને બદલો

નીચે પાયથોનમાં નવી લાઇન ધરાવતી સ્ટ્રીંગ્સની કામગીરીનું વર્ણન કરે છે.

• નવી લાઇન, પ્રિન્ટ આઉટપુટ (ડિસ્પ્લે) ધરાવતી સ્ટ્રિંગ બનાવો
  • નવી લાઇન કેરેક્ટર (સીઆર અને એલએફ બંનેમાંથી અથવા સિસ્ટમ પર આધાર રાખીને)\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() નો ઉપયોગ સ્ટ્રિંગની યાદીને એક સ્ટ્રિંગમાં જોડવા માટે કરી શકાય છે.

• સંબંધિત લેખો:પાયથોન (+ ઓપરેટર, જોડાવા, વગેરે) માં સ્ટ્રિંગ્સને જોડવું અને જોડવું

જ્યારે 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” શામેલ છે. ઉપર વર્ણવેલ 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() ક્રમિક રીતે ચલાવવામાં આવે છે, તો દરેક આઉટપુટ પરિણામ નવી લાઇન પર પ્રદર્શિત થશે.

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

જો કે, જો તમે આઉટપુટ માટે સ્ટ્રીંગ્સને જોડવા માંગતા હો, તો પ્રિન્ટ() ના અંતિમ દલીલમાં સ્પષ્ટ કરવા કરતાં મૂળ સ્ટ્રિંગ્સને જોડવાનું સરળ છે. નીચેનો લેખ જુઓ.

• સંબંધિત લેખો:પાયથોન (+ ઓપરેટર, જોડાવા, વગેરે) માં સ્ટ્રિંગ્સને જોડવું અને જોડવું