Comment supprimer une nouvelle ligne de fin?

Quel est l'équivalent Python de la chompfonction de Perl , qui supprime le dernier caractère d'une chaîne s'il s'agit d'une nouvelle ligne?

Essayez la méthode rstrip()(voir doc Python 2 et Python 3 )

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

La rstrip()méthode de Python supprime toutes sortes d'espaces blancs par défaut, pas seulement une nouvelle ligne comme Perl le fait chomp.

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

Pour supprimer uniquement les retours à la ligne:

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

Il y a aussi les méthodes lstrip()et 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'

Et je dirais que la méthode "pythonique" pour obtenir des lignes sans suivre les caractères de retour à la ligne est splitlines ().

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

La manière canonique de supprimer les caractères de fin de ligne (EOL) consiste à utiliser la méthode chaîne rstrip () en supprimant tout \ r ou \ n de fin. Voici des exemples de caractères EOL pour Mac, Windows et 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'utilisation de '\ r \ n' comme paramètre pour rstrip signifie qu'il supprimera toute combinaison finale de '\ r' ou '\ n'. C'est pourquoi cela fonctionne dans les trois cas ci-dessus.

Cette nuance est importante dans de rares cas. Par exemple, j'ai dû traiter une fois un fichier texte contenant un message HL7. La norme HL7 requiert un «\ r» de fin comme caractère EOL. La machine Windows sur laquelle j'utilisais ce message avait ajouté son propre caractère EOL '\ r \ n'. Par conséquent, la fin de chaque ligne ressemblait à «\ r \ r \ n». Utiliser rstrip ('\ r \ n') aurait enlevé tout le '\ r \ r \ n' qui n'est pas ce que je voulais. Dans ce cas, j'ai simplement coupé les deux derniers caractères à la place.

Notez que contrairement à la chompfonction de Perl , cela supprimera tous les caractères spécifiés à la fin de la chaîne, pas un seul:

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

Notez que rstrip n'agit pas exactement comme chomp () de Perl car il ne modifie pas la chaîne. Autrement dit, en Perl:

$x="a\n";

chomp $x

se traduit par l' $xêtre "a".

mais en Python:

x="a\n"

x.rstrip()

signifie que la valeur de xest toujours "a\n" . Même x=x.rstrip()ne donne pas toujours le même résultat, car il supprime tous les espaces à la fin de la chaîne, pas un seul saut de ligne au plus.

Je pourrais utiliser quelque chose comme ça:

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

Je pense que le problème rstrip("\n")est que vous voudrez probablement vous assurer que le séparateur de ligne est portable. (certains systèmes archaïques seraient utilisés "\r\n"). L'autre problème est que rstriples espaces blancs répétés seront supprimés. Espérons os.linesepqu'il contiendra les bons personnages. ce qui précède fonctionne pour moi.

Vous pouvez utiliser line = line.rstrip('\n'). Cela supprimera tous les sauts de ligne de la fin de la chaîne, pas un seul.

s = s.rstrip()

supprimera toutes les nouvelles lignes à la fin de la chaîne s. L'affectation est nécessaire car rstriprenvoie une nouvelle chaîne au lieu de modifier la chaîne d'origine.

Cela reproduirait exactement le chomp de perl (comportement moins sur les tableaux) pour le terminateur de ligne "\ 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

(Remarque: il ne modifie pas la chaîne "en place"; il ne supprime pas les espaces de fin supplémentaires; prend \ r \ n en compte)

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

ou vous pourriez toujours devenir plus geek avec des expressions rationnelles :)

s'amuser!

vous pouvez utiliser la bande:

line = line.strip()

démo:

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

rstrip ne fait pas la même chose que chomp, sur tant de niveaux. Lisez http://perldoc.perl.org/functions/chomp.html et voyez que chomp est vraiment très complexe.

Cependant, mon point principal est que chomp supprime au plus 1 fin de ligne, tandis que rstrip en supprimera autant que possible.

Ici, vous pouvez voir rstrip supprimer toutes les nouvelles lignes:

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

Une approximation beaucoup plus proche de l'utilisation typique de chomp Perl peut être accomplie avec re.sub, comme ceci:

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

Attention à "foo".rstrip(os.linesep): cela ne fera que couper les caractères de nouvelle ligne pour la plate-forme sur laquelle votre Python est exécuté. Imaginez que vous trafiquez les lignes d'un fichier Windows sous Linux, par exemple:

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

Utilisez "foo".rstrip("\r\n")plutôt, comme Mike l'a dit ci-dessus.

Un exemple dans la documentation de Python utilise simplement line.strip().

La chompfonction de Perl supprime une séquence de saut de ligne de la fin d'une chaîne uniquement si elle est réellement là.

Voici comment je prévois de le faire en Python, si processc'est conceptuellement la fonction dont j'ai besoin pour faire quelque chose d'utile à chaque ligne de ce fichier:

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)

Je ne programme pas en Python, mais je suis tombé sur une FAQ sur python.org préconisant S.rstrip ("\ r \ n") pour python 2.2 ou version ultérieure.

import re

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

Je trouve pratique d'avoir pu obtenir les lignes hachées via l'itérateur, parallèlement à la façon dont vous pouvez obtenir les lignes non hachées à partir d'un objet fichier. Vous pouvez le faire avec le code suivant:

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

Exemple d'utilisation:

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

solution de contournement pour un cas spécial:

si le caractère de nouvelle ligne est le dernier caractère (comme c'est le cas avec la plupart des entrées de fichier), alors pour tout élément de la collection, vous pouvez indexer comme suit:

foobar= foobar[:-1]

pour découper votre caractère de nouvelle ligne.

Si votre question est de nettoyer tous les sauts de ligne dans un objet chaîne à plusieurs lignes (oldstr), vous pouvez le diviser en une liste en fonction du délimiteur '\ n', puis joindre cette liste en une nouvelle chaîne (newstr).

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

Il semble qu'il n'y ait pas d'analogue parfait pour le chomp de Perl . En particulier, rstrip ne peut pas gérer les délimiteurs de nouvelle ligne multi-caractères comme \r\n. Cependant, splitlines fait comme indiqué ici . Suite à ma réponse à une autre question, vous pouvez combiner jointure et splitlines pour supprimer / remplacer tous les retours à la ligne d'une chaîne s:

''.join(s.splitlines())

Ce qui suit supprime exactement une nouvelle ligne de fin (comme le ferait chomp, je crois). Passer Truecomme keependsargument aux lignes de séparation conserve les délimiteurs. Ensuite, splitlines est appelé à nouveau pour supprimer les délimiteurs sur la dernière "ligne" uniquement:

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

Je bouillonne ma réponse basée sur l'expression régulière de celle que j'ai publiée plus tôt dans les commentaires d'une autre réponse. Je pense que l'utilisation reest une solution plus claire et explicite à ce problème que str.rstrip.

>>> import re

Si vous souhaitez supprimer un ou plusieurs caractères de fin de ligne:

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

Si vous souhaitez supprimer les caractères de nouvelle ligne partout (pas seulement à la fin):

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

Si vous voulez supprimer seulement 1-2 caractères de nouvelle ligne de fuite (c. -à- \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'

J'ai l'impression que la plupart des gens veulent vraiment ici, c'est supprimer une seule occurrence d'un caractère de fin de ligne, soit \r\nou \net rien de plus.

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

(Le ?: s'agit de créer un groupe non capturant.)

(Soit dit en passant, ce n'est pas ce '...'.rstrip('\n', '').rstrip('\r', '')qui ne peut être clair pour les autres qui tombent sur ce fil. str.rstripSupprime autant de caractères de fin que possible, donc une chaîne comme foo\n\n\ncela entraînerait un faux positif fooalors que vous souhaitiez peut-être conserver le d'autres sauts de ligne après en avoir retiré un.)

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

Utilisez simplement:

line = line.rstrip("\n")

ou

line = line.strip("\n")

Vous n'avez besoin d'aucune de ces choses compliquées

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'

Avec regex

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

Remplacer \ n, \ t, \ r

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

Avec regex

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

avec Join

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

Il existe trois types de terminaisons de ligne que l' on rencontre normalement: \n, \ret \r\n. Une expression régulière assez simple dans re.sub, à savoir r"\r?\n?$", est capable de tous les attraper.

(Et nous devons tous les attraper , ai-je raison?)

import re

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

Avec le dernier argument, nous limitons le nombre d'occurrences remplacées à un, imitant le chomp dans une certaine mesure. Exemple:

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)

... où a == b == cest True.

Si vous êtes préoccupé par la vitesse (disons que vous avez une longue liste de chaînes) et que vous connaissez la nature du caractère de nouvelle ligne, le découpage des chaînes est en fait plus rapide que rstrip. Un petit test pour illustrer cela:

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

Production:

Method 1: 3.92700004578
Method 2: 6.73000001907

Cela fonctionnera à la fois pour Windows et Linux (peu coûteux avec re sub si vous recherchez uniquement une solution re)

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

Commencez par séparer les lignes par le séparateur de votre choix:

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

devrait fonctionner comme un charme.

Un fourre-tout:

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