rstrip - strip python




Come posso rimuovere(chomp) una nuova riga finale in Python? (18)

A prendere tutto:

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

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


Attento a "foo".rstrip(os.linesep) : questo farà solo chomp i caratteri newline per la piattaforma su cui viene eseguito il tuo Python. Immagina di frullare 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 invece "foo".rstrip("\r\n") , come dice Mike sopra.


E direi che il modo "pythonic" per ottenere linee senza caratteri di fine riga è splitline ().

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

Esistono tre tipi di terminazioni di linea che normalmente incontriamo: \n , \r e \r\n . Un'espressione regolare piuttosto semplice in re.sub , vale a dire r"\r?\n?$" , È in grado di catturarli tutti.

(E dobbiamo prenderli tutti , ho ragione?)

import re

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

Con l'ultimo argomento, limitiamo il numero di occorrenze sostituite a uno, 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 .


Il modo canonico per eliminare i caratteri di fine riga (EOL) consiste nell'utilizzare il metodo string rstrip () rimuovendo qualsiasi trailing \ 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'

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

Questa sfumatura conta in rari casi. Ad esempio, una volta ho dovuto elaborare un file di testo che conteneva un messaggio HL7. Lo standard HL7 richiede un carattere finale '\ r' 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'utilizzo di rstrip ('\ r \ n') avrebbe tolto l'intero '\ r \ r \ n' che non è quello che volevo. In quel caso, ho semplicemente tagliato gli ultimi due caratteri.

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

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

Non programma in Python, ma mi sono imbattuto in una FAQ su python.org che proponeva S.rstrip ("\ r \ n") per Python 2.2 o successive.


Potrei usare qualcosa del genere:

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

Penso che il problema con rstrip("\n") è che probabilmente vorrai assicurarti che il separatore di riga sia portatile. (si dice che alcuni sistemi antiquati usino "\r\n" ). L'altro risultato è che la rstrip gli spazi bianchi ripetuti. Speriamo che os.linesep conterrà i caratteri giusti. quanto sopra funziona per me.


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

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

Il metodo rstrip() di Python elimina tutti i tipi di spazi bianchi finali per impostazione predefinita, non solo una nuova riga come fa Perl con chomp .

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

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

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 'in place', non spoglia lo spazio bianco extra, ma \ r \ n in considerazione)


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

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


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

''.join(s.splitlines())

Quanto segue rimuove esattamente una nuova riga finale (come credo, credo). Passando True come argomento di keepends alle linee di divisione mantengono i delimitatori. Quindi, lo splitline viene chiamato di nuovo 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 facendo esplodere la mia risposta basata su espressioni regolari da una che ho postato in precedenza nei commenti di un'altra risposta. Penso che l'uso di re sia una soluzione più esplicita a questo problema rispetto a str.rstrip .

>>> import re

Se si desidera rimuovere uno o più caratteri di nuova riga finali :

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

Se si desidera rimuovere i caratteri newline ovunque (non solo alla fine):

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

Se si desidera rimuovere solo 1-2 caratteri finali di nuova riga (ad esempio, \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 la maggior parte delle persone vuole davvero qui, è quella di rimuovere una sola occorrenza di un carattere di fine riga finale, \r\n o \n e nient'altro.

>>> 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 ?: È quello di creare un gruppo non catturante.)

(A proposito, questo non è il tipo '...'.rstrip('\n', '').rstrip('\r', '') fa ciò che potrebbe non essere chiaro agli altri che inciampano su questo thread str.rstrip rimuove il maggior numero possibile di caratteri finali, quindi una stringa come foo\n\n\n risulterebbe in un falso positivo di foo mentre potreste aver voluto conservare le altre newline dopo averne rimosso uno finale.)


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

La funzione chomp di Perl rimuove una sequenza di interruzioni di riga dalla fine di una stringa solo se è effettivamente lì.

Ecco come ho intenzione di farlo in Python, se il process è concettualmente la funzione di cui ho bisogno per fare qualcosa di utile per ogni riga da 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)

puoi usare la striscia:

line = line.strip()

demo:

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

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 nella raccolta è possibile indicizzare come segue:

foobar= foobar[:-1]

per troncare il carattere di nuova riga.


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

o potresti sempre diventare più geeker con espressioni regolari :)

divertiti!


import re

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

s = s.rstrip()

rimuoverà tutte le nuove righe alla fine della stringa s . Il compito è necessario perché rstrip restituisce una nuova stringa invece di modificare la stringa originale.







trailing