후행 줄 바꿈을 제거하려면 어떻게해야합니까?

chomp문자열이 줄 바꿈 인 경우 문자열의 마지막 문자를 제거하는 Perl 함수 와 동등한 Python은 무엇입니까 ?

방법을 시도 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'

그리고 줄 바꿈 문자없이 줄을 얻는 "pythonic"방법은 splitlines ()라고 말합니다.

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

줄 끝 (EOL) 문자를 제거하는 정식 방법은 문자열 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'

rstrip의 매개 변수로 '\ r \ n'을 사용하면 '\ 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"

rstrip은 문자열을 수정하지 않기 때문에 Perl의 chomp ()와 똑같이 작동하지 않습니다. 즉, Perl에서 :

$x="a\n";

chomp $x

결과 $x것 "a".

그러나 파이썬에서는 :

x="a\n"

x.rstrip()

의 값 x이 여전히 임을 의미합니다 "a\n". 심지어 x=x.rstrip()줄 바꿈이 아니라 문자열 끝에서 모든 공백을 제거하기 때문에 항상 동일한 결과를 제공하지는 않습니다.

나는 이런 식으로 사용할 수 있습니다 :

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

문제 rstrip("\n")는 아마도 라인 분리기가 이식 가능한지 확인하고 싶을 것입니다. (일부 구식 시스템은 사용한다는 소문이 있습니다 "\r\n"). 다른 단점은 rstrip반복되는 공백을 제거 한다는 것입니다. 바라건대 os.linesep올바른 문자가 포함 되기를 바랍니다 . 위의 내용은 저에게 효과적입니다.

을 사용할 수 있습니다 line = line.rstrip('\n'). 이것은 줄 끝이 아니라 줄 끝에서 모든 줄 바꿈을 제거합니다.

s = s.rstrip()

문자열 끝에서 모든 줄 바꿈을 제거합니다 s. rstrip원래 문자열을 수정하는 대신 새 문자열을 반환 하므로 할당이 필요 합니다.

이것은 "\ n"줄 종결 자에 대해 정확하게 perl의 chomp (배열에서 빼기 동작)를 복제합니다.

def chomp(x):
    if x.endswith("\r\n"): return x[:-2]
    if x.endswith("\n") or x.endswith("\r"): return x[:-1]
    return x

(참고 : 문자열 'in place'는 수정하지 않으며 추가 공백을 제거하지 않으며 \ r \ n을 고려합니다)

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

또는 항상 정규 표현식으로 괴짜를 얻을 수 있습니다 :)

재미 있어요!

스트립을 사용할 수 있습니다 :

line = line.strip()

데모:

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

rstrip은 많은 수준에서 chomp와 동일한 기능을 수행하지 않습니다. http://perldoc.perl.org/functions/chomp.html을 읽고 chomp가 실제로 매우 복잡하다는 것을 알 수 있습니다.

그러나 내 주요 요점은 chomp가 최대 1 줄 끝을 제거하는 반면 rstrip은 가능한 한 많은 것을 제거한다는 것입니다.

다음은 모든 줄 바꿈을 제거하는 rstrip을 볼 수 있습니다.

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

다음과 같이 rel을 사용하여 일반적인 Perl chomp 사용법을 훨씬 더 가깝게 추정 할 수 있습니다.

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

주의 사항 "foo".rstrip(os.linesep): 파이썬이 실행되는 플랫폼의 줄 바꿈 문자 만 꽉 채우게됩니다. 예를 들어 Linux에서 Windows 파일의 라인을 침식한다고 상상해보십시오.

$ 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")Mike가 위에서 말한 것처럼 대신 사용하십시오 .

파이썬 문서 의 예제는 단순히을 사용합니다 line.strip().

Perl의 chomp함수는 실제로 문자열이있는 경우에만 문자열 끝에서 하나의 줄 바꿈 시퀀스를 제거합니다.

process개념적 으로이 파일의 각 줄에 유용한 것을 수행하는 데 필요한 함수 인 경우 Python에서 어떻게 할 계획입니까 ?

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)

파이썬으로 프로그래밍하지는 않지만 python.org에서 python 2.2 이상에 대해 S.rstrip ( "\ r \ n")을 옹호 하는 FAQ 를 발견했습니다 .

import re

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

파일 객체에서 촘촘한 줄을 얻는 방법과 평행하게 반복자를 통해 촘촘한 줄을 얻는 것이 편리하다는 것을 알았습니다. 다음 코드를 사용하면됩니다.

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)

특수한 경우에 대한 해결 방법 :

개행 문자가 마지막 문자 인 경우 (대부분의 파일 입력의 경우와 마찬가지로) 컬렉션의 모든 요소에 대해 다음과 같이 색인을 생성 할 수 있습니다.

foobar= foobar[:-1]

줄 바꿈 문자를 잘라냅니다.

질문이 여러 줄 str 객체 (oldstr)에서 모든 줄 바꿈을 정리하는 경우 구분 기호 '\ n'에 따라 목록으로 나누고이 목록을 새 str (newstr)에 결합 할 수 있습니다.

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

perl의 chomp에 대한 완벽한 아날로그가없는 것 같습니다 . 특히 rstrip은와 같은 여러 문자 줄 바꿈 구분자를 처리 할 수 ​​없습니다 \r\n. 그러나 분할 선 은 여기에서 지적한대로 입니다. 다른 질문에 대한 내 대답 에 따라 조인 과 분할 선 을 결합 하여 문자열에서 모든 줄 바꿈을 제거 / 교체 할 수 있습니다 s.

''.join(s.splitlines())

다음은 정확히 하나의 후행 줄 바꿈을 제거합니다 (나는 생각하는 것처럼). 분리선에 True대한 keepends인수로 전달 하면 구분 기호가 유지됩니다. 그런 다음 마지막 "줄"에서 구분 기호를 제거하기 위해 분할 선이 다시 호출됩니다.

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당신이 보존 싶었을 수있는 반면 하나의 후행 줄을 제거한 후 다른 줄 바꿈.)

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

그냥 사용하십시오 :

line = line.rstrip("\n")

또는

line = line.strip("\n")

이 복잡한 물건이 필요하지 않습니다

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'

일반적으로 발생하는 세 가지 유형의 줄 끝이 있습니다. \n,\r 및 \r\n. 의 간단한 정규 표현식 re.sub, 즉r"\r?\n?$" , 그들 모두를 잡을 수있다.

(그리고 우리 모두를 잡아야 해요 , 맞습니까?)

import re

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

마지막 논증으로, 우리는 발생 빈도를 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.

속도에 관심이 있고 (예를 들어, 문자열 목록이 충분하지 않음) 줄 바꿈 문자의 특성을 알고 있으면 문자열 슬라이싱이 실제로 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

이것은 Windows와 Linux 모두에서 작동합니다 (re 해결책 만 찾고 있다면 re sub로 조금 비쌉니다)

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

먼저 분할 선을 원하는 구분 기호로 연결하십시오.

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

매력처럼 작동합니다.

모두 잡아라 :

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