Wie kann ich einen nachgestellten Zeilenumbruch entfernen?

Was ist das Python-Äquivalent zu Perls chompFunktion, bei der das letzte Zeichen einer Zeichenfolge entfernt wird, wenn es sich um eine neue Zeile handelt?

Probieren Sie die Methode aus rstrip()(siehe Dokument Python 2 und Python 3 ).

>>> 'test string\n'.rstrip()
'test string'

Die Python- rstrip()Methode entfernt standardmäßig alle Arten von nachgestellten Leerzeichen, nicht nur eine neue Zeile, wie dies bei Perl der Fall ist chomp.

>>> 'test string \n \r\n\n\r \n\n'.rstrip()
'test string'

So entfernen Sie nur Zeilenumbrüche:

>>> 'test string \n \r\n\n\r \n\n'.rstrip('\n')
'test string \n \r\n\n\r '

Es gibt auch die Methoden lstrip()und strip():

>>> s = "   \n\r\n  \n  abc   def \n\r\n  \n  "
>>> s.strip()
'abc   def'
>>> s.lstrip()
'abc   def \n\r\n  \n  '
>>> s.rstrip()
'   \n\r\n  \n  abc   def'

Und ich würde sagen, der "pythonische" Weg, um Zeilen ohne nachgestellte Zeilenumbrüche zu erhalten, ist splitlines ().

>>> text = "line 1\nline 2\r\nline 3\nline 4"
>>> text.splitlines()
['line 1', 'line 2', 'line 3', 'line 4']

Die kanonische Methode zum Entfernen von Zeilenendezeichen (EOL) besteht darin, die Methode string rstrip () zu verwenden, um nachfolgende \ r oder \ n zu entfernen. Hier finden Sie Beispiele für Mac-, Windows- und Unix-EOL-Zeichen.

>>> 'Mac EOL\r'.rstrip('\r\n')
'Mac EOL'
>>> 'Windows EOL\r\n'.rstrip('\r\n')
'Windows EOL'
>>> 'Unix EOL\n'.rstrip('\r\n')
'Unix EOL'

Die Verwendung von '\ r \ n' als Parameter für rstrip bedeutet, dass alle nachfolgenden Kombinationen von '\ r' oder '\ n' entfernt werden. Deshalb funktioniert es in allen drei oben genannten Fällen.

Diese Nuance ist in seltenen Fällen von Bedeutung. Zum Beispiel musste ich einmal eine Textdatei verarbeiten, die eine HL7-Nachricht enthielt. Der HL7-Standard erfordert ein abschließendes '\ r' als EOL-Zeichen. Der Windows-Computer, auf dem ich diese Nachricht verwendet habe, hat ein eigenes EOL-Zeichen '\ r \ n' angehängt. Daher sah das Ende jeder Zeile wie '\ r \ r \ n' aus. Die Verwendung von rstrip ('\ r \ n') hätte das gesamte '\ r \ r \ n' entfernt, was nicht das ist, was ich wollte. In diesem Fall habe ich stattdessen einfach die letzten beiden Zeichen abgeschnitten.

Beachten Sie, dass im Gegensatz zu Perls chompFunktion alle angegebenen Zeichen am Ende der Zeichenfolge entfernt werden, nicht nur eines:

>>> "Hello\n\n\n".rstrip("\n")
"Hello"

Beachten Sie, dass rstrip nicht genau wie Perls chomp () funktioniert, da es den String nicht ändert. Das heißt, in Perl:

$x="a\n";

chomp $x

führt zu $xSein "a".

aber in Python:

x="a\n"

x.rstrip()

wird bedeuten, dass der Wert von ximmer noch ist "a\n" . Auch x=x.rstrip()gibt nicht immer das gleiche Ergebnis, da alle Leerzeichen vom Ende der Zeichenfolge entfernt werden, nicht nur höchstens eine neue Zeile.

Ich könnte so etwas verwenden:

import os
s = s.rstrip(os.linesep)

Ich denke, das Problem dabei rstrip("\n")ist, dass Sie wahrscheinlich sicherstellen möchten, dass das Zeilentrennzeichen tragbar ist. (Einige veraltete Systeme sollen verwendet werden "\r\n"). Das andere Problem ist, dass rstripwiederholte Leerzeichen entfernt werden. Hoffentlich os.linesepenthält die richtigen Zeichen. Das obige funktioniert für mich.

Sie können verwenden line = line.rstrip('\n'). Dadurch werden alle Zeilenumbrüche vom Ende der Zeichenfolge entfernt, nicht nur eine.

s = s.rstrip()

entfernt alle Zeilenumbrüche am Ende der Zeichenfolge s. Die Zuweisung wird benötigt, da rstripeine neue Zeichenfolge zurückgegeben wird, anstatt die ursprüngliche Zeichenfolge zu ändern.

Dies würde genau Perls Chomp (minus Verhalten auf Arrays) für den Zeilenabschluss "\ n" replizieren:

def chomp(x):
    if x.endswith("\r\n"): return x[:-2]
    if x.endswith("\n") or x.endswith("\r"): return x[:-1]
    return x

(Hinweis: Die Zeichenfolge 'an Ort und Stelle' wird nicht geändert. Es werden keine zusätzlichen nachgestellten Leerzeichen entfernt. Berücksichtigt \ r \ n.)

"line 1\nline 2\r\n...".replace('\n', '').replace('\r', '')
>>> 'line 1line 2...'

oder du könntest mit regulären Ausdrücken immer geekier werden :)

habe Spaß!

Sie können Streifen verwenden:

line = line.strip()

Demo:

>>> "\n\n hello world \n\n".strip()
'hello world'

rstrip macht auf so vielen Ebenen nicht dasselbe wie chomp. Lesen Sie http://perldoc.perl.org/functions/chomp.html und sehen Sie, dass Chomp in der Tat sehr komplex ist.

Mein Hauptpunkt ist jedoch, dass chomp höchstens 1 Zeilenende entfernt, während rstrip so viele wie möglich entfernt.

Hier können Sie sehen, wie rstrip alle Zeilenumbrüche entfernt:

>>> 'foo\n\n'.rstrip(os.linesep)
'foo'

Eine viel engere Annäherung an die typische Verwendung von Perl-Chomp kann mit re wie folgt erreicht werden:

>>> re.sub(os.linesep + r'\Z','','foo\n\n')
'foo\n'

Vorsicht bei "foo".rstrip(os.linesep): Dadurch werden nur die Zeilenumbruchzeichen für die Plattform verarbeitet, auf der Ihr Python ausgeführt wird. Stellen Sie sich vor, Sie schimpfen unter Linux mit den Zeilen einer Windows-Datei, zum Beispiel:

$ python
Python 2.7.1 (r271:86832, Mar 18 2011, 09:09:48) 
[GCC 4.5.0 20100604 [gcc-4_5-branch revision 160292]] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import os, sys
>>> sys.platform
'linux2'
>>> "foo\r\n".rstrip(os.linesep)
'foo\r'
>>>

Verwenden Sie "foo".rstrip("\r\n")stattdessen, wie Mike oben sagt.

Ein Beispiel in der Python-Dokumentation verwendet einfach line.strip().

Perls chompFunktion entfernt eine Zeilenumbruchsequenz nur dann vom Ende einer Zeichenfolge, wenn sie tatsächlich vorhanden ist.

So plane ich das in Python, wenn dies processkonzeptionell die Funktion ist, die ich benötige, um für jede Zeile aus dieser Datei etwas Nützliches zu tun:

import os
sep_pos = -len(os.linesep)
with open("file.txt") as f:
    for line in f:
        if line[sep_pos:] == os.linesep:
            line = line[:sep_pos]
        process(line)

Ich programmiere nicht in Python, aber ich bin auf python.org auf eine FAQ gestoßen, die S.rstrip ("\ r \ n") für Python 2.2 oder höher befürwortet.

import re

r_unwanted = re.compile("[\n\t\r]")
r_unwanted.sub("", your_text)

Ich finde es praktisch, die gechompten Zeilen im Iterator abrufen zu können, parallel zu der Art und Weise, wie Sie die nicht gechompten Zeilen von einem Dateiobjekt abrufen können. Sie können dies mit dem folgenden Code tun:

def chomped_lines(it):
    return map(operator.methodcaller('rstrip', '\r\n'), it)

Beispielnutzung:

with open("file.txt") as infile:
    for line in chomped_lines(infile):
        process(line)

Problemumgehungslösung für Sonderfälle:

Wenn das Zeilenumbruchzeichen das letzte Zeichen ist (wie dies bei den meisten Dateieingaben der Fall ist), können Sie für jedes Element in der Sammlung Folgendes indizieren:

foobar= foobar[:-1]

um Ihren Newline-Charakter herauszuschneiden.

Wenn Sie alle Zeilenumbrüche in einem mehrzeiligen str-Objekt (oldstr) bereinigen möchten, können Sie es gemäß dem Trennzeichen '\ n' in eine Liste aufteilen und diese Liste dann zu einem neuen str (newstr) zusammenfügen.

newstr = "".join(oldstr.split('\n'))

Es sieht so aus, als gäbe es kein perfektes Analogon für Perls Chomp . Insbesondere kann rstrip keine Newline-Trennzeichen mit mehreren Zeichen wie verarbeiten \r\n. Allerdings Teilungslinien nicht wie hier darauf hingewiesen . Nach meiner Antwort auf eine andere Frage, können Sie kombinieren beitreten und Teilungslinien entfernen / ersetzen Sie alle Zeilenumbrüche aus einem String s:

''.join(s.splitlines())

Folgende entfernt genau ein nachlauf Newline (wie chomp würde, glaube ich). Bei Trueder keependsÜbergabe als Argument an Splitlines bleiben die Trennzeichen erhalten. Dann wird Splitlines erneut aufgerufen, um die Trennzeichen nur in der letzten "Zeile" zu entfernen:

def chomp(s):
    if len(s):
        lines = s.splitlines(True)
        last = lines.pop()
        return ''.join(lines + last.splitlines())
    else:
        return ''

Ich sprudle meine auf regulären Ausdrücken basierende Antwort von einer, die ich zuvor in den Kommentaren einer anderen Antwort gepostet habe. Ich denke, die Verwendung reist eine klarere und explizitere Lösung für dieses Problem als str.rstrip.

>>> import re

Wenn Sie ein oder mehrere nachgestellte Zeilenumbrüche entfernen möchten:

>>> re.sub(r'[\n\r]+$', '', '\nx\r\n')
'\nx'

Wenn Sie Zeilenumbrüche überall entfernen möchten (nicht nur am Ende):

>>> re.sub(r'[\n\r]+', '', '\nx\r\n')
'x'

Wenn Sie nur 1-2 Newline Zeichen (dh entfernen \r, \n, \r\n, \n\r, \r\r, \n\n)

>>> re.sub(r'[\n\r]{1,2}$', '', '\nx\r\n\r\n')
'\nx\r'
>>> re.sub(r'[\n\r]{1,2}$', '', '\nx\r\n\r')
'\nx\r'
>>> re.sub(r'[\n\r]{1,2}$', '', '\nx\r\n')
'\nx'

Ich habe das Gefühl, was die meisten Leute hier wirklich wollen, ist, nur ein Vorkommen eines nachgestellten Zeilenumbruchs zu entfernen , entweder \r\noder \nund nichts weiter.

>>> re.sub(r'(?:\r\n|\n)$', '', '\nx\n\n', count=1)
'\nx\n'
>>> re.sub(r'(?:\r\n|\n)$', '', '\nx\r\n\r\n', count=1)
'\nx\r\n'
>>> re.sub(r'(?:\r\n|\n)$', '', '\nx\r\n', count=1)
'\nx'
>>> re.sub(r'(?:\r\n|\n)$', '', '\nx\n', count=1)
'\nx'

(Das ?:ist, um eine nicht erfassende Gruppe zu erstellen.)

(Übrigens ist dies nicht das, was '...'.rstrip('\n', '').rstrip('\r', '')für andere, die über diesen Thread stolpern, möglicherweise nicht klar ist. str.rstripEntfernt so viele der nachfolgenden Zeichen wie möglich, sodass eine Zeichenfolge wie foo\n\n\nein falsches Positiv von ergibt, foowährend Sie möglicherweise die beibehalten möchten andere Zeilenumbrüche nach dem Entfernen eines einzelnen nachfolgenden.)

>>> '   spacious   '.rstrip()
'   spacious'
>>> "AABAA".rstrip("A")
  'AAB'
>>> "ABBA".rstrip("AB") # both AB and BA are stripped
   ''
>>> "ABCABBA".rstrip("AB")
   'ABC'

Benutz einfach :

line = line.rstrip("\n")

oder

line = line.strip("\n")

Sie brauchen nichts von diesem komplizierten Zeug

s = '''Hello  World \t\n\r\tHi There'''
# import the module string   
import string
# use the method translate to convert 
s.translate({ord(c): None for c in string.whitespace}
>>'HelloWorldHiThere'

Mit Regex

s = '''  Hello  World 
\t\n\r\tHi '''
print(re.sub(r"\s+", "", s), sep='')  # \s matches all white spaces
>HelloWorldHi

Ersetzen Sie \ n, \ t, \ r

s.replace('\n', '').replace('\t','').replace('\r','')
>'  Hello  World Hi '

Mit Regex

s = '''Hello  World \t\n\r\tHi There'''
regex = re.compile(r'[\n\r\t]')
regex.sub("", s)
>'Hello  World Hi There'

mit Join

s = '''Hello  World \t\n\r\tHi There'''
' '.join(s.split())
>'Hello  World Hi There'

Es gibt drei Arten von Zeilenenden , dass wir normalerweise auftreten: \n, \rund \r\n. Ein ziemlich einfacher regulärer Ausdruck in re.subnämlich r"\r?\n?$"kann sie alle fangen.

(Und wir müssen sie alle fangen , habe ich recht?)

import re

re.sub(r"\r?\n?$", "", the_text, 1)

Mit dem letzten Argument begrenzen wir die Anzahl der ersetzten Vorkommen auf eins und ahmen Chomp bis zu einem gewissen Grad nach. Beispiel:

import re

text_1 = "hellothere\n\n\n"
text_2 = "hellothere\n\n\r"
text_3 = "hellothere\n\n\r\n"

a = re.sub(r"\r?\n?$", "", text_1, 1)
b = re.sub(r"\r?\n?$", "", text_2, 1)
c = re.sub(r"\r?\n?$", "", text_3, 1)

... wo a == b == cist True.

Wenn Sie sich Gedanken über die Geschwindigkeit machen (sagen wir, Sie haben eine lange Liste von Zeichenfolgen) und die Art des Newline-Zeichens kennen, ist das Schneiden von Zeichenfolgen tatsächlich schneller als rstrip. Ein kleiner Test, um dies zu veranschaulichen:

import time

loops = 50000000

def method1(loops=loops):
    test_string = 'num\n'
    t0 = time.time()
    for num in xrange(loops):
        out_sting = test_string[:-1]
    t1 = time.time()
    print('Method 1: ' + str(t1 - t0))

def method2(loops=loops):
    test_string = 'num\n'
    t0 = time.time()
    for num in xrange(loops):
        out_sting = test_string.rstrip()
    t1 = time.time()
    print('Method 2: ' + str(t1 - t0))

method1()
method2()

Ausgabe:

Method 1: 3.92700004578
Method 2: 6.73000001907

Dies funktioniert sowohl für Windows als auch für Linux (etwas teuer mit re sub, wenn Sie nur nach re Lösung suchen)

import re 
if re.search("(\\r|)\\n$", line):
    line = re.sub("(\\r|)\\n$", "", line)

Trennen Sie zuerst die Linien und verbinden Sie sie dann mit einem beliebigen Trennzeichen:

x = ' '.join(x.splitlines())

sollte wie ein Zauber wirken.

Ein Haken an alle:

line = line.rstrip('\r|\n')