¿Cómo puedo eliminar una nueva línea final?

¿Cuál es el equivalente de Python de la chompfunción de Perl , que elimina el último carácter de una cadena si es una nueva línea?

Prueba el método rstrip()(ver doc Python 2 y Python 3 )

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

El rstrip()método de Python elimina de forma predeterminada todo tipo de espacios en blanco al final, no solo una nueva línea como hace Perl chomp.

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

Para quitar solo nuevas líneas:

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

También existen los métodos lstrip()y 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'

Y yo diría que la forma "pitónica" de obtener líneas sin arrastrar caracteres de nueva línea es splitlines ().

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

La forma canónica de eliminar los caracteres de fin de línea (EOL) es utilizar el método de cadena rstrip () eliminando cualquier \ r o \ n final. Aquí hay ejemplos para Mac, Windows y personajes 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 eliminará cualquier combinación final de '\ r' o '\ n'. Es por eso que funciona en los tres casos anteriores.

Este matiz es importante en casos raros. Por ejemplo, una vez tuve que procesar un archivo de texto que contenía un mensaje HL7. El estándar HL7 requiere un '\ r' final como su carácter EOL. La máquina de Windows en la que estaba usando este mensaje había agregado su propio carácter '\ r \ n' EOL. Por lo tanto, el final de cada línea se parecía a '\ r \ r \ n'. El uso de rstrip ('\ r \ n') habría eliminado todo el '\ r \ r \ n', que no es lo que quería. En ese caso, simplemente corté los dos últimos caracteres.

Tenga en cuenta que, a diferencia de la chompfunción de Perl , esto eliminará todos los caracteres especificados al final de la cadena, no solo uno:

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

Tenga en cuenta que rstrip no actúa exactamente como Chomp () de Perl porque no modifica la cadena. Es decir, en Perl:

$x="a\n";

chomp $x

resulta en $xser "a".

pero en Python:

x="a\n"

x.rstrip()

significará que el valor de xes todavía "a\n" . Even x=x.rstrip()no siempre da el mismo resultado, ya que elimina todos los espacios en blanco desde el final de la cadena, no solo una nueva línea como máximo.

Podría usar algo como esto:

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

Creo que el problema rstrip("\n")es que probablemente querrás asegurarte de que el separador de línea sea portátil. (se rumorea que algunos sistemas anticuados usan "\r\n"). El otro problema es que rstripeliminará los espacios en blanco repetidos. Con suerte os.linesepcontendrá los personajes correctos. Lo anterior funciona para mí.

Puedes usar line = line.rstrip('\n'). Esto eliminará todas las líneas nuevas desde el final de la cadena, no solo una.

s = s.rstrip()

eliminará todas las nuevas líneas al final de la cadena s. La asignación es necesaria porque rstripdevuelve una nueva cadena en lugar de modificar la cadena original.

Esto replicaría exactamente el chomp de perl (menos el comportamiento en las matrices) para el terminador de línea "\ 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

(Nota: no modifica la cadena 'en su lugar'; no elimina los espacios en blanco finales adicionales; toma \ r \ n en cuenta)

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

o siempre puedes ser más geek con regexps :)

¡que te diviertas!

puedes usar strip:

line = line.strip()

manifestación:

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

rstrip no hace lo mismo que chomp, en muchos niveles. Lea http://perldoc.perl.org/functions/chomp.html y vea que chomp es muy complejo.

Sin embargo, mi punto principal es que chomp elimina como máximo 1 final de línea, mientras que rstrip eliminará la mayor cantidad posible.

Aquí puede ver rstrip eliminando todas las líneas nuevas:

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

Una aproximación mucho más cercana del uso típico de Perl Chomp se puede lograr con re.sub, así:

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

Cuidado con "foo".rstrip(os.linesep): Eso solo machacará los caracteres de nueva línea para la plataforma donde se está ejecutando su Python. Imagine que está cambiando las líneas de un archivo de Windows en Linux, por ejemplo:

$ 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 en su "foo".rstrip("\r\n")lugar, como Mike dice anteriormente.

Un ejemplo en la documentación de Python simplemente usa line.strip().

La chompfunción de Perl elimina una secuencia de salto de línea del final de una cadena solo si realmente está allí.

Aquí es cómo planeo hacer eso en Python, si processconceptualmente es la función que necesito para hacer algo útil en cada línea de este archivo:

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)

No programo en Python, pero encontré un FAQ en python.org que abogaba por S.rstrip ("\ r \ n") para python 2.2 o posterior.

import re

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

Me parece conveniente poder obtener las líneas cortadas a través de un iterador, en paralelo a la forma en que puede obtener las líneas no cortadas de un objeto de archivo. Puedes hacerlo con el siguiente código:

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

Uso de la muestra:

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

solución alternativa para casos especiales:

si el carácter de nueva línea es el último carácter (como es el caso con la mayoría de las entradas de archivo), entonces, para cualquier elemento de la colección, puede indexar de la siguiente manera:

foobar= foobar[:-1]

para cortar tu personaje de nueva línea.

Si su pregunta es limpiar todos los saltos de línea en un objeto str de varias líneas (oldstr), puede dividirlo en una lista de acuerdo con el delimitador '\ n' y luego unir esta lista en un nuevo str (newstr).

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

Parece que no hay un análogo perfecto para el chomp de Perl . En particular, rstrip no puede manejar delimitadores de nueva línea de caracteres múltiples como \r\n. Sin embargo, splitlines hace lo que se señala aquí . Siguiendo mi respuesta en una pregunta diferente, puede combinar unir y dividir líneas para eliminar / reemplazar todas las nuevas líneas de una cadena s:

''.join(s.splitlines())

Lo siguiente elimina exactamente una nueva línea final (como lo haría chomp, creo). Pasando Truecomo keependsargumento a las líneas divisorias se retienen los delimitadores. Luego, se vuelve a llamar a splitlines para eliminar los delimitadores de la última "línea":

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

Estoy aumentando mi respuesta basada en expresiones regulares de una que publiqué anteriormente en los comentarios de otra respuesta. Creo que usar rees una solución más clara y explícita para este problema que str.rstrip.

>>> import re

Si desea eliminar uno o más caracteres de nueva línea finales :

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

Si desea eliminar caracteres de nueva línea en todas partes (no solo al final):

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

Si desea eliminar sólo 1-2 caracteres salto de línea final (es decir, \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'

Tengo la sensación de que lo que la mayoría de la gente realmente quiere aquí es eliminar solo una ocurrencia de un personaje de nueva línea final, ya sea \r\no \nnada más.

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

(Los ?: objetivo es crear un grupo sin captura).

(Por cierto, esto no es lo '...'.rstrip('\n', '').rstrip('\r', '')que no está claro para otros que se topan con este hilo. str.rstripQuita la mayor cantidad posible de caracteres finales, por lo que una cadena como foo\n\n\nresultaría en un falso positivo foomientras que es posible que haya querido preservar el otras líneas nuevas después de quitar una sola final).

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

Solo usa :

line = line.rstrip("\n")

o

line = line.strip("\n")

No necesitas nada de estas cosas complicadas

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'

Con expresiones regulares

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

Reemplazar \ n, \ t, \ r

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

Con expresiones regulares

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

con Join

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

Hay tres tipos de finales de línea que normalmente encontramos: \n, \ry \r\n. Una expresión regular bastante simple en re.sub, a saberr"\r?\n?$" , es capaz de atraparlos a todos.

(Y tenemos que atraparlos a todos , ¿estoy en lo cierto?)

import re

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

Con el último argumento, limitamos el número de ocurrencias reemplazadas a una, imitando en cierta medida chomp. Ejemplo:

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)

... donde a == b == cesta True.

Si le preocupa la velocidad (digamos que tiene una larga lista de cadenas) y conoce la naturaleza del carácter de nueva línea, el corte de cadenas es en realidad más rápido que rstrip. Una pequeña prueba para ilustrar esto:

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

Salida:

Method 1: 3.92700004578
Method 2: 6.73000001907

Esto funcionará tanto para Windows como para Linux (un poco caro con re sub si está buscando solo una solución)

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

Primero divide las líneas y luego únelas por cualquier separador que quieras:

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

debería funcionar como un encanto.

Una trampa para todos:

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