Como posso remover uma nova linha à direita?

Qual é o equivalente em Python da chompfunção Perl , que remove o último caractere de uma string se for uma nova linha?

Experimente o método rstrip()(consulte a documentação Python 2 e Python 3 )

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

O rstrip()método do Python retira todos os tipos de espaços em branco à direita por padrão, não apenas uma nova linha como o Perl faz chomp.

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

Para retirar apenas novas linhas:

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

Existem também os métodos lstrip()e 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'

E eu diria que a maneira "pitônica" de obter linhas sem rastrear caracteres de nova linha é splitlines ().

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

A maneira canônica de remover os caracteres de fim de linha (EOL) é usar o método string strstrip () removendo qualquer \ r ou \ n à direita. Aqui estão exemplos de caracteres Mac, Windows e Unix EOL.

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

Usar '\ r \ n' como parâmetro para rstrip significa que ele removerá qualquer combinação à direita de '\ r' ou '\ n'. É por isso que funciona nos três casos acima.

Essa nuance é importante em casos raros. Por exemplo, uma vez tive que processar um arquivo de texto que continha uma mensagem HL7. O padrão HL7 requer um '\ r' à direita como seu caractere EOL. A máquina Windows em que eu estava usando esta mensagem anexou seu próprio caractere EOL '\ r \ n'. Portanto, o final de cada linha parecia '\ r \ r \ n'. Usar rstrip ('\ r \ n') teria retirado todo o '\ r \ r \ n', que não era o que eu queria. Nesse caso, simplesmente cortei os dois últimos caracteres.

Observe que, diferentemente da chompfunção do Perl , isso remove todos os caracteres especificados no final da string, não apenas um:

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

Note que o rstrip não age exatamente como o chomp () do Perl porque não modifica a string. Ou seja, no Perl:

$x="a\n";

chomp $x

resulta em $xser "a".

mas em Python:

x="a\n"

x.rstrip()

significa que o valor de aindax é . Nem sempre dá o mesmo resultado, pois retira todo o espaço em branco do final da string, e não apenas uma nova linha no máximo. "a\n"x=x.rstrip()

Eu poderia usar algo como isto:

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

Acho que o problema rstrip("\n")é que você provavelmente desejará garantir que o separador de linhas seja portátil. (há rumores de que alguns sistemas antiquados "\r\n"). A outra pegadinha é a de rstripremover os espaços em branco repetidos. Esperançosamente os.linesepconterá os caracteres certos. o acima funciona para mim.

Você pode usar line = line.rstrip('\n'). Isso removerá todas as novas linhas do final da cadeia, não apenas uma.

s = s.rstrip()

removerá todas as novas linhas no final da string s. A atribuição é necessária porque rstripretorna uma nova sequência em vez de modificar a sequência original.

Isso replicaria exatamente o chomp do perl (menos o comportamento nas matrizes) para o "\ n" terminador de linha:

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

(Nota: ele não modifica a string 'in place'; não remove o espaço em branco extra; leva \ r \ n em consideração)

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

ou você sempre pode ficar mais geek com regexps :)

diverta-se!

você pode usar strip:

line = line.strip()

demo:

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

O rstrip não faz a mesma coisa que o chomp, em muitos níveis. Leia http://perldoc.perl.org/functions/chomp.html e veja que o chomp é realmente muito complexo.

No entanto, meu ponto principal é que o chomp remove no máximo 1 linha final, enquanto o rstrip remove o máximo possível.

Aqui você pode ver o rstrip removendo todas as novas linhas:

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

Uma aproximação muito mais próxima do uso típico do Perl chomp pode ser realizada com o re.sub, assim:

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

Cuidado com "foo".rstrip(os.linesep): Isso apenas incluirá os caracteres de nova linha da plataforma em que seu Python está sendo executado. Imagine que você está chimping as linhas de um arquivo do Windows no Linux, por exemplo:

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

Use "foo".rstrip("\r\n"), como Mike diz acima.

Um exemplo na documentação do Python simplesmente usa line.strip().

A chompfunção Perl remove uma sequência de quebra de linha do final de uma string apenas se ela estiver realmente lá.

Aqui está como eu planejo fazer isso no Python, se processé conceitualmente a função que eu preciso para fazer algo útil para cada linha deste arquivo:

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)

Eu não programo em Python, mas me deparei com uma FAQ no python.org defendendo S.rstrip ("\ r \ n") para python 2.2 ou posterior.

import re

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

Eu acho conveniente poder obter as linhas chomped via iterator, paralelamente à maneira como você pode obter as linhas chomped de um objeto de arquivo. Você pode fazer isso com o seguinte código:

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

Uso da amostra:

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

solução alternativa para caso especial:

se o caractere de nova linha for o último caractere (como é o caso da maioria das entradas de arquivo), para qualquer elemento da coleção, você poderá indexar da seguinte maneira:

foobar= foobar[:-1]

para cortar seu caractere de nova linha.

Se sua pergunta é limpar todas as quebras de linha em um objeto de várias linhas str (oldstr), você pode dividi-lo em uma lista de acordo com o delimitador '\ n' e ingressar nessa lista em uma nova str (newstr).

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

Parece que não existe um análogo perfeito para o chomp do perl . Em particular, o rstrip não pode lidar com delimitadores de nova linha com vários caracteres, como \r\n. No entanto, as linhas de divisão fazem como indicado aqui . Após minha resposta em uma pergunta diferente, você pode combinar linhas de junção e de divisão para remover / substituir todas as novas linhas de uma sequência s:

''.join(s.splitlines())

O seguinte remove exatamente uma nova linha à direita (como o chomp faria, acredito). Passar Truecomo keependsargumento para linhas de divisão mantém os delimitadores. Em seguida, as linhas de divisão são chamadas novamente para remover os delimitadores apenas na última "linha":

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

Estou borbulhando minha resposta com base em expressões regulares de uma que eu postei anteriormente nos comentários de outra resposta. Eu acho que usar reé uma solução mais clara e explícita para esse problema do que str.rstrip.

>>> import re

Se você deseja remover um ou mais caracteres de nova linha à direita :

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

Se você deseja remover os caracteres de nova linha em qualquer lugar (não apenas à direita):

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

Se você quiser remover apenas 1-2 caracteres final de linha (ou seja, \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'

Sinto que o que a maioria das pessoas realmente deseja aqui é remover apenas uma ocorrência de um caractere de nova linha à direita, um \r\nou \nmais nada.

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

(O ?:objetivo é criar um grupo que não seja de captura.)

(A propósito, isso não é o que '...'.rstrip('\n', '').rstrip('\r', '')faz, o que pode não estar claro para os outros que se deparam com esse encadeamento. str.rstripRetira o máximo possível de caracteres finais; portanto, um encadeamento semelhante foo\n\n\nresultaria em um falso positivo, fooenquanto você pode querer preservar o outras linhas novas após remover uma única linha à direita.)

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

Apenas use :

line = line.rstrip("\n")

ou

line = line.strip("\n")

Você não precisa de nada disso complicado

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'

Com regex

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

Substituir \ n, \ t, \ r

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

Com regex

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

com Join

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

Existem três tipos de finais de linha que normalmente encontrar: \n, \re \r\n. Uma expressão regular bastante simples re.sub, a saber r"\r?\n?$", é capaz de capturá-los todos.

(E temos que pegá-los todos , estou certo?)

import re

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

Com o último argumento, limitamos o número de ocorrências substituídas a uma, imitando o chomp até certo ponto. Exemplo:

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)

... onde a == b == cé True.

Se você está preocupado com a velocidade (digamos que você tenha uma lista longa de strings) e conhece a natureza do caractere de nova linha, o fatiamento de strings é realmente mais rápido que o rstrip. Um pequeno teste para ilustrar isso:

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

Resultado:

Method 1: 3.92700004578
Method 2: 6.73000001907

Isso funcionará tanto para Windows quanto para Linux (um pouco caro com re sub se você estiver procurando apenas uma solução)

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

Primeiro divida as linhas e junte-as a qualquer separador que desejar:

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

deve funcionar como um encanto.

Uma captura de todos:

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