Jak mogę usunąć końcowy znak nowej linii?

1688

Co to jest odpowiednik funkcji Perla w Pythonie chomp, która usuwa ostatni znak ciągu, jeśli jest to nowy wiersz?

Georgy
źródło
2
Superset: dowolny ciąg zamiast nowego wiersza: stackoverflow.com/questions/1038824/...
Ciro Santilli 26 病毒 审查 六四 事件 法轮功
3
Odpowiedź A + jest taka, że ​​jeśli wynikało to z zapomnienia open()pliku z odpowiednim parametrem „newline = ...” dla twojej platformy (uniwersalna obsługa nowego wiersza), być może nie będziesz musiał jawnie go usuwać.
smci,

Odpowiedzi:

1868

Wypróbuj metodę rstrip()(zobacz dokument Python 2 i Python 3 )

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

rstrip()Metoda Pythona domyślnie usuwa wszystkie końcowe białe znaki, a nie tylko jedną nową linię, jak robi to Perl chomp.

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

Aby usunąć tylko nowe linie:

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

Istnieją również metody lstrip()i 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'
Markus Jarderot
źródło
22
Nie jestem osobą w Pythonie, więc nie mam na to odpowiedzi, ale chomp () Perla faktycznie usuwa separator rekordów wejściowych od końca. Jest to nowa linia na Unixy, ale może być inna (np. Windows) i może być zmienna. Czy istnieje sposób, aby usunąć tę wartość tylko raz z końca łańcucha?
brian d foy
5
brian d foy: Python nie ma separatora rekordów wejściowych, takiego jak awk i Perl.
Peter Hosey,
7
@csde_rats, to nieprawda: OS X używa \nnowych linii tak jak Unix. (Przed OS X MacOS używał \rseparatora linii, ale skończyło się to 10 lat temu.)
skue
21
@briandfoy Python ma wbudowaną obsługę Universal newlines (tylko podczas czytania, a nie podczas pisania). Plik otwierasz w trybie „U” lub „rU”, a następnie niezależnie od systemu Windows, Linux, Mac, cokolwiek, zanim tekst dotrze do kodu Pythona, każdy styl nowej linii został zastąpiony przez „\ n”. Patrz: python.org/dev/peps/pep-0278
AlcubierreDrive,
12
Idę do przodu i przeliteruję to, ponieważ jestem noobem i spędziłem trochę czasu zastanawiając się, dlaczego to nie działa. .strip()nie zmienia łańcucha (prawdopodobnie ma coś wspólnego z niezmiennymi łańcuchami). Jeśli nie w wierszu poleceń, będziesz chciał"string = string.strip()"
Script Kitty
146

Kanonicznym sposobem usuwania znaków końca wiersza (EOL) jest użycie metody string rstrip () usuwającej końcowe \ r lub \ n. Oto przykłady znaków EOL dla komputerów Mac, Windows i Unix.

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

Użycie „\ r \ n” jako parametru rstrip oznacza, że ​​usunie on dowolną kombinację końcową „\ r” lub „\ n”. Dlatego działa we wszystkich trzech powyższych przypadkach.

Ten niuans ma znaczenie w rzadkich przypadkach. Na przykład kiedyś musiałem przetworzyć plik tekstowy zawierający komunikat HL7. Standard HL7 wymaga znaku „\ r” jako znaku EOL. Komputer z systemem Windows, na którym korzystałem z tego komunikatu, dodał własny znak EOL „\ r \ n”. Dlatego koniec każdej linii wyglądał jak „\ r \ r \ n”. Użycie rstrip („\ r \ n”) usunęłoby całe „\ r \ r \ n”, co nie jest tym, czego chciałem. W takim przypadku po prostu odciąłem dwa ostatnie znaki.

Zauważ, że w przeciwieństwie do chompfunkcji Perla , spowoduje to usunięcie wszystkich określonych znaków na końcu łańcucha, a nie tylko jednego:

>>> "Hello\n\n\n".rstrip("\n")
"Hello"
Mikrofon
źródło
7
Pamiętaj, że nowoczesne aplikacje Mac OS X używają \ n. Używają tylko starych aplikacji Carbon oryginalnie napisanych dla systemu Mac OS.
Peter Hosey,
2
Dziękuję za wyjaśnienie. Oczywiście pas startowy ('\ r \ n') nadal działa w tym przypadku.
Mike,
13
Istnieje również os.linesep, który zawiera sekwencję EOL dla bieżącego systemu operacyjnego.
Eli Collins,
To najlepsza odpowiedź: usuwa tylko nowe linie i robi to poprawnie dla najpopularniejszych platform.
kevinarpe
plus +1 Za użycie \ni\r
fechnert
99

Zauważ, że rstrip nie działa dokładnie tak samo jak chomp () Perla, ponieważ nie modyfikuje łańcucha. To znaczy w Perlu:

$x="a\n";

chomp $x

skutkuje $xbyciem "a".

ale w Pythonie:

x="a\n"

x.rstrip()

oznacza, że ​​wartość xjest nadal "a\n" . Nawet x=x.rstrip()nie zawsze daje taki sam wynik, ponieważ usuwa wszystkie białe znaki z końca łańcucha, a nie tylko jedną nową linię.

Flimm
źródło
7
Ponadto strip () usuwa powtarzające się znaki, podczas gdy chop / chomp usuwa tylko jedną
nową linię
50

Mogę użyć czegoś takiego:

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

Myślę, że problem rstrip("\n")polega na tym, że prawdopodobnie będziesz chciał upewnić się, że separator linii jest przenośny. (podobno używa się niektórych przestarzałych systemów "\r\n"). Inna gotcha polega na rstripusunięciu powtarzających się białych znaków. Mam nadzieję os.linesep, że będzie zawierać właściwe postacie. powyższe działa dla mnie.

Jamie
źródło
12
Nie zadziała to jednak, jeśli próbujesz wyczyścić treści przesłane przez użytkownika w aplikacji internetowej. Treści użytkownika mogą pochodzić z dowolnego źródła i zawierać dowolne znaki nowej linii.
apiguy
2
Dobra uwaga, z tym wyjątkiem, że możesz przetwarzać pliki „obce” (z przestarzałych systemów) w swoim nowoczesnym systemie operacyjnym.
ChuckCottrill
1
Pamiętaj również, że jeśli czytasz plik w trybie tekstowym, nie będzie to również działać w systemie Windows, ponieważ końcowy znak zawsze zostanie przekonwertowany na „\ n”.
Szalony fizyk
@MadPhysicist Masz rację, że konwertuje go, ale nadal działa, ponieważ jest taki sam rstrip('\r\n')i rstrip()usuwa wszystkie znaki, które są w argumencie.
dtauxe
41

Możesz użyć line = line.rstrip('\n'). Spowoduje to usunięcie wszystkich nowych linii z końca łańcucha, a nie tylko jednego.

Kiriloff
źródło
35
s = s.rstrip()

usunie wszystkie znaki nowej linii na końcu ciągu s. Przypisanie jest potrzebne, ponieważ rstripzwraca nowy ciąg zamiast modyfikować oryginalny ciąg.

slec
źródło
33

Powtórzyłoby to dokładnie chomp perla (minus zachowanie na tablicach) dla terminatora linii „\ n”:

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

(Uwaga: nie modyfikuje ciągu „na miejscu”; nie usuwa dodatkowych spacji końcowych; bierze pod uwagę \ r \ n)

Alien Life Form
źródło
27
"line 1\nline 2\r\n...".replace('\n', '').replace('\r', '')
>>> 'line 1line 2...'

lub zawsze możesz dostać geekier z regexps :)

baw się dobrze!

mihaicc
źródło
Działa to świetnie dla mnie, próbując szybko zamienić plik tekstowy z zakończeniami linii w jedną linię tekstu. Jestem nowicjuszem, więc nie jestem pewien, czy jest lepszy sposób, ale zadziałało, dzięki! (Strip zdawał się działać tylko od końca, a nie wewnętrznie)
Steve Koch
2
Dlaczego nie użyć tylko jednej instrukcji zamiany, takiej jak .replace('\n|\r', '')?
Klamka
2
Na wypadek, gdyby ktokolwiek chciał skorzystać z pomysłu z @DoorknobofSnow, wystarczy niewielka zmiana w użyciu modułu wyrażeń regularnych: import re re.sub('\n|\r', '', '\nx\n\r\n')==> 'x'.
Taylor Edmiston
Wykorzystanie tej techniki i wyrażeń regularnych, jak wspomniano w @TaylorEdmiston, powinno być właściwą odpowiedzią.
Bhargav
@Bhargav Dodałem odpowiedź na to pytanie w oparciu o ten komentarz, jak zasugerowałeś, jednocześnie badając kilka innych powiązanych opcji. Wyjaśniłem również, dlaczego myślę, że wyrażenie regularne jest lepszym rozwiązaniem tego problemu niż str.rstrip, ponieważ tego używa większość odpowiedzi.
Taylor Edmiston
27

możesz użyć paska:

line = line.strip()

próbny:

>>> "\n\n hello world \n\n".strip()
'hello world'
Hackaholic
źródło
1
Wypróbowałem to rozwiązanie, ale usuwa on wiodące spacje w linii.
Tarik
@Tarik możesz użyć rstrip
Hackaholic
rstrip usunie wszystkie końcowe białe znaki, w przeciwieństwie do chomp, który usuwa tylko co najwyżej jedną nową linię.
Flimm
20

rstrip nie robi tego samego co chomp, na tak wielu poziomach. Przeczytaj http://perldoc.perl.org/functions/chomp.html i przekonaj się, że chomp jest naprawdę bardzo złożony.

Jednak moim głównym celem jest to, że chomp usuwa co najwyżej 1 koniec linii, podczas gdy rstrip usuwa tyle, ile może.

Tutaj możesz zobaczyć rstrip usuwający wszystkie nowe linie:

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

Znacznie bliższe przybliżenie typowego użycia chrupania Perla można uzyskać za pomocą re.sub, jak poniżej:

>>> re.sub(os.linesep + r'\Z','','foo\n\n')
'foo\n'
ingydotnet
źródło
2
Uznanie, jesteś jedynym, który wskazał na ten bardzo ważny szczegół. Jednak, jak ktoś wyżej zauważył, użycie os.linesep nie będzie działać, jeśli czytasz pliki z innego systemu. Może to zająć nieco więcej pracy w Pythonie, w rzeczywistości sprawdzanie końca linii.
brianmearns
19

Ostrożnie z "foo".rstrip(os.linesep): Spowoduje to jedynie zgryzienie znaków nowej linii dla platformy, na której wykonywany jest Twój Python. Wyobraź sobie, że pod Linuksem szczypiesz linie pliku Windows, na przykład:

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

Użyj "foo".rstrip("\r\n")zamiast tego, jak mówi Mike powyżej.

Carlos Valiente
źródło
Inną rzeczą, na którą należy zwrócić uwagę, jest to, że nie usuwa ona co najwyżej jednej nowej linii, ale w przeciwieństwie do wszystkich nowych linii chomp.
Flimm
19

Przykład w dokumentacji Pythona po prostu używa line.strip().

chompFunkcja Perla usuwa jedną sekwencję łamania linii z końca łańcucha tylko wtedy, gdy faktycznie tam jest.

Oto jak planuję to zrobić w Pythonie, jeśli processkoncepcyjnie jest to funkcja, której potrzebuję, aby zrobić coś użytecznego dla każdej linii z tego pliku:

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)
minopret
źródło
2
Wreszcie odpowiedź, która usuwa ją tylko raz (podobnie jak w rzeczywistości chomp ...) i jest przenośna dla systemu operacyjnego!
Ciro Santilli 冠状 病毒 审查 六四 事件 法轮功
13

Nie programuję w Pythonie, ale na python.org natknąłem się na często zadawane pytania dotyczące S.rstrip („\ r \ n”) dla Pythona w wersji 2.2 lub nowszej.

Andrew Grimm
źródło
10
import re

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

źródło
2
Spowoduje to również usunięcie białych znaków tabulacji, których pierwotne pytanie nie wymaga. (Ze względu na znak \ t)
NoahR
9

Uważam, że wygodnie jest mieć możliwość pobierania linii ubijanych w iteratorze, równolegle do sposobu, w jaki można uzyskać niepochmurne linie z obiektu pliku. Możesz to zrobić za pomocą następującego kodu:

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

Przykładowe użycie:

with open("file.txt") as infile:
    for line in chomped_lines(infile):
        process(line)
kuzzooroo
źródło
Uwaga: Z operator.methodcalleri map( itertools.imapna Py2) można popchnąć tę pracę do warstwy C, unikając Python generator kodu poziom (a tym samym działa nieco szybciej, choć trzeba przyznać I / O koszt jest prawdopodobne, aby zamaskować niewielkie zyski) for line in map(operator.methodcaller('rstrip', '\r\n'), infile):. Nadal można go rozróżnić jako def chomped_lines(it): return map(operator.methodcaller('rstrip', '\r\n'), it).
ShadowRanger,
8

rozwiązanie obejścia dla specjalnego przypadku:

jeśli znak nowej linii jest ostatnim znakiem (jak ma to miejsce w przypadku większości plików wejściowych), to dla dowolnego elementu w kolekcji można indeksować w następujący sposób:

foobar= foobar[:-1]

aby wyciąć swój znak nowej linii.

Chij
źródło
3
Czasami nowa linia nie jest ostatnim znakiem, ale ostatnimi, szczególnie w systemie Windows, jak zauważyli inni.
Cacovsky
8

Jeśli Twoim zadaniem jest wyczyszczenie wszystkich podziałów linii w obiekcie o wielu liniach str (oldstr), możesz podzielić go na listę zgodnie z ogranicznikiem „\ n”, a następnie dołączyć tę listę do nowego str (newstr).

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

Leozj
źródło
7

Wygląda na to, że nie jest to idealne analogowe Perl chomp . W szczególności rstrip nie może obsługiwać wieloznakowych ograniczników nowej linii, takich jak \r\n. Jednak splitlines nie jak wskazał tutaj . Po mojej odpowiedzi na inne pytanie, możesz łączyć złączenia i linie podziału, aby usunąć / zastąpić wszystkie znaki nowej linii s:

''.join(s.splitlines())

Poniższe usuwa dokładnie jedną końcową nową linię (jak sądzę chomp). Przekazywanie Truejako keependsargument linii podziału zachowuje ograniczniki. Następnie ponownie uruchamiane są linie podziału, aby usunąć ograniczniki tylko w ostatniej „linii”:

def chomp(s):
    if len(s):
        lines = s.splitlines(True)
        last = lines.pop()
        return ''.join(lines + last.splitlines())
    else:
        return ''
użytkownik3780389
źródło
7

Mam na uwadze moją odpowiedź opartą na wyrażeniach regularnych z tej, którą zamieściłem wcześniej w komentarzach do innej odpowiedzi. Myślę, że używanie rejest wyraźniejszym i bardziej wyraźnym rozwiązaniem tego problemu niż str.rstrip.

>>> import re

Jeśli chcesz usunąć jeden lub więcej końcowych znaków nowego wiersza:

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

Jeśli chcesz wszędzie usuwać znaki nowego wiersza (nie tylko końcowe):

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

Jeśli chcesz usunąć tylko 1-2 doczepiany znaki nowej linii (czyli \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'

Mam uczucie, co większość ludzi naprawdę chcesz tu jest usunięcie tylko jedno wystąpienie znaku nowej linii spływu, albo \r\nalbo \ni nic więcej.

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

(Ma ?:to na celu utworzenie grupy nie przechwytywania).

(Nawiasem mówiąc, to nie jest to '...'.rstrip('\n', '').rstrip('\r', ''), co może nie być jasne dla innych, którzy natkną się na ten wątek. str.rstripUsuwa tyle znaków, ile to możliwe, więc ciąg taki foo\n\n\ndałby fałszywy wynik pozytywny, foopodczas gdy być może chciałbyś zachować inne znaki nowej linii po usunięciu jednego końcowego).

Taylor Edmiston
źródło
Za pomocą wyrażenia regularnego możesz pominąć grupę, która nie została przechwycona, nawet w celu ostatecznego podejścia r'\r?\n$'. Prawdopodobnie bardziej wydajny, ponieważ silniki regex mają trudniej optymalizować alternatywy. Zauważ też, że jeśli będziesz to robił wiele razy, będzie to znacznie szybsze (szczególnie jeśli masz do czynienia z innymi rezastosowaniami) re.compilew wyrażeniu raz na raz, a następnie użyj submetody skompilowanego obiektu wyrażenia regularnego; funkcje modułu są na poziomie Pythona i najpierw sprawdzają pamięć podręczną dla skompilowanych wyrażeń regularnych (tworzenie / buforowanie, jeśli brakuje), a następnie wywołują metodę dopasowywania; pomijanie tego wyszukiwania pomaga.
ShadowRanger,
1
Dodatkowo uwaga: Ponieważ próbujesz dopasować \nbezpośrednio, możesz chcieć użyć \Znad $(lub po prostu dopasować \r?$, ponieważ $niejawnie można dopasować tuż przed znakiem nowej linii na końcu łańcucha).
ShadowRanger,
5
>>> '   spacious   '.rstrip()
'   spacious'
>>> "AABAA".rstrip("A")
  'AAB'
>>> "ABBA".rstrip("AB") # both AB and BA are stripped
   ''
>>> "ABCABBA".rstrip("AB")
   'ABC'

źródło
Przykład, którego potrzebowałem! Więc rstrip („\ r \ n”) usunie zarówno „\ n”, jak i „\ r” w dowolnej kombinacji na końcu linii!
Agostino,
@Agostino Nie trzeba podawać "\r\n"Na przykład: ' spacious \n\r\n\r \n\n'.rstrip()produkuje' spacious'
olibre
2
@olibre kod, który sugerujesz, usunie również inne znaki spacji / spacji, które mogą nie być tym, czego potrzeba. W rzeczywistości musiałem tylko usunąć kombinacje znaków eol. Mimo to dziękuję za zwrócenie na to uwagi.
Agostino,
4

Po prostu użyj :

line = line.rstrip("\n")

lub

line = line.strip("\n")

Nie potrzebujesz żadnych z tych skomplikowanych rzeczy

Pomóż mi
źródło
2
Zauważ, że to nie to samo co chomp.
Flimm
4
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'

Z wyrażeniem regularnym

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

Zamień \ n, \ t, \ r

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

Z wyrażeniem regularnym

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

z Join

s = '''Hello  World \t\n\r\tHi There'''
' '.join(s.split())
>'Hello  World Hi There'
sim
źródło
3

Istnieją trzy typy zakończeń linii, które normalnie napotkać: \n, \ri \r\n. Raczej proste wyrażenie regularne w re.submianowicier"\r?\n?$" , jest w stanie złapać je wszystkie.

(I musimy ich wszystkich złapać , mam rację?)

import re

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

Ostatnim argumentem jest ograniczenie liczby zastąpień do jednego, do pewnego stopnia naśladując chomp. Przykład:

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)

... gdzie a == b == cjest True.

Internetowy
źródło
Nie potrzebujesz nawet pełnoprawnych wyrażeń regularnych. rstrip("\r\n")jest wszystkim. Spróbować print(text_2.rstrip('\r\n')).
Agostino,
@Agostino: Prawda, biorąc pod uwagę, że to str.rstrip()rozwiązuje problem. To zależy od twoich potrzeb. To rozwiązanie jest wykonany specjalnie dla przypadków, gdy trzeba usunąć tylko ostatnią "\n", "\r"czy "\r\n"jednak nie wszystkie z nich (jeśli istnieje wiele "\n"w ciągu). re.sub(r"\r?\n?$", "", text_1, 1)zwraca "hellothere\n\n"i text_1.rstrip("\r\n")zwraca "hellothere"inny ciąg.
internetowy
To, co próbuję powiedzieć, to: str.strip()to wszystko jest czasem problemem.
internetowy
1

Jeśli martwisz się szybkością (powiedz, że masz długą listę łańcuchów) i znasz charakter znaku nowej linii, przecinanie łańcucha jest w rzeczywistości szybsze niż rstrip. Mały test ilustrujący to:

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()

Wynik:

Method 1: 3.92700004578
Method 2: 6.73000001907
Stephen Miller
źródło
Wiem, że prawdopodobnie powinienem używać „globalnych pętli” wewnątrz funkcji, ale to również działa.
Stephen Miller
Ten test jest nie tak i nie fair .. W method1dopiero odcięcie ostatniego znaku, bez względu na to, w method2tych .rstrip()pierwszych kontroli, jeżeli końca łańcucha znaków zawierającego niepożądane i kotlety je tylko wtedy, gdy niektóre zostały znalezione. Zaimplementuj sprawdzanie znaków method1i ponownie przetestuj!
spky
Jak powiedziałem we wstępie do odpowiedzi: jeśli znasz charakter znaku nowej linii, jest to przydatne. Jeśli nie, to oczywiście musisz wdrożyć sprawdzanie postaci - lub po prostu użyć rstrip. Nie chciałem być „niesprawiedliwy”, aby położyć kres, ale po prostu zilustrować nie tak nieznaczną różnicę, którą warto rozważyć w niektórych sytuacjach.
Stephen Miller
1

Będzie to działać zarówno w systemie Windows, jak i Linux (nieco drogie z re-sub, jeśli szukasz tylko ponownego rozwiązania)

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

Venfah Nazir
źródło
3
Po co korzystać z tego, re.searchczego potrzebujesz re.sub?
wjandrea
0

Najpierw podziel linie, a następnie połącz je dowolnymi separatorami:

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

powinien działać jak urok.

Głęboki błękit
źródło
-1

Złap wszystko:

line = line.rstrip('\r|\n')
użytkownik4178860
źródło
5
rstripnie przyjmuje wyrażeń regularnych. "hi|||\n\n".rstrip("\r|\n")powroty"hi"
Flimm