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

Попробуйте метод rstrip() (см. Документы 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 '

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

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

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

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

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

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

И я бы сказал, что «питонический» способ получить строки без завершающих символов новой строки - это splitlines ().

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

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

$x = "a\n";

chomp $x

приводит к тому, что $x является "a".

но в Python:

x = "a\n"

x.rstrip()

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

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

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

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

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

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'

Осторожно с "foo".rstrip(os.linesep): это будет перебирать только символы новой строки для платформы, на которой выполняется ваш 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"), как сказал Майк выше.

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

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

foobar= foobar[:-1]

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

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

или вы всегда можете стать более вызывающим с регулярными выражениями :)

веселиться!

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

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

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

пример в документации 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)

import re

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

Уловить все:

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

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

line = line.strip()

демо:

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

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

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)

s = s.rstrip()

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

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

Если вас беспокоит скорость (например, у вас есть длинный список строк) и вы знаете природу символа новой строки, нарезка строк на самом деле быстрее, чем 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

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

line = line.rstrip("\n")

или же

line = line.strip("\n")

Вам не нужно ничего из этого сложного

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

Обычно мы встречаем три типа окончаний строк: \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.

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

''.join(s.splitlines())

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

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

Я всплываю в своем ответе на основе регулярного выражения из ответа, который я опубликовал ранее в комментариях к другому ответу. Я думаю, что использование 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, тогда как у вас может быть хотел сохранить другие символы новой строки после удаления одной конечной.)

Это будет работать как для Windows, так и для Linux (немного дороже с re sub, если вы ищете только повторное решение)

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

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'

С регулярным выражением

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

Заменить \ n, \ t, \ r

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

С регулярным выражением

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

с присоединением

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