Как я могу удалить завершающий перевод строки?

Ответ 1

Попробуйте метод rstrip() (см. doc Python 2 и Python 3)

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

Метод Python rstrip() по умолчанию разделяет все виды конечных пробелов, а не одну новую строку, как Perl делает с chomp.

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

Чтобы удалить только символы новой строки:

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

Существуют также методы lstrip() и 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'

Ответ 2

И я бы сказал, что "pythonic" способ получить строки без конечных символов новой строки - splitlines().

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

Ответ 3

Канонический способ стирания символов конца строки (EOL) заключается в использовании метода string rstrip(), удаляющего любые конечные \r или\n. Ниже приведены примеры символов Mac, Windows и 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'

Использование '\ r\n' в качестве параметра для rstrip означает, что оно будет лишать любую конечную комбинацию '\ r' или '\n'. Вот почему он работает во всех трех случаях выше.

Этот нюанс имеет значение в редких случаях. Например, однажды мне пришлось обработать текстовый файл, содержащий сообщение HL7. Стандарт HL7 требует, чтобы в качестве символа EOL использовался конечный "\ r". Машина Windows, на которой я использовала это сообщение, добавила свой собственный символ "\ r\n" EOL. Поэтому конец каждой строки выглядел как "\ r\r\n". Использование rstrip ('\ r\n') удалило бы все "\ r\r\n", чего я не хотел. В этом случае я просто нарезал последние два символа.

Обратите внимание, что в отличие от функции Perl chomp это приведет к удалению всех указанных символов в конце строки, а не только к одному:

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

Ответ 4

Обратите внимание, что rstrip не действует точно так же, как Perl chomp(), потому что он не изменяет строку. То есть, в Perl:

$x="a\n";

chomp $x

приводит к $x "a".

но в Python:

x="a\n"

x.rstrip()

будет означать, что значение x еще "a\n". Даже x=x.rstrip() не всегда дает тот же результат, поскольку он удаляет все пробелы из конца строки, а не только одну новую строку.

Ответ 5

Я мог бы использовать что-то вроде этого:

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

Я думаю, что проблема с rstrip("\n") заключается в том, что вы, вероятно, захотите убедиться, что разделитель строк переносится. (некоторые устаревшие системы, по слухам, используют "\r\n"). Другой способ заключается в том, что rstrip будет удалять повторяющиеся пробелы. Надеемся, что os.linesep будет содержать правильные символы. это работает для меня.

Ответ 6

Вы можете использовать line = line.rstrip('\n'). Это разделит все строки новой строки от конца строки, а не только на одну.

Ответ 7

s = s.rstrip()

удалит все строки новой строки в конце строки s. Назначение необходимо, потому что rstrip возвращает новую строку вместо изменения исходной строки.

Ответ 8

Это будет точно реплицировать perl chomp (минус поведение на массивах) для терминатора строки "\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

(Примечание: он не изменяет строку "на месте", она не разделяет лишние пробелы, принимает \r\n в учетной записи)

Ответ 9

вы можете использовать полосу:

line = line.strip()

демо:

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

Ответ 10

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

или вы всегда можете получить geekier с регулярными выражениями:)

получайте удовольствие!

Ответ 11

Осторожно с "foo".rstrip(os.linesep): это будет только chomp символы новой строки для платформы, на которой выполняется ваш Python. Представьте, что вы подбираете строки файла Windows под Linux, например:

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

Используйте "foo".rstrip("\r\n") вместо этого, как сказал Майк выше.

Ответ 12

пример в документации по Python просто использует line.strip().

Функция Perl chomp удаляет одну последовательность разрыва строки из конца строки, только если она действительно есть.

Вот как я планирую сделать это в Python, если process концептуально является функцией, которая мне нужна, чтобы сделать что-то полезное для каждой строки из этого файла:

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)

Ответ 13

rstrip не делает то же самое, что и chomp, на стольких уровнях. Прочитайте http://perldoc.perl.org/functions/chomp.html и убедитесь, что chomp очень сложный.

Однако, мой основной момент состоит в том, что chomp удаляет не более 1 строки, тогда как rstrip удаляет столько, сколько может.

Здесь вы можете увидеть, что rstrip удаляет все строки новой строки:

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

Более близкое приближение типичного использования Perl chomp может быть выполнено с помощью re.sub, например:

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

Ответ 14

Я не программирую в Python, но я наткнулся на FAQ на python.org, выступая за S.rstrip( "\r\n" ) для python 2.2 или новее.

Ответ 15

import re

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

Ответ 16

Если ваш вопрос состоит в том, чтобы очистить все разрывы строк в объекте с несколькими строками str (oldstr), вы можете разбить его на список в соответствии с разделителем '\n', а затем соединить этот список с новой str (newstr).

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

Ответ 17

Мне удобно иметь возможность получать перебранные строки через итератор, параллельно тому, как вы можете получить строки с неперехваченными линиями из файлового объекта. Вы можете сделать это со следующим кодом:

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

Использование образца:

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

Ответ 18

обходное решение для специального случая:

если символ новой строки является последним символом (как в случае с большинством входов файлов), то для любого элемента в коллекции вы можете индексировать следующее:

foobar= foobar[:-1]

чтобы вырезать символ новой строки.

Ответ 19

Похоже, что нет идеального аналога для perl chomp. В частности, rstrip не может обрабатывать многосимвольные разделители новой строки, такие как \r\n. Однако разделительные линии делают , как указано здесь. Следуя моему ответу на другой вопрос, вы можете объединить объединить и разделительные линии, чтобы удалить/заменить все новые строки в строке s:

''.join(s.splitlines())

Следующее удаляет ровно одну завершающую новую строку (как я полагаю, chomp). Передача True в качестве аргумента keepends для разделенных линий сохраняет разделители. Затем снова вызывается splitline, чтобы удалить разделители только на последней "строке":

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

Ответ 20

Я поднимаю свой ответ на основе регулярных выражений от одного, который я опубликовал ранее в комментариях к другому ответу. Я думаю, что использование re является более явным более явным решением этой проблемы, чем str.rstrip.

>>> import re

Если вы хотите удалить один или несколько завершающих символов новой строки:

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

Если вы хотите удалить символы новой строки везде (а не только трейлинг):

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

Если вы хотите удалить только 1-2 конечных символа новой строки (т.е. \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'

Я чувствую, что большинство людей действительно хочет здесь, - это удалить только одно появление символа новой строки, либо \r\n либо \n и ничего больше.

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

(" ?: - создать группу, не связанную с захватом).

(Кстати, это не то, что '...'.rstrip('\n', '').rstrip('\r', ''), что может быть непонятным для других, преследующих этот поток str.rstrip как можно больше символов завершающего символа, поэтому строка, подобная foo\n\n\n приведет к ложному положительному результату foo тогда как вы, возможно, захотите сохранить другие символы новой строки после удаления одного завершающего символа.)

Ответ 21

Используя str. rstrip([chars])

Здесь мы говорим Официальная полная документация Нажмите здесь

Ответ 22

Просто используйте:

line = line.rstrip("\n")

или

line = line.strip("\n")

Вам не нужен какой-либо из этих сложных вещей

Ответ 23

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

Ответ 24

Существует три типа окончаний строк, которые мы обычно встречаем: \n, \r и \r\n. Достаточно простое регулярное выражение в re.sub, а именно r"\r?\n?$", способно их поймать.

(И мы должны поймать их всех, я прав?)

import re

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

С последним аргументом мы ограничиваем количество замещений замененными на одно, имитируя chomp до некоторой степени. Пример:

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)

... где a == b == c True.

Ответ 25

Это будет работать как для windows, так и для linux (бит дорогостоящий с повторным подключением, если вы ищете только новое решение)

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

Ответ 26

Если вас беспокоит скорость (скажем, у вас есть список строк), и вы знаете природу новой строки char, нарезка строк на самом деле быстрее, чем rstrip. Небольшой тест, чтобы проиллюстрировать это:

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

Вывод:

Method 1: 3.92700004578
Method 2: 6.73000001907

Ответ 27

    s = '''d2234 d45564 d223098 d50923 PETY_354_d3456 d76533
d2635 PETY_354 d88593 d324623 HUI_6478_d3553d35626'''
    s.replace(" ", "")
    >>'d2234d45564d223098d50923PETY_354_d3456d76533\nd2635PETY_354d88593d324623HUI_6478_d3553d35626'

    import string
    s.translate({ord(c): None for c in string.whitespace})
>>'d2234d45564d223098d50923PETY_354_d3456d76533d2635PETY_354d88593d324623HUI_6478_d3553d35626'

Ответ 28

Ухватить все:

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