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

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

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'

Powiedziałbym, że „pytonicznym” sposobem uzyskiwania linii bez znaków końca linii jest splitline ().

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

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"

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ę.

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.

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

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.

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)

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

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

baw się dobrze!

możesz użyć paska:

line = line.strip()

próbny:

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

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'

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.

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)

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.

import re

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

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)

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.

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

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

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

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

Po prostu użyj :

line = line.rstrip("\n")

lub

line = line.strip("\n")

Nie potrzebujesz żadnych z tych skomplikowanych rzeczy

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'

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.

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

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)

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

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

powinien działać jak urok.

Złap wszystko:

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