Come posso rimuovere una nuova riga finale?

Qual è l'equivalente Python della chompfunzione di Perl , che rimuove l'ultimo carattere di una stringa se è una nuova riga?

Prova il metodo rstrip()(vedi doc Python 2 e Python 3 )

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

Il rstrip()metodo di Python elimina tutti i tipi di spazio bianco finale per impostazione predefinita, non solo una nuova riga come fa Perl chomp.

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

Per eliminare solo le nuove righe:

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

Esistono anche i metodi 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 direi che il modo "pythonic" per ottenere linee senza trascinare i caratteri di nuova riga è diviso ().

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

Il modo canonico di eliminare i caratteri di fine riga (EOL) consiste nell'utilizzare il metodo string rstrip () rimuovendo eventuali tracce finali \ r o \ n. Ecco alcuni esempi di caratteri EOL per Mac, Windows e 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'

L'uso di '\ r \ n' come parametro per rstrip significa che eliminerà qualsiasi combinazione finale di '\ r' o '\ n'. Ecco perché funziona in tutti e tre i casi sopra.

Questa sfumatura è importante in rari casi. Ad esempio, una volta ho dovuto elaborare un file di testo che conteneva un messaggio HL7. Lo standard HL7 richiede un '\ r' finale come carattere EOL. La macchina Windows su cui stavo usando questo messaggio aveva aggiunto il proprio carattere EOL '\ r \ n'. Pertanto, la fine di ogni riga sembrava '\ r \ r \ n'. L'uso di rstrip ('\ r \ n') avrebbe tolto l'intero '\ r \ r \ n' che non è quello che volevo. In tal caso, ho semplicemente semplicemente tagliato gli ultimi due caratteri.

Nota che a differenza della chompfunzione di Perl , questo eliminerà tutti i caratteri specificati alla fine della stringa, non solo uno:

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

Nota che rstrip non si comporta esattamente come il chomp () di Perl perché non modifica la stringa. Cioè, in Perl:

$x="a\n";

chomp $x

risulta in $xessere "a".

ma in Python:

x="a\n"

x.rstrip()

significherà che il valore di xè fermo "a\n" . Anche x=x.rstrip()non dà sempre lo stesso risultato, poiché rimuove tutto lo spazio bianco dalla fine della stringa, non solo una nuova riga al massimo.

Potrei usare qualcosa del genere:

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

Penso che il problema rstrip("\n")sia che probabilmente vorrai assicurarti che il separatore di linea sia portatile. (si dice che alcuni sistemi antiquati vengano utilizzati "\r\n"). L'altro gotcha è che eliminerà rstripgli spazi bianchi ripetuti. Spero os.linesepche conterrà i personaggi giusti. quanto sopra funziona per me.

Puoi usare line = line.rstrip('\n'). Questo eliminerà tutte le nuove righe dalla fine della stringa, non solo una.

s = s.rstrip()

rimuoverà tutte le nuove righe alla fine della stringa s. L'assegnazione è necessaria perché rstriprestituisce una nuova stringa invece di modificare la stringa originale.

Questo replicherebbe esattamente il chomp di perl (meno il comportamento sugli array) per il terminatore di riga "\ 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: non modifica la stringa "sul posto"; non rimuove gli spazi vuoti finali in eccesso; prende in considerazione \ r \ n)

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

o potresti sempre diventare più geek con regexps :)

divertiti!

puoi usare strip:

line = line.strip()

demo:

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

rstrip non fa la stessa cosa di chomp, su così tanti livelli. Leggi http://perldoc.perl.org/functions/chomp.html e vedi che chomp è davvero molto complesso.

Tuttavia, il mio punto principale è che chomp rimuove al massimo 1 finale di riga, mentre rstrip ne rimuoverà il maggior numero possibile.

Qui puoi vedere rstrip che rimuove tutte le nuove righe:

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

Un'approssimazione molto più ravvicinata dell'uso tipico di Chomp Perl può essere realizzata con re.sub, come questo:

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

Attenzione "foo".rstrip(os.linesep): ciò comporterà solo i caratteri di nuova riga per la piattaforma in cui viene eseguito Python. Immagina di scartare le linee di un file Windows sotto Linux, ad esempio:

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

Usa "foo".rstrip("\r\n")invece, come dice Mike sopra.

Un esempio nella documentazione di Python usa semplicemente line.strip().

La chompfunzione di Perl rimuove una sequenza di interruzioni di riga dalla fine di una stringa solo se è effettivamente presente.

Ecco come ho intenzione di farlo in Python, se processconcettualmente è la funzione di cui ho bisogno per fare qualcosa di utile per ogni riga di questo file:

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)

Non programma in Python, ma ho trovato una FAQ su python.org a sostegno di S.rstrip ("\ r \ n") per Python 2.2 o versioni successive.

import re

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

Trovo conveniente poter essere in grado di ottenere le linee tratteggiate tramite in iteratore, parallelamente al modo in cui è possibile ottenere le linee non tratteggiate da un oggetto file. Puoi farlo con il seguente codice:

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

Esempio di utilizzo:

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

soluzione alternativa per casi speciali:

se il carattere di nuova riga è l'ultimo carattere (come nel caso della maggior parte degli input di file), quindi per qualsiasi elemento della raccolta è possibile indicizzare come segue:

foobar= foobar[:-1]

per dividere il tuo personaggio newline.

Se la tua domanda è di ripulire tutte le interruzioni di riga in un oggetto str a più righe (oldstr), puoi dividerlo in un elenco in base al delimitatore '\ n' e quindi unire questo elenco in un nuovo str (newstr).

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

Sembra che non ci sia un analogo perfetto per il chomp di Perl . In particolare, rstrip non può gestire delimitatori newline multi-carattere come \r\n. Tuttavia, le linee di divisione fanno come indicato qui . Seguendo la mia risposta su una domanda diversa, è possibile combinare join e linee di divisione per rimuovere / sostituire tutte le nuove righe da una stringa s:

''.join(s.splitlines())

Quanto segue rimuove esattamente una nuova riga finale (come direbbe chomp). Il passaggio Truecome keependsargomento alle linee di divisione mantiene i delimitatori. Quindi, le linee di divisione vengono nuovamente chiamate per rimuovere i delimitatori solo sull'ultima "linea":

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

Sto ribollendo la mia risposta basata sull'espressione regolare da una che ho pubblicato in precedenza nei commenti di un'altra risposta. Penso che l'utilizzo resia una soluzione più chiara a questo problema rispetto a str.rstrip.

>>> import re

Se si desidera rimuovere uno o più caratteri newline finali :

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

Se vuoi rimuovere i caratteri newline ovunque (non solo in coda):

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

Se si desidera rimuovere solo 1-2 trascinamento caratteri di nuova linea (cioè \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'

Ho la sensazione che ciò che la maggior parte della gente vuole davvero qui, è di rimuovere solo una ricorrenza di un personaggio newline finale, o \r\no \ne niente di più.

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

(Il ?: per creare un gruppo non di acquisizione.)

(A proposito, questo non è ciò '...'.rstrip('\n', '').rstrip('\r', '')che potrebbe non essere chiaro agli altri inciampare su questo thread. str.rstripSpoglia il maggior numero possibile di caratteri finali, quindi una stringa simile foo\n\n\ncomporterebbe un falso positivo di foomentre potresti aver voluto preservare il altre nuove righe dopo aver rimosso una singola traccia.)

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

Usa solo:

line = line.rstrip("\n")

o

line = line.strip("\n")

Non hai bisogno di nessuna di queste cose complicate

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 regex

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

Sostituisci \ n, \ t, \ r

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

Con regex

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'

Ci sono tre tipi di fine riga che normalmente incontriamo: \n, \re \r\n. Un'espressione regolare piuttosto semplice in re.sub, vale a direr"\r?\n?$" , è in grado di catturarli tutti.

(E dobbiamo prenderli tutti , vero?)

import re

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

Con l'ultimo argomento, limitiamo il numero di occorrenze sostituite a una, imitando in qualche misura il chomp. Esempio:

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)

... dove a == b == cè True.

Se sei preoccupato per la velocità (supponi di avere un elenco di stringhe troppo lungo) e conosci la natura del carattere newline, l'affettatura delle stringhe è effettivamente più veloce di rstrip. Un piccolo test per illustrare questo:

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

Produzione:

Method 1: 3.92700004578
Method 2: 6.73000001907

Funzionerà sia per Windows che per Linux (un po 'caro con re-sub se stai cercando solo una soluzione)

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

Prima dividi le linee quindi uniscile con qualsiasi separatore che ti piace:

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

dovrebbe funzionare come un incantesimo.

Una cattura tutto:

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