Het volgende beschrijft de werking van strings die newlines bevatten in Python.
- Maak string met newlines, druk uitvoer af (display)
- newline-teken (CR of LF of beide, afhankelijk van het systeem)
\n(LF),\r\n(CR+LF) - driedubbele quote
''',""" - Als u wilt inspringen
- newline-teken (CR of LF of beide, afhankelijk van het systeem)
- Samenvoegen van een lijst van strings met nieuwe regels
- Splits string in newlines en lijst:
splitlines() - Verwijderen en vervangen van lijnaanvoercodes
- Uitvoer afdrukken zonder nieuwe regel achteraan
Maak een string met newlines, druk af
newline-teken (CR of LF of beide, afhankelijk van het systeem) \n(LF), \r\n(CR+LF)
Het invoegen van een regel feed code in een string zal resulteren in een nieuwe regel.
s = 'Line1\nLine2\nLine3'
print(s)
# Line1
# Line2
# Line3
s = 'Line1\r\nLine2\r\nLine3'
print(s)
# Line1
# Line2
# Line3
Regeleindecodes kunnen op de volgende manieren worden gebruikt. In sommige editors kunt u een regeleinde-code selecteren.
| Macを含むUnix系 | \n(LF) |
| Windows系 | \r\n(CR+LF) |
driedubbele quote ''',"""
Als drievoudige aanhalingstekens worden gebruikt om de string in te sluiten, zal het een string zijn zoals hij is, inclusief nieuwe regels.
s = '''Line1
Line2
Line3'''
print(s)
# Line1
# Line2
# Line3
Als u wilt inspringen
Drievoudige aanhalingstekens zijn ook spaties in een string, dus als je netjes in code probeert te schrijven en inspringt zoals hieronder, zullen onnodige spaties worden ingevoegd.
s = '''
Line1
Line2
Line3
'''
print(s)
#
# Line1
# Line2
# Line3
#
Door een backslash te gebruiken om newlines in de code te negeren en er een vervolgregel van te maken, kan het als volgt geschreven worden
Sluit elke regel af met “” of “” en voeg aan het einde van de zin het teken voor een nieuwe regel ←n toe.
s = 'Line1\n'\
'Line2\n'\
'Line3'
print(s)
# Line1
# Line2
# Line3
Hier is de syntaxis dat opeenvolgende string-literalen worden samengevoegd. Zie het volgende artikel voor details.
Als je inspringing in een string wilt toevoegen, voeg je gewoon een spatie toe aan de string op elke regel.
s = 'Line1\n'\
' Line2\n'\
' Line3'
print(s)
# Line1
# Line2
# Line3
Aangezien regeleindes in haakjes vrij kunnen worden gemaakt, kan bovendien het volgende worden geschreven met haakjes in plaats van backslashes.
s = ('Line1\n'
'Line2\n'
'Line3')
print(s)
# Line1
# Line2
# Line3
s = ('Line1\n'
' Line2\n'
' Line3')
print(s)
# Line1
# Line2
# Line3
Als u alleen het begin van een regel wilt uitlijnen, voeg dan een backslash toe aan de eerste regel met driedubbele aanhalingstekens.
s = '''\
Line1
Line2
Line3'''
print(s)
# Line1
# Line2
# Line3
s = '''\
Line1
Line2
Line3'''
print(s)
# Line1
# Line2
# Line3
Samenvoegen van een lijst van strings met nieuwe regels
De string methode join() kan worden gebruikt om een lijst van strings samen te voegen tot een enkele string.
Wanneer join() wordt aangeroepen vanaf een newline-teken, wordt elk string-element samengevoegd met een newline.
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'
Zoals in het bovenstaande voorbeeld, kan de ingebouwde functie repr() gebruikt worden om strings die newline codes bevatten, te controleren zoals ze zijn.
Splits string in newlines en lijst: splitlines()
De string methode splitlines() kan worden gebruikt om een string te splitsen in een lijst van newlines.
splitlines() zal elk van de volgende regeleindecodes splitsen. Verticale tabs en pagina-einden worden ook gesplitst.
\n\r\n\v\f
s = 'Line1\nLine2\r\nLine3'
print(s.splitlines())
# ['Line1', 'Line2', 'Line3']
Verwijderen en vervangen van lijnaanvoercodes
Door splitlines() en join() te combineren, is het mogelijk om newline-codes te verwijderen (verwijderen) uit een string die newlines bevat, of ze te vervangen door andere strings.
s = 'Line1\nLine2\r\nLine3'
print(''.join(s.splitlines()))
# Line1Line2Line3
print(' '.join(s.splitlines()))
# Line1 Line2 Line3
print(','.join(s.splitlines()))
# Line1,Line2,Line3
Batch wijziging van regeleinde codes is ook mogelijk. Zelfs als regeleinde-codes gemengd of onbekend zijn, kunnen ze worden gesplitst met behulp van splitlines() en vervolgens worden samengevoegd met de gewenste regeleinde-code.
s_n = '\n'.join(s.splitlines())
print(s_n)
# Line1
# Line2
# Line3
print(repr(s_n))
# 'Line1\nLine2\nLine3'
Zoals hierboven vermeld, zal splitlines() elke newline code splitsen, dus er is geen reden om bijzonder bezorgd te zijn over newline codes in het geval van de methode die splitlines() en join() combineert.
Als de newline code duidelijk is, kan hij ook vervangen worden door de replace() methode, die de string vervangt.
s = 'Line1\nLine2\nLine3'
print(s.replace('\n', ''))
# Line1Line2Line3
print(s.replace('\n', ','))
# Line1,Line2,Line3
Merk echter op dat het niet zal werken als het andere line feed codes bevat dan verwacht.
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'
Het is mogelijk om meerdere newline codes te vervangen door replace() te herhalen, maar het zal niet werken als de volgorde verkeerd is omdat “\r” “\n” bevat. De methode die splitlines() en join() combineert, zoals hierboven beschreven, is veiliger omdat je je geen zorgen hoeft te maken over regelinvoegcodes.
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
Gebruik de methode rstrip() om regelinvoercodes aan het einde van een zin te verwijderen. rstrip() is een methode om witruimtekens (inclusief regelinvoer) aan het rechte einde van een string te verwijderen.
s = 'aaa\n'
print(s + 'bbb')
# aaa
# bbb
print(s.rstrip() + 'bbb')
# aaabbb
Uitvoer afdrukken zonder nieuwe regel achteraan
De print() functie voegt standaard een nieuwe regel achteraan toe. Daarom zal, als print() na elkaar wordt uitgevoerd, elk uitvoerresultaat op een nieuwe regel worden weergegeven.
print('a')
print('b')
print('c')
# a
# b
# c
Dit komt omdat de standaardwaarde van het argument einde van print(), dat de string specificeert die aan het einde moet worden toegevoegd, het newline-symbool is.
Indien u geen nieuwe regel aan het einde wenst, stel dan het argument einde in op een lege string, en de uitvoer zal worden uitgevoerd zonder een nieuwe regel aan het einde.
print('a', end='')
print('b', end='')
print('c', end='')
# abc
Het argument einde kan een willekeurige string zijn.
print('a', end='-')
print('b', end='-')
print('c')
# a-b-c
Als je echter strings aan elkaar wilt plakken voor uitvoer, is het eenvoudiger om de originele strings aan elkaar te plakken dan om ze op te geven in het eindargument van print(). Zie het volgende artikel.