Wie Entferne ich einen trailing newline?

Was ist das Python äquivalent von Perl - chomp Funktion, die entfernt das Letzte Zeichen eines string, wenn es ein Zeilenumbruch ist?

  • Obermenge: jede Zeichenkette, statt nur Zeilenvorschub: stackoverflow.com/questions/1038824/...
  • Die A+ - Antwort ist, wenn diese fällig war, zu vergessen, um open() eine Datei mit den entsprechenden 'newline=...', parameter für Ihre Plattform (universal newline support), können Sie nicht brauchen, um explizit zu entfernen.
InformationsquelleAutor | 2008-11-08
  1. 1648

    Versuchen, die Methode rstrip() (siehe doc Python 2 und Python 3)

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

    Python ' s rstrip() Methode Streifen alle Arten von trailing-whitespaces werden standardmäßig nicht nur ein newline als Perl hat mit Mampf.

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

    Streifen nur Zeilenumbrüche:

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

    Dort sind 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'
    • Ich bin kein Python-person, so habe ich nicht die Antwort auf diese, aber Perl chomp() entfernt tatsächlich den input record separator vom Ende. Das ist ein newline auf Unixy Dinge, die aber unterschiedlich sein kann (z.B. Windows) und es ist veränderlich. Gibt es eine Möglichkeit zu entfernen, dass der Wert nur einmal am Ende einer Schnur?
    • brian d foy: Python muss nicht eine input record separator, wie awk und Perl haben.
    • \N für ausreichend? >>> "test" string\r\n".rstrip("\n") 'test string\r'
    • \r selbst wird nicht ausgelöst, eine newline überall (außer für OSX, aber wen interessiert OSX?)
    • das stimmt nicht: OS X verwendet \n für Zeilenumbrüche genauso wie Unix. (Vor OS X, MacOS habe \r als line-Trenner, aber das endete vor 10 Jahren.)
    • Python hat eine eingebaute Unterstützung für Universal-newlines (nur beim Lesen, nicht beim schreiben). Sie öffnen die Datei in entweder "U" oder "rU" - Modus, und dann unabhängig von Windows, Linux, Mac, was auch immer, durch die Zeit, die der text erreicht Sie Ihre python-code, ist jede Art von "newline" ersetzt wurde durch "\n". Siehe: python.org/dev/peps/pep-0278
    • Dies entfernt nur das erste \n nicht alle \n ' s. Was ist, wenn ich einen string wie: "sadsa\nsadas\nsadsad\n" Wie kann ich entfernen Sie ALLE Zeilenumbrüche? replace('\n', ") funktioniert auch nicht.
    • Nur für den Fall jemand missverstehen Beispiel: das argument für strip, rstrip, lstrip wird als eine Liste von Zeichen, kein string. So 'abcdedcba'.strip("abc") gibt def, nicht cdedcba!
    • Was ist mit Windows? Wenn Sie entfernen die \n erhalten Sie noch \r.
    • Ich denke du meinst 'ded', nicht 'def'. 🙂
    • Wie oben von @AlcubierreDrive, Handhabung von Zeilenumbrüchen in einer tragbaren Weise bedeutet, Sie werden in der kanonischen \n bilden, wenn Sie aus der Datei gelesen werden. Dann, Ihr Programm, die Arbeit mit Streichern wird es nie sehen \r Zeichen.
    • Ich weiß, das ist nicht wirklich eine Frage, aber gebracht ist, in die Kommentare. Gibt es einen Grund, warum text.rstrip(os.linesep) würde nicht funktionieren in einer OS-unabhängigen Weg, dies zu erreichen?
    • Ich werde weitermachen und Bann, weil ich bin ein noob und ich verbrachte eine Weile gefragt, warum es nicht funktioniert. .strip() nicht verändert die Zeichenfolge (hat wahrscheinlich etwas zu tun mit immutable strings). Wenn nicht in der Befehlszeile, Sie wollen "string = string.strip()"
    • rstrip() auf seine eigene, wird Ihnen eine Menge Kopfschmerzen, wenn Sie die Verarbeitung TSVs einige leere Spalten. Zum Beispiel "foo\tbar\t\t\n".rstrip() entfernt das Letzte von zwei leeren Spalten aus Ihren Daten.

    InformationsquelleAutor
  2. 151

    Und ich würde sagen, der "pythonic" Weg, um Linien ohne trailing newline " - Zeichen ist splitlines().

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

    Den kanonischen Weg zum strip end-of-line - (EOL -) Zeichen zu verwenden, die string rstrip () - Methode entfernen Sie nachgestellte \r oder \n ist. Hier sind 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'

    Verwendung von "\r\n " als parameter zu rstrip bedeutet, dass es Streifen aus nachgestellte Kombination von '\r' oder '\n'. Das ist, warum es funktioniert in allen drei Fällen vor.

    Diese nuance zählt in seltenen Fällen. Beispielsweise habe ich einmal zu Bearbeiten hatte, eine text-Datei, die enthalten eine HL7-Nachricht. Der HL7-standard verlangt ein abschließendes '\r' als EOL-Zeichen. Der Windows-Rechner, auf dem ich mit dieser Nachricht angehängt hatte seine eigene '\r\n' EOL-Zeichen. Daher am Ende jeder Zeile sah aus wie '\r\r\n'. Mit rstrip('\r\n') hätte sich die gesamte '\r\r\n', das ist nicht das, was ich wollte. In diesem Fall habe ich einfach abgeschnitten die letzten zwei Zeichen statt.

    Beachten Sie, dass im Gegensatz zu Perl - chomp Funktion, wird dieser Streifen alle angegebenen Zeichen am Ende des Strings, nicht nur eine:

    >>> "Hello\n\n\n".rstrip("\n")
"Hello"
    • Beachten Sie, dass moderne Mac-OS-X-apps \n". Nur alte Carbon-apps, die ursprünglich für Mac OS-verwenden \r.
    • Vielen Dank für die Klarstellung. Natürlich, die rstrip('\r\n') bleibt auch in diesem Fall.
    • Es gibt auch os.linesep enthält die EOL-Sequenz für das aktuelle OS.
    • Dies ist die beste Antwort: Es nur Streifen newlines, und tut es richtig für die gängigsten Plattformen.
    • plus +1 Für den Einsatz \n und \r
    • normalerweise, Sie sehen nicht \r im Eingang, weil Python nutzt universal-newlines-Modus standardmäßig ('\n', '\r' oder '\r\n' übersetzt werden '\n' beim Lesen). Wenn Sie möchten, zu berücksichtigen, Unicode-Zeilenumbrüche; siehe str.splitlines().
    • Upvoting, denn dies ist viel sicherer als rstrip() ohne Argumente.

    InformationsquelleAutor Mike
  4. 98

    Beachten Sie, dass rstrip nicht handeln genauso wie Perl chomp (), weil es nicht die Zeichenfolge ändern. Das ist in Perl:

    $x="a\n";

chomp $x

    Ergebnisse in $x wird "a".

    aber in Python:

    x="a\n"

x.rstrip()

    bedeutet, dass der Wert der x ist noch "a\n". Auch x=x.rstrip() nicht immer das gleiche Ergebnis, wie es entfernt alle whitespace-Zeichen am Ende der Zeichenfolge nicht nur eine newline am meisten.

    • Auch strip() entfernt wiederholten Zeichen in der Erwägung, dass chop/chomp entfernt nur ein newline
    • Ah ja, strings sind unveränderlich, danke für die Erinnerung!
    InformationsquelleAutor
  5. 48

    Ich könnte so etwas wie dieses:

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

    Ich denke, das problem mit rstrip("\n") ist, dass Sie wahrscheinlich wollen, um sicherzustellen, dass die line separator tragbar ist. (einige veraltete Systeme sind angeblich zu verwenden "\r\n"). Der andere Punkt ist, dass rstrip Streifen aus wiederholten Leerzeichen. Hoffentlich os.linesep enthält die richtigen Zeichen. die oben genannten arbeiten für mich.

    • Das wird nicht funktionieren, aber wenn Sie versuchen zu bereinigen, die von Benutzern eingereichten Inhalte in einer web-Anwendung. Die Benutzer-content aus jeder Quelle und enthalten alle neue-Zeile-Zeichen.
    • Guter Punkt, es sei denn, Sie werden Verarbeitung "fremder" Dateien (von antiquierten Systemen) auf dem modernen os.
    • Beachten Sie auch, dass, wenn Sie das Lesen einer Datei im text-Modus, das funktioniert nicht auf einem Windows system, da die nachfolgenden Zeichen werden immer konvertiert werden '\n'.
    • Sie haben Recht, dass es nicht konvertieren, aber es funktioniert immer noch, da ist es das gleiche wie rstrip('\r\n') und rstrip() Streifen alle Zeichen, die im argument.
    InformationsquelleAutor Jamie
  6. 39

    Können Sie verwenden line = line.rstrip('\n'). Dieser Streifen alle Zeilenumbrüche vom Ende der Zeichenfolge, nicht nur eine.

    InformationsquelleAutor kiriloff
  7. 32
    s = s.rstrip()

    entfernt alle Zeilenumbrüche am Ende des Strings s. Die Zuordnung ist erforderlich, da rstrip gibt einen neuen string, anstatt eine änderung der ursprünglichen Zeichenfolge.

    InformationsquelleAutor slec
  8. 28

    Diese würde exakt nachzubilden perl chomp (minus Verhalten auf arrays) für "\n" zeilenabschluss:

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

    (Anmerkung: es ist nicht zu ändern string "in place"; es nicht entfernen zusätzlicher Leerzeichen; ist \r\n-Konto)

    InformationsquelleAutor Alien Life Form
  9. 26

    können Sie mit strip:

    line = line.strip()

    demo:

    >>> "\n\n hello world \n\n".strip()
'hello world'
    • Versucht, diese Lösung, aber es entfernt führende Leerzeichen in der Zeile.
    • Sie können rstrip
    • rstrip löscht alle Leerzeichen, im Gegensatz zu chomp, die löscht nur höchstens eine Zeile.
    InformationsquelleAutor Hackaholic
  10. 25
    "line 1\nline 2\r\n...".replace('\n', '').replace('\r', '')
>>> 'line 1line 2...'

    oder Sie immer geekier mit regexps 🙂

    Spaß haben!

    • Dies funktionierte großartig für mich, der versucht, schnell wieder eine text-Datei mit der Zeile enden in einer Zeile text. Ich bin ein newbie, also nicht sicher, ob es einen besseren Weg, es zu tun, aber es hat geklappt, vielen Dank! (Streifen schien, nur von den enden, nicht intern)
    • Warum nicht einfach ein replace-Anweisung, wie .replace('\n|\r', '')?
    • funktioniert nicht
    • Nur im Fall, jemand will die Idee von @DoorknobofSnow, es ist nur eine kleine änderung, benutzen Sie den regex-Modul: import re re.sub('\n|\r', '', '\nx\n\r\n') ==> 'x'.
    • Mit dieser und regex-Technik, wie @TaylorEdmiston erwähnt werden sollte die richtige Antwort.
    • Ich habe eine Antwort auf diese Frage auf der Basis dieser Kommentar, wie Sie vorgeschlagen, während Sie erkunden auch noch ein paar andere Optionen. Ich auch geklärt, warum ich denke, regex ist eine bessere Lösung für dieses problem, als str.rstrip seit das ist, was die meisten Antworten verwenden.

    InformationsquelleAutor mihaicc
  11. 20

    Vorsichtig mit "foo".rstrip(os.linesep): Das wird nur chomp das newline Zeichen für die Plattform, wo Sie Ihre Python ausgeführt wird. Stell dir vor, du bist chimping die Zeilen einer Windows-Datei, unter Linux, 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 "foo".rstrip("\r\n") statt, wie Mike sagt, oben.

    • Die andere Sache zu beachten ist, dass es nicht entfernen, höchstens ein newline, aber alle Zeilenumbrüche, im Gegensatz zu chomp.
    InformationsquelleAutor Carlos Valiente
  12. 19

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

    Perl - chomp Funktion entfernt einen Zeilenumbruch der Sequenz vom Ende einer Zeichenfolge nur, wenn es wirklich da ist.

    Hier ist, wie ich Plane zu tun, dass in Python, wenn process ist konzeptionell die Funktion, die ich brauche, um etwas nützliches zu tun, um jede Zeile aus dieser Datei:

    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)
    • Endlich, eine Antwort, die nur entfernt es einmal (wie die tatsächliche chomp...) und ist OS tragbar!
    InformationsquelleAutor minopret
  13. 17

    rstrip nicht das gleiche tun wie chomp, auf so vielen Ebenen. Lesen http://perldoc.perl.org/functions/chomp.html und sehen, dass chomp ist sehr Komplex, in der Tat.

    Aber mein Hauptpunkt ist, dass chomp entfernt, höchstens 1 Linie endend, in der Erwägung, dass rstrip wird, entfernen Sie so viele wie Sie können.

    Hier sehen Sie rstrip das entfernen aller Zeilenumbrüche:

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

    Eine viel engere Annäherung der typischen Perl chomp-Auslastung kann erreicht werden, mit der re.sub, wie diese:

    >>> re.sub(os.linesep + r'\Z','','foo\n\n')
'foo\n'
    • Ein großes Lob, du bist die einzige, die darauf hingewiesen, dieses sehr wichtige detail. Aber, wie jemand oben erwähnt, mit Hilfe von os.linesep wird nicht funktionieren, wenn Sie Lesen, Dateien von einem anderen system. Dies könnte ein bisschen mehr Arbeit in Python, eigentlich der Inspektion am Ende der Zeile.
    InformationsquelleAutor ingydotnet
  14. 14

    Ich nicht das Programm in Python, aber ich kam über ein FAQ an python.org befürworten S. rstrip("\r\n") python 2.2 oder höher.

    InformationsquelleAutor Andrew Grimm
  15. 10
    import re

r_unwanted = re.compile("[\n\t\r]")
r_unwanted.sub("", your_text)
    • Das wird wohl auch Registerkarte entfernen Leerzeichen, die die ursprüngliche Frage nicht auf Anfrage. ( Wegen der \t-Zeichen )
    InformationsquelleAutor Halit Alptekin
  16. 8

    workaround-Lösung für den speziellen Fall:

    wenn der neue-Zeile-Zeichen ist das Letzte Zeichen (wie der Fall mit die meisten Datei-Eingänge), dann wird für jedes element in der Auflistung können Sie den index wie folgt: 

    foobar= foobar[:-1]

    slice Ihre neue-Zeile-Zeichen.

    • Manchmal ist der Zeilenumbruch ist nicht ein Letzte Zeichen, aber die letzten, die speziell auf windows, wie andere haben darauf hingewiesen.
    InformationsquelleAutor Chij
  17. 8

    Wenn Ihre Frage ist, zu bereinigen, alle Zeilenumbrüche in mehrzeiligen str-Objekt (oldstr), können Sie es aufgeteilt in eine Liste nach dem Trennzeichen '\n' und dann kommen Sie mit dieser Liste in eine neue, str(newstr).

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

    InformationsquelleAutor Leozj
  18. 7

    Ich finde es bequem zu haben in der Lage sein, um die chomped Linien über den in-iterator, parallel zum Weg, um die un-chomped Zeilen aus einer Datei-Objekt. Sie können dies mit dem folgenden code:

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

    Beispiel für die Nutzung:

    with open("file.txt") as infile:
    for line in chomped_lines(infile):
        process(line)
    • Hinweis: Mit operator.methodcaller und map (itertools.imap auf Py2) drücken Sie können diese Arbeit an der C-Schicht, die Vermeidung von Python-level-generator-code (und somit läuft ein bisschen schneller, obwohl-zugegeben-I/O-overhead ist wahrscheinlich, Maske, kleine Gewinne): for line in map(operator.methodcaller('rstrip', '\r\n'), infile):. Es könnte noch ausgeklammert, wie def chomped_lines(it): return map(operator.methodcaller('rstrip', '\r\n'), it).
    InformationsquelleAutor kuzzooroo
  19. 7

    Bin ich sprudeln meinen regulären Ausdruck basiert Antwort von einer, die ich weiter oben geschrieben, in den Kommentaren von anderen beantworten. Ich denke, mit re ist deutlicher, mehr explizite Lösung für dieses problem als str.rstrip.

    >>> import re

    Wenn Sie möchten, entfernen Sie eine oder mehrere nachfolgende newline chars:

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

    Wenn Sie entfernen möchten newline chars überall (nicht nur nachgestellt):

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

    Wenn Sie möchten, entfernen Sie nur 1-2 nachgestellte newline-Zeichen (D. H., \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'

    Habe ich das Gefühl, was die meisten Menschen wirklich wollen, hier, ist zu entfernen, nur eine auftreten von ein abschließendes newline-Zeichen, entweder \r\n oder \n und nichts mehr.

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

    (Die ?: zu schaffen, ist eine non-capturing-group.)

    (Dies ist übrigens nicht was '...'.rstrip('\n', '').rstrip('\r', '') tut, das kann nicht sein, klar, für andere das stolpern über diesen thread. str.rstrip Streifen als viele nachfolgende Zeichen wie möglich, damit ein string wie foo\n\n\n Ergebnis wäre ein false positive von foo in der Erwägung, dass Sie vielleicht wollte, um zu bewahren die andere Zeilenumbrüche nach dem Strippen einen einzigen trailing eine.)

    • Sie könnte überspringen Sie die non-capturing-group, auch für Ihre Letzte Ansatz, mit dem regex r'\r?\n$'. Wahrscheinlich effizienter, da regex-engines haben eine härtere Zeit zu optimieren-Wechsel. Beachten Sie auch, dass, wenn Sie gehen zu tun, das viele Male, aber deutlich schneller (vor allem, wenn Sie die Vermischung mit anderen re verwendet) zu re.compile den Ausdruck einmal vorne, dann verwenden Sie die sub - Methode der regex kompiliert Objekt; Modul-Funktionen sind Python-Ebene und lassen einen cache für kompilierte regexes ersten (Erstellung/Zwischenspeichern, wenn Sie fehlt), dann rufen die passende Methode; - skipping, die lookup hilft.
    • Auch, Seite-Hinweis: Da bist du, der versucht, die \n direkt, möchten Sie vielleicht die Verwendung \Z über $ (oder gleichen Sie einfach \r?$, da $ implizit kann mit nur vor dem newline am Ende einer Zeichenkette (string).
    InformationsquelleAutor Taylor Edmiston
  20. 6

    Sieht es aus wie es gibt nicht die eine perfekte analog zur perl -chomp. Insbesondere rstrip nicht in den Griff-multi-newline-Zeichen Trennzeichen wie \r\n. Allerdings splitlines hat wie schon hier.
    Folgende meine Antwort auf eine andere Frage, die Sie kombinieren können beitreten und splitlines zu entfernen/ersetzen alle Zeilenumbrüche aus einem string s:

    ''.join(s.splitlines())

    Den folgenden entfernt genau eine nachfolgende newline (wie chomp würde, glaube ich). Vorbei True als keepends argument splitlines behalten die Trennzeichen. Dann, splitlines erneut aufgerufen, um entfernen Sie die Klammern einfach auf die Letzte "line": 

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

    Verwenden Sie einfach : 

    line = line.rstrip("\n")

    oder

    line = line.strip("\n")

    Brauchen Sie nicht alle diese komplizierten Sachen

    • Beachten Sie, dass dies nicht das gleiche wie chomp.
    InformationsquelleAutor Help me
  22. 4
    >>> '   spacious   '.rstrip()
'   spacious'
>>> "AABAA".rstrip("A")
  'AAB'
>>> "ABBA".rstrip("AB") # both AB and BA are stripped
   ''
>>> "ABCABBA".rstrip("AB")
   'ABC'
    • Das Beispiel, das ich gebraucht! So rstrip("\r\n"), ziehen beide '\n' und '\r' in jeder Kombination, die am Ende der Zeile!
    • Keine Notwendigkeit "\r\n" Zum Beispiel: ' spacious \n\r\n\r \n\n'.rstrip() produziert ' spacious'
    • der code, den Sie vorschlagen, wird auch Streifen anderen blank/space-Zeichen, die möglicherweise nicht das, was man braucht. In der Tat, ich brauchte nur zu Streifen Kombinationen von eol-Zeichen. Trotzdem, vielen Dank für diesen Hinweis.
    InformationsquelleAutor
  23. 3

    Gibt es drei Arten von Zeilenenden, die wir normalerweise begegnen: \n, \r und \r\n. Einen eher einfachen regulären Ausdruck in re.sub, nämlich r"\r?\n?$" ist in der Lage, um Sie alle zu fangen.

    (Und wir gotta catch 'em all, hab ich Recht?)

    import re

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

    Mit dem letzten argument, beschränken wir die Anzahl der vorkommen ersetzt werden, um eine, die Nachahmung von chomp zu einem gewissen Grad. 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 == c ist True.

    • Sie brauchen noch nicht einmal vollwertige reguläre Ausdrücke. rstrip("\r\n") ist ein catch-all. Versuchen print(text_2.rstrip('\r\n')).
    • Wahr ist, gegeben, dass str.rstrip() löst das problem. Es hängt davon ab, welche Bedürfnisse Sie haben. Diese Lösung ist speziell für die Fälle, wenn Sie benötigen, entfernen Sie einfach die Letzte "\n", "\r" oder "\r\n" aber nicht alle von Ihnen (wenn es mehrere "\n" im string). re.sub(r"\r?\n?$", "", text_1, 1) zurück "hellothere\n\n" und text_1.rstrip("\r\n") zurück "hellothere" die eine andere Zeichenfolge.
    • Was ich versuche zu sagen ist: dass str.strip() ist ein catch-all ist manchmal das problem.
    InformationsquelleAutor internetional
  24. 2

    Dies funktioniert sowohl für windows und linux (etwas teuer mit re sub wenn Sie auf der Suche für nur re-Lösung)

    import re 
if re.search("(\\r|)\\n$", line):
    line = re.sub("(\\r|)\\n$", "", line)
    • Warum re.search wo Sie müssen nur re.sub?
    InformationsquelleAutor Venfah Nazir
  25. 1

    Wenn Sie besorgt über Geschwindigkeit (sagen wir, Sie haben eine laaange Liste von strings) und Sie wissen, dass die Art der newline-char, string-slicing ist tatsächlich schneller als rstrip. Einen kleinen 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
    • Ich weiß, ich sollte wahrscheinlich "global " loops" innerhalb der Funktionen, aber das funktioniert auch.
    • Dieser test ist nicht falsch und nicht fair.. In method1 Sie sind einfach abhacken das Letzte Zeichen, egal was, in method2 die .rstrip() zuerst überprüft, ob das Ende der Zeichenfolge enthält unerwünschte Zeichen und hackt Sie ab, nur wenn einige gefunden wurden. Bitte implementieren Sie einige Kontrollkästchen für Zeichen in method1 - und test-agin!
    • Wie gesagt im intro zur Antwort: Wenn Sie wissen, dass die Art der newline-char, dann ist dies nützlich. Wenn nicht, dann ja, werden Sie natürlich brauchen, um zu implementieren eine Art von Charakter schauen - oder nutzen Sie einfach rstrip. Ich meine nicht zu "unfair" zu rstrip, sondern einfach veranschaulichen, der einen nicht unbedeutenden Unterschied, dass möglicherweise eine überlegung Wert, in einigen Situationen.
    InformationsquelleAutor Stephen Miller
  26. -1

    Einen catch-all:

    line = line.rstrip('\r|\n')
    • rstrip nicht regulären Ausdruck. "hi|||\n\n".rstrip("\r|\n") zurück "hi"
    InformationsquelleAutor user4178860
Schreibe einen Kommentar